2709 lines
75 KiB
Markdown
2709 lines
75 KiB
Markdown
# \AdminAPI
|
|
|
|
All URIs are relative to *http://localhost*
|
|
|
|
Method | HTTP request | Description
|
|
------------- | ------------- | -------------
|
|
[**AnswerAdminApiAnswerPageGet**](AdminAPI.md#AnswerAdminApiAnswerPageGet) | **Get** /answer/admin/api/answer/page | AdminAnswerPage admin answer page
|
|
[**AnswerAdminApiAnswerStatusPut**](AdminAPI.md#AnswerAdminApiAnswerStatusPut) | **Put** /answer/admin/api/answer/status | AdminSetAnswerStatus
|
|
[**AnswerAdminApiDashboardGet**](AdminAPI.md#AnswerAdminApiDashboardGet) | **Get** /answer/admin/api/dashboard | DashboardInfo
|
|
[**AnswerAdminApiQuestionPageGet**](AdminAPI.md#AnswerAdminApiQuestionPageGet) | **Get** /answer/admin/api/question/page | AdminQuestionPage admin question page
|
|
[**AnswerAdminApiQuestionStatusPut**](AdminAPI.md#AnswerAdminApiQuestionStatusPut) | **Put** /answer/admin/api/question/status | AdminSetQuestionStatus
|
|
[**AnswerAdminApiReportPut**](AdminAPI.md#AnswerAdminApiReportPut) | **Put** /answer/admin/api/report/ | handle flag
|
|
[**AnswerAdminApiReportsPageGet**](AdminAPI.md#AnswerAdminApiReportsPageGet) | **Get** /answer/admin/api/reports/page | list report page
|
|
[**AnswerAdminApiRolesGet**](AdminAPI.md#AnswerAdminApiRolesGet) | **Get** /answer/admin/api/roles | get role list
|
|
[**AnswerAdminApiSettingPrivilegesGet**](AdminAPI.md#AnswerAdminApiSettingPrivilegesGet) | **Get** /answer/admin/api/setting/privileges | GetPrivilegesConfig get privileges config
|
|
[**AnswerAdminApiSettingPrivilegesPut**](AdminAPI.md#AnswerAdminApiSettingPrivilegesPut) | **Put** /answer/admin/api/setting/privileges | update privileges config
|
|
[**AnswerAdminApiSettingSmtpGet**](AdminAPI.md#AnswerAdminApiSettingSmtpGet) | **Get** /answer/admin/api/setting/smtp | GetSMTPConfig get smtp config
|
|
[**AnswerAdminApiSettingSmtpPut**](AdminAPI.md#AnswerAdminApiSettingSmtpPut) | **Put** /answer/admin/api/setting/smtp | update smtp config
|
|
[**AnswerAdminApiSiteinfoBrandingGet**](AdminAPI.md#AnswerAdminApiSiteinfoBrandingGet) | **Get** /answer/admin/api/siteinfo/branding | get site interface
|
|
[**AnswerAdminApiSiteinfoBrandingPut**](AdminAPI.md#AnswerAdminApiSiteinfoBrandingPut) | **Put** /answer/admin/api/siteinfo/branding | update site info branding
|
|
[**AnswerAdminApiSiteinfoCustomCssHtmlGet**](AdminAPI.md#AnswerAdminApiSiteinfoCustomCssHtmlGet) | **Get** /answer/admin/api/siteinfo/custom-css-html | get site info custom html css config
|
|
[**AnswerAdminApiSiteinfoCustomCssHtmlPut**](AdminAPI.md#AnswerAdminApiSiteinfoCustomCssHtmlPut) | **Put** /answer/admin/api/siteinfo/custom-css-html | update site custom css html config
|
|
[**AnswerAdminApiSiteinfoGeneralGet**](AdminAPI.md#AnswerAdminApiSiteinfoGeneralGet) | **Get** /answer/admin/api/siteinfo/general | get site general information
|
|
[**AnswerAdminApiSiteinfoGeneralPut**](AdminAPI.md#AnswerAdminApiSiteinfoGeneralPut) | **Put** /answer/admin/api/siteinfo/general | update site general information
|
|
[**AnswerAdminApiSiteinfoInterfaceGet**](AdminAPI.md#AnswerAdminApiSiteinfoInterfaceGet) | **Get** /answer/admin/api/siteinfo/interface | get site interface
|
|
[**AnswerAdminApiSiteinfoInterfacePut**](AdminAPI.md#AnswerAdminApiSiteinfoInterfacePut) | **Put** /answer/admin/api/siteinfo/interface | update site info interface
|
|
[**AnswerAdminApiSiteinfoLegalGet**](AdminAPI.md#AnswerAdminApiSiteinfoLegalGet) | **Get** /answer/admin/api/siteinfo/legal | Set the legal information for the site
|
|
[**AnswerAdminApiSiteinfoLegalPut**](AdminAPI.md#AnswerAdminApiSiteinfoLegalPut) | **Put** /answer/admin/api/siteinfo/legal | update site legal info
|
|
[**AnswerAdminApiSiteinfoLoginGet**](AdminAPI.md#AnswerAdminApiSiteinfoLoginGet) | **Get** /answer/admin/api/siteinfo/login | get site info login config
|
|
[**AnswerAdminApiSiteinfoLoginPut**](AdminAPI.md#AnswerAdminApiSiteinfoLoginPut) | **Put** /answer/admin/api/siteinfo/login | update site login
|
|
[**AnswerAdminApiSiteinfoSeoGet**](AdminAPI.md#AnswerAdminApiSiteinfoSeoGet) | **Get** /answer/admin/api/siteinfo/seo | get site seo information
|
|
[**AnswerAdminApiSiteinfoSeoPut**](AdminAPI.md#AnswerAdminApiSiteinfoSeoPut) | **Put** /answer/admin/api/siteinfo/seo | update site seo information
|
|
[**AnswerAdminApiSiteinfoThemeGet**](AdminAPI.md#AnswerAdminApiSiteinfoThemeGet) | **Get** /answer/admin/api/siteinfo/theme | get site info theme config
|
|
[**AnswerAdminApiSiteinfoThemePut**](AdminAPI.md#AnswerAdminApiSiteinfoThemePut) | **Put** /answer/admin/api/siteinfo/theme | update site custom css html config
|
|
[**AnswerAdminApiSiteinfoUsersGet**](AdminAPI.md#AnswerAdminApiSiteinfoUsersGet) | **Get** /answer/admin/api/siteinfo/users | get site user config
|
|
[**AnswerAdminApiSiteinfoUsersPut**](AdminAPI.md#AnswerAdminApiSiteinfoUsersPut) | **Put** /answer/admin/api/siteinfo/users | update site info config about users
|
|
[**AnswerAdminApiSiteinfoWriteGet**](AdminAPI.md#AnswerAdminApiSiteinfoWriteGet) | **Get** /answer/admin/api/siteinfo/write | get site interface
|
|
[**AnswerAdminApiSiteinfoWritePut**](AdminAPI.md#AnswerAdminApiSiteinfoWritePut) | **Put** /answer/admin/api/siteinfo/write | update site write info
|
|
[**AnswerAdminApiThemeOptionsGet**](AdminAPI.md#AnswerAdminApiThemeOptionsGet) | **Get** /answer/admin/api/theme/options | Get theme options
|
|
[**AnswerAdminApiUserActivationGet**](AdminAPI.md#AnswerAdminApiUserActivationGet) | **Get** /answer/admin/api/user/activation | get user activation
|
|
[**AnswerAdminApiUserPasswordPut**](AdminAPI.md#AnswerAdminApiUserPasswordPut) | **Put** /answer/admin/api/user/password | update user password
|
|
[**AnswerAdminApiUserPost**](AdminAPI.md#AnswerAdminApiUserPost) | **Post** /answer/admin/api/user | add user
|
|
[**AnswerAdminApiUserRolePut**](AdminAPI.md#AnswerAdminApiUserRolePut) | **Put** /answer/admin/api/user/role | update user role
|
|
[**AnswerAdminApiUserStatusPut**](AdminAPI.md#AnswerAdminApiUserStatusPut) | **Put** /answer/admin/api/user/status | update user
|
|
[**AnswerAdminApiUsersActivationPost**](AdminAPI.md#AnswerAdminApiUsersActivationPost) | **Post** /answer/admin/api/users/activation | send user activation
|
|
[**AnswerAdminApiUsersPageGet**](AdminAPI.md#AnswerAdminApiUsersPageGet) | **Get** /answer/admin/api/users/page | get user page
|
|
[**AnswerAdminApiUsersPost**](AdminAPI.md#AnswerAdminApiUsersPost) | **Post** /answer/admin/api/users | add users
|
|
|
|
|
|
|
|
## AnswerAdminApiAnswerPageGet
|
|
|
|
> HandlerRespBody AnswerAdminApiAnswerPageGet(ctx).Page(page).PageSize(pageSize).Status(status).Query(query).QuestionId(questionId).Execute()
|
|
|
|
AdminAnswerPage admin answer page
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
page := int32(56) // int32 | page size (optional)
|
|
pageSize := int32(56) // int32 | page size (optional)
|
|
status := "status_example" // string | user status (optional)
|
|
query := "query_example" // string | answer id or question title (optional)
|
|
questionId := "questionId_example" // string | question id (optional)
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiAnswerPageGet(context.Background()).Page(page).PageSize(pageSize).Status(status).Query(query).QuestionId(questionId).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiAnswerPageGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiAnswerPageGet`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiAnswerPageGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiAnswerPageGetRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**page** | **int32** | page size |
|
|
**pageSize** | **int32** | page size |
|
|
**status** | **string** | user status |
|
|
**query** | **string** | answer id or question title |
|
|
**questionId** | **string** | question id |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiAnswerStatusPut
|
|
|
|
> HandlerRespBody AnswerAdminApiAnswerStatusPut(ctx).Data(data).Execute()
|
|
|
|
AdminSetAnswerStatus
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaAdminSetAnswerStatusRequest() // SchemaAdminSetAnswerStatusRequest | AdminSetAnswerStatusRequest
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiAnswerStatusPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiAnswerStatusPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiAnswerStatusPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiAnswerStatusPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiAnswerStatusPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaAdminSetAnswerStatusRequest**](SchemaAdminSetAnswerStatusRequest.md) | AdminSetAnswerStatusRequest |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiDashboardGet
|
|
|
|
> HandlerRespBody AnswerAdminApiDashboardGet(ctx).Execute()
|
|
|
|
DashboardInfo
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiDashboardGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiDashboardGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiDashboardGet`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiDashboardGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiDashboardGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiQuestionPageGet
|
|
|
|
> HandlerRespBody AnswerAdminApiQuestionPageGet(ctx).Page(page).PageSize(pageSize).Status(status).Query(query).Execute()
|
|
|
|
AdminQuestionPage admin question page
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
page := int32(56) // int32 | page size (optional)
|
|
pageSize := int32(56) // int32 | page size (optional)
|
|
status := "status_example" // string | user status (optional)
|
|
query := "query_example" // string | question id or title (optional)
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiQuestionPageGet(context.Background()).Page(page).PageSize(pageSize).Status(status).Query(query).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiQuestionPageGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiQuestionPageGet`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiQuestionPageGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiQuestionPageGetRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**page** | **int32** | page size |
|
|
**pageSize** | **int32** | page size |
|
|
**status** | **string** | user status |
|
|
**query** | **string** | question id or title |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiQuestionStatusPut
|
|
|
|
> HandlerRespBody AnswerAdminApiQuestionStatusPut(ctx).Data(data).Execute()
|
|
|
|
AdminSetQuestionStatus
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaAdminSetQuestionStatusRequest() // SchemaAdminSetQuestionStatusRequest | AdminSetQuestionStatusRequest
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiQuestionStatusPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiQuestionStatusPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiQuestionStatusPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiQuestionStatusPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiQuestionStatusPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaAdminSetQuestionStatusRequest**](SchemaAdminSetQuestionStatusRequest.md) | AdminSetQuestionStatusRequest |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiReportPut
|
|
|
|
> HandlerRespBody AnswerAdminApiReportPut(ctx).Data(data).Execute()
|
|
|
|
handle flag
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaReportHandleReq(int32(123), "Id_example") // SchemaReportHandleReq | flag
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiReportPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiReportPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiReportPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiReportPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiReportPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaReportHandleReq**](SchemaReportHandleReq.md) | flag |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiReportsPageGet
|
|
|
|
> HandlerRespBody AnswerAdminApiReportsPageGet(ctx).Status(status).ObjectType(objectType).Page(page).PageSize(pageSize).Execute()
|
|
|
|
list report page
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
status := "status_example" // string | status
|
|
objectType := "objectType_example" // string | object_type
|
|
page := int32(56) // int32 | page size (optional)
|
|
pageSize := int32(56) // int32 | page size (optional)
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiReportsPageGet(context.Background()).Status(status).ObjectType(objectType).Page(page).PageSize(pageSize).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiReportsPageGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiReportsPageGet`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiReportsPageGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiReportsPageGetRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**status** | **string** | status |
|
|
**objectType** | **string** | object_type |
|
|
**page** | **int32** | page size |
|
|
**pageSize** | **int32** | page size |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiRolesGet
|
|
|
|
> AnswerAdminApiRolesGet200Response AnswerAdminApiRolesGet(ctx).Execute()
|
|
|
|
get role list
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiRolesGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiRolesGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiRolesGet`: AnswerAdminApiRolesGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiRolesGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiRolesGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiRolesGet200Response**](AnswerAdminApiRolesGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
No authorization required
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSettingPrivilegesGet
|
|
|
|
> AnswerAdminApiSettingPrivilegesGet200Response AnswerAdminApiSettingPrivilegesGet(ctx).Execute()
|
|
|
|
GetPrivilegesConfig get privileges config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSettingPrivilegesGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSettingPrivilegesGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSettingPrivilegesGet`: AnswerAdminApiSettingPrivilegesGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSettingPrivilegesGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSettingPrivilegesGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSettingPrivilegesGet200Response**](AnswerAdminApiSettingPrivilegesGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSettingPrivilegesPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSettingPrivilegesPut(ctx).Data(data).Execute()
|
|
|
|
update privileges config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaUpdatePrivilegesConfigReq(openapiclient.schema.PrivilegeLevel(1)) // SchemaUpdatePrivilegesConfigReq | config
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSettingPrivilegesPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSettingPrivilegesPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSettingPrivilegesPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSettingPrivilegesPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSettingPrivilegesPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaUpdatePrivilegesConfigReq**](SchemaUpdatePrivilegesConfigReq.md) | config |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSettingSmtpGet
|
|
|
|
> AnswerAdminApiSettingSmtpGet200Response AnswerAdminApiSettingSmtpGet(ctx).Execute()
|
|
|
|
GetSMTPConfig get smtp config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSettingSmtpGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSettingSmtpGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSettingSmtpGet`: AnswerAdminApiSettingSmtpGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSettingSmtpGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSettingSmtpGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSettingSmtpGet200Response**](AnswerAdminApiSettingSmtpGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSettingSmtpPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSettingSmtpPut(ctx).Data(data).Execute()
|
|
|
|
update smtp config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaUpdateSMTPConfigReq() // SchemaUpdateSMTPConfigReq | smtp config
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSettingSmtpPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSettingSmtpPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSettingSmtpPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSettingSmtpPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSettingSmtpPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaUpdateSMTPConfigReq**](SchemaUpdateSMTPConfigReq.md) | smtp config |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoBrandingGet
|
|
|
|
> AnswerAdminApiSiteinfoBrandingGet200Response AnswerAdminApiSiteinfoBrandingGet(ctx).Execute()
|
|
|
|
get site interface
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoBrandingGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoBrandingGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoBrandingGet`: AnswerAdminApiSiteinfoBrandingGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoBrandingGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoBrandingGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoBrandingGet200Response**](AnswerAdminApiSiteinfoBrandingGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoBrandingPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoBrandingPut(ctx).Data(data).Execute()
|
|
|
|
update site info branding
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteBrandingReq() // SchemaSiteBrandingReq | branding info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoBrandingPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoBrandingPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoBrandingPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoBrandingPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoBrandingPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteBrandingReq**](SchemaSiteBrandingReq.md) | branding info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoCustomCssHtmlGet
|
|
|
|
> AnswerAdminApiSiteinfoCustomCssHtmlGet200Response AnswerAdminApiSiteinfoCustomCssHtmlGet(ctx).Execute()
|
|
|
|
get site info custom html css config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoCustomCssHtmlGet`: AnswerAdminApiSiteinfoCustomCssHtmlGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoCustomCssHtmlGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoCustomCssHtmlGet200Response**](AnswerAdminApiSiteinfoCustomCssHtmlGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoCustomCssHtmlPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoCustomCssHtmlPut(ctx).Data(data).Execute()
|
|
|
|
update site custom css html config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteCustomCssHTMLReq() // SchemaSiteCustomCssHTMLReq | login info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoCustomCssHtmlPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoCustomCssHtmlPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoCustomCssHtmlPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteCustomCssHTMLReq**](SchemaSiteCustomCssHTMLReq.md) | login info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoGeneralGet
|
|
|
|
> AnswerAdminApiSiteinfoGeneralGet200Response AnswerAdminApiSiteinfoGeneralGet(ctx).Execute()
|
|
|
|
get site general information
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoGeneralGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoGeneralGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoGeneralGet`: AnswerAdminApiSiteinfoGeneralGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoGeneralGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoGeneralGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoGeneralGet200Response**](AnswerAdminApiSiteinfoGeneralGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoGeneralPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoGeneralPut(ctx).Data(data).Execute()
|
|
|
|
update site general information
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteGeneralReq("ContactEmail_example", "Name_example", "SiteUrl_example") // SchemaSiteGeneralReq | general
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoGeneralPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoGeneralPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoGeneralPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoGeneralPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoGeneralPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteGeneralReq**](SchemaSiteGeneralReq.md) | general |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoInterfaceGet
|
|
|
|
> AnswerAdminApiSiteinfoInterfaceGet200Response AnswerAdminApiSiteinfoInterfaceGet(ctx).Execute()
|
|
|
|
get site interface
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoInterfaceGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoInterfaceGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoInterfaceGet`: AnswerAdminApiSiteinfoInterfaceGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoInterfaceGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoInterfaceGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoInterfaceGet200Response**](AnswerAdminApiSiteinfoInterfaceGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoInterfacePut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoInterfacePut(ctx).Data(data).Execute()
|
|
|
|
update site info interface
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteInterfaceReq("Language_example", "TimeZone_example") // SchemaSiteInterfaceReq | general
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoInterfacePut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoInterfacePut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoInterfacePut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoInterfacePut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoInterfacePutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteInterfaceReq**](SchemaSiteInterfaceReq.md) | general |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoLegalGet
|
|
|
|
> AnswerAdminApiSiteinfoLegalGet200Response AnswerAdminApiSiteinfoLegalGet(ctx).Execute()
|
|
|
|
Set the legal information for the site
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoLegalGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoLegalGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoLegalGet`: AnswerAdminApiSiteinfoLegalGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoLegalGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoLegalGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoLegalGet200Response**](AnswerAdminApiSiteinfoLegalGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoLegalPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoLegalPut(ctx).Data(data).Execute()
|
|
|
|
update site legal info
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteLegalReq() // SchemaSiteLegalReq | write info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoLegalPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoLegalPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoLegalPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoLegalPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoLegalPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteLegalReq**](SchemaSiteLegalReq.md) | write info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoLoginGet
|
|
|
|
> AnswerAdminApiSiteinfoLoginGet200Response AnswerAdminApiSiteinfoLoginGet(ctx).Execute()
|
|
|
|
get site info login config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoLoginGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoLoginGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoLoginGet`: AnswerAdminApiSiteinfoLoginGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoLoginGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoLoginGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoLoginGet200Response**](AnswerAdminApiSiteinfoLoginGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoLoginPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoLoginPut(ctx).Data(data).Execute()
|
|
|
|
update site login
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteLoginReq() // SchemaSiteLoginReq | login info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoLoginPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoLoginPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoLoginPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoLoginPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoLoginPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteLoginReq**](SchemaSiteLoginReq.md) | login info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoSeoGet
|
|
|
|
> AnswerAdminApiSiteinfoSeoGet200Response AnswerAdminApiSiteinfoSeoGet(ctx).Execute()
|
|
|
|
get site seo information
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoSeoGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoSeoGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoSeoGet`: AnswerAdminApiSiteinfoSeoGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoSeoGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoSeoGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoSeoGet200Response**](AnswerAdminApiSiteinfoSeoGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoSeoPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoSeoPut(ctx).Data(data).Execute()
|
|
|
|
update site seo information
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteSeoReq(int32(123), "Robots_example") // SchemaSiteSeoReq | seo
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoSeoPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoSeoPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoSeoPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoSeoPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoSeoPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteSeoReq**](SchemaSiteSeoReq.md) | seo |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoThemeGet
|
|
|
|
> AnswerAdminApiSiteinfoThemeGet200Response AnswerAdminApiSiteinfoThemeGet(ctx).Execute()
|
|
|
|
get site info theme config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoThemeGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoThemeGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoThemeGet`: AnswerAdminApiSiteinfoThemeGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoThemeGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoThemeGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoThemeGet200Response**](AnswerAdminApiSiteinfoThemeGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoThemePut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoThemePut(ctx).Data(data).Execute()
|
|
|
|
update site custom css html config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteThemeReq("Theme_example") // SchemaSiteThemeReq | login info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoThemePut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoThemePut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoThemePut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoThemePut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoThemePutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteThemeReq**](SchemaSiteThemeReq.md) | login info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoUsersGet
|
|
|
|
> AnswerAdminApiSiteinfoUsersGet200Response AnswerAdminApiSiteinfoUsersGet(ctx).Execute()
|
|
|
|
get site user config
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoUsersGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoUsersGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoUsersGet`: AnswerAdminApiSiteinfoUsersGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoUsersGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoUsersGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoUsersGet200Response**](AnswerAdminApiSiteinfoUsersGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoUsersPut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoUsersPut(ctx).Data(data).Execute()
|
|
|
|
update site info config about users
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteUsersReq("DefaultAvatar_example") // SchemaSiteUsersReq | users info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoUsersPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoUsersPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoUsersPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoUsersPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoUsersPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteUsersReq**](SchemaSiteUsersReq.md) | users info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoWriteGet
|
|
|
|
> AnswerAdminApiSiteinfoWriteGet200Response AnswerAdminApiSiteinfoWriteGet(ctx).Execute()
|
|
|
|
get site interface
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoWriteGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoWriteGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoWriteGet`: AnswerAdminApiSiteinfoWriteGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoWriteGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoWriteGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiSiteinfoWriteGet200Response**](AnswerAdminApiSiteinfoWriteGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiSiteinfoWritePut
|
|
|
|
> HandlerRespBody AnswerAdminApiSiteinfoWritePut(ctx).Data(data).Execute()
|
|
|
|
update site write info
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSiteWriteReq() // SchemaSiteWriteReq | write info
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiSiteinfoWritePut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiSiteinfoWritePut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiSiteinfoWritePut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiSiteinfoWritePut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiSiteinfoWritePutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSiteWriteReq**](SchemaSiteWriteReq.md) | write info |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiThemeOptionsGet
|
|
|
|
> HandlerRespBody AnswerAdminApiThemeOptionsGet(ctx).Execute()
|
|
|
|
Get theme options
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiThemeOptionsGet(context.Background()).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiThemeOptionsGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiThemeOptionsGet`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiThemeOptionsGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
This endpoint does not need any parameter.
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiThemeOptionsGetRequest struct via the builder pattern
|
|
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUserActivationGet
|
|
|
|
> AnswerAdminApiUserActivationGet200Response AnswerAdminApiUserActivationGet(ctx).UserId(userId).Execute()
|
|
|
|
get user activation
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
userId := "userId_example" // string | user id
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUserActivationGet(context.Background()).UserId(userId).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUserActivationGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUserActivationGet`: AnswerAdminApiUserActivationGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUserActivationGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUserActivationGetRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**userId** | **string** | user id |
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiUserActivationGet200Response**](AnswerAdminApiUserActivationGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUserPasswordPut
|
|
|
|
> HandlerRespBody AnswerAdminApiUserPasswordPut(ctx).Data(data).Execute()
|
|
|
|
update user password
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaUpdateUserPasswordReq("Password_example", "UserId_example") // SchemaUpdateUserPasswordReq | user
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUserPasswordPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUserPasswordPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUserPasswordPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUserPasswordPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUserPasswordPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaUpdateUserPasswordReq**](SchemaUpdateUserPasswordReq.md) | user |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUserPost
|
|
|
|
> HandlerRespBody AnswerAdminApiUserPost(ctx).Data(data).Execute()
|
|
|
|
add user
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaAddUserReq("DisplayName_example", "Email_example", "Password_example") // SchemaAddUserReq | user
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUserPost(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUserPost``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUserPost`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUserPost`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUserPostRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaAddUserReq**](SchemaAddUserReq.md) | user |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUserRolePut
|
|
|
|
> HandlerRespBody AnswerAdminApiUserRolePut(ctx).Data(data).Execute()
|
|
|
|
update user role
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaUpdateUserRoleReq(int32(123), "UserId_example") // SchemaUpdateUserRoleReq | user
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUserRolePut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUserRolePut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUserRolePut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUserRolePut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUserRolePutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaUpdateUserRoleReq**](SchemaUpdateUserRoleReq.md) | user |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUserStatusPut
|
|
|
|
> HandlerRespBody AnswerAdminApiUserStatusPut(ctx).Data(data).Execute()
|
|
|
|
update user
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaUpdateUserStatusReq("Status_example", "UserId_example") // SchemaUpdateUserStatusReq | user
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUserStatusPut(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUserStatusPut``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUserStatusPut`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUserStatusPut`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUserStatusPutRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaUpdateUserStatusReq**](SchemaUpdateUserStatusReq.md) | user |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUsersActivationPost
|
|
|
|
> HandlerRespBody AnswerAdminApiUsersActivationPost(ctx).Data(data).Execute()
|
|
|
|
send user activation
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaSendUserActivationReq("UserId_example") // SchemaSendUserActivationReq | SendUserActivationReq
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUsersActivationPost(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUsersActivationPost``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUsersActivationPost`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUsersActivationPost`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUsersActivationPostRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaSendUserActivationReq**](SchemaSendUserActivationReq.md) | SendUserActivationReq |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUsersPageGet
|
|
|
|
> AnswerAdminApiUsersPageGet200Response AnswerAdminApiUsersPageGet(ctx).Page(page).PageSize(pageSize).Query(query).Staff(staff).Status(status).Execute()
|
|
|
|
get user page
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
page := int32(56) // int32 | page size (optional)
|
|
pageSize := int32(56) // int32 | page size (optional)
|
|
query := "query_example" // string | search query: email, username or id:[id] (optional)
|
|
staff := true // bool | staff user (optional)
|
|
status := "status_example" // string | user status (optional)
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUsersPageGet(context.Background()).Page(page).PageSize(pageSize).Query(query).Staff(staff).Status(status).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUsersPageGet``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUsersPageGet`: AnswerAdminApiUsersPageGet200Response
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUsersPageGet`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUsersPageGetRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**page** | **int32** | page size |
|
|
**pageSize** | **int32** | page size |
|
|
**query** | **string** | search query: email, username or id:[id] |
|
|
**staff** | **bool** | staff user |
|
|
**status** | **string** | user status |
|
|
|
|
### Return type
|
|
|
|
[**AnswerAdminApiUsersPageGet200Response**](AnswerAdminApiUsersPageGet200Response.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: Not defined
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|
|
|
|
## AnswerAdminApiUsersPost
|
|
|
|
> HandlerRespBody AnswerAdminApiUsersPost(ctx).Data(data).Execute()
|
|
|
|
add users
|
|
|
|
|
|
|
|
### Example
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
openapiclient "git.ncc.cx/package/openapi-go-answer"
|
|
)
|
|
|
|
func main() {
|
|
data := *openapiclient.NewSchemaAddUsersReq() // SchemaAddUsersReq | user
|
|
|
|
configuration := openapiclient.NewConfiguration()
|
|
apiClient := openapiclient.NewAPIClient(configuration)
|
|
resp, r, err := apiClient.AdminAPI.AnswerAdminApiUsersPost(context.Background()).Data(data).Execute()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error when calling `AdminAPI.AnswerAdminApiUsersPost``: %v\n", err)
|
|
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
|
|
}
|
|
// response from `AnswerAdminApiUsersPost`: HandlerRespBody
|
|
fmt.Fprintf(os.Stdout, "Response from `AdminAPI.AnswerAdminApiUsersPost`: %v\n", resp)
|
|
}
|
|
```
|
|
|
|
### Path Parameters
|
|
|
|
|
|
|
|
### Other Parameters
|
|
|
|
Other parameters are passed through a pointer to a apiAnswerAdminApiUsersPostRequest struct via the builder pattern
|
|
|
|
|
|
Name | Type | Description | Notes
|
|
------------- | ------------- | ------------- | -------------
|
|
**data** | [**SchemaAddUsersReq**](SchemaAddUsersReq.md) | user |
|
|
|
|
### Return type
|
|
|
|
[**HandlerRespBody**](HandlerRespBody.md)
|
|
|
|
### Authorization
|
|
|
|
[ApiKeyAuth](../README.md#ApiKeyAuth)
|
|
|
|
### HTTP request headers
|
|
|
|
- **Content-Type**: application/json
|
|
- **Accept**: application/json
|
|
|
|
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
|
|
[[Back to Model list]](../README.md#documentation-for-models)
|
|
[[Back to README]](../README.md)
|
|
|