v2

func (*BaseApi) ApplyWebsiteSSL ¶

func (b *BaseApi) ApplyWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Apply ssl @Accept json @Param request body request.WebsiteSSLApply true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/obtain [post] @x-panel-log {"bodyKeys":["ID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ID","isList":false,"db":"website_ssls","output_column":"primary_domain","output_value":"domain"}],"formatZH":"申请证书 [domain]","formatEN":"apply ssl [domain]"}

func (*BaseApi) Backup ¶

func (b *BaseApi) Backup(c *gin.Context)

@Tags Backup Account @Summary Backup system data @Accept json @Param request body dto.CommonBackup true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/backup [post] @x-panel-log {"bodyKeys":["type","name","detailName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"备份 [type] 数据 [name][detailName]","formatEN":"backup [type] data [name][detailName]"}

func (*BaseApi) BatchChangeModeAndOwner ¶

func (b *BaseApi) BatchChangeModeAndOwner(c *gin.Context)

@Tags File @Summary Batch change file mode and owner @Accept json @Param request body request.FileRoleReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/batch/role [post] @x-panel-log {"bodyKeys":["paths","mode","user","group"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"批量修改文件权限和用户/组 [paths] => [mode]/user/[group]","formatEN":"Batch change file mode and owner [paths] => [mode]/user/[group]"}

func (*BaseApi) BatchCheckFiles ¶

func (b *BaseApi) BatchCheckFiles(c *gin.Context)

@Tags File @Summary Batch check file exist @Accept json @Param request body request.FilePathsCheck true "request" @Success 200 {array} response.ExistFileInfo @Security ApiKeyAuth @Security Timestamp @Router /files/batch/check [post]

func (*BaseApi) BatchDeleteFile ¶

func (b *BaseApi) BatchDeleteFile(c *gin.Context)

@Tags File @Summary Batch delete file @Accept json @Param request body request.FileBatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/batch/del [post] @x-panel-log {"bodyKeys":["paths"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"批量删除文件/文件夹 [paths]","formatEN":"Batch delete dir or file [paths]"}

func (*BaseApi) BatchOperateRule ¶

func (b *BaseApi) BatchOperateRule(c *gin.Context)

@Tags Firewall @Summary Create group @Accept json @Param request body dto.BatchRuleOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/batch [post]

func (*BaseApi) BindDomain ¶

func (b *BaseApi) BindDomain(c *gin.Context)

@Tags AI @Summary Bind domain @Accept json @Param request body dto.OllamaBindDomain true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/domain/bind [post]

func (*BaseApi) BindMcpDomain ¶

func (b *BaseApi) BindMcpDomain(c *gin.Context)

@Tags McpServer @Summary Bind Domain for mcp server @Accept json @Param request body request.McpBindDomain true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/domain/bind [post]

func (*BaseApi) BindPostgresqlUser ¶

func (b *BaseApi) BindPostgresqlUser(c *gin.Context)

@Tags Database PostgreSQL @Summary Bind postgresql user @Accept json @Param request body dto.PostgresqlBindUser true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/bind [post] @x-panel-log {"bodyKeys":["name", "username"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"绑定 postgresql 数据库 [name] 用户 [username]","formatEN":"bind postgresql database [name] user [username]"}

func (*BaseApi) BindUser ¶

func (b *BaseApi) BindUser(c *gin.Context)

@Tags Database Mysql @Summary Bind user of mysql database @Accept json @Param request body dto.BindUser true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/bind [post] @x-panel-log {"bodyKeys":["database", "username"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"绑定 mysql 数据库名 [database] [username]","formatEN":"bind mysql database [database] [username]"}

func (*BaseApi) BuildNginx ¶

func (b *BaseApi) BuildNginx(c *gin.Context)

@Tags OpenResty @Summary Build OpenResty @Accept json @Param request body request.NginxBuildReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /openresty/build [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"构建 OpenResty","formatEN":"Build OpenResty"}

func (*BaseApi) CancelIgnoreAppUpgrade ¶

func (b *BaseApi) CancelIgnoreAppUpgrade(c *gin.Context)

写一个去掉忽略的接口 @Tags App @Summary Cancel Ignore Upgrade App @Accept json @Param request body request.ReqWithID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/ignored/cancel [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"取消忽略应用升级","formatEN":"Cancel ignore application upgrade"}

func (*BaseApi) ChangeAppPort ¶

func (b *BaseApi) ChangeAppPort(c *gin.Context)

@Tags App @Summary Change app port @Accept json @Param request body request.PortUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/port/change [post] @x-panel-log {"bodyKeys":["key","name","port"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"应用端口修改 [key]-[name] => [port]","formatEN":"Application port update [key]-[name] => [port]"}

func (*BaseApi) ChangeDefaultServer ¶

func (b *BaseApi) ChangeDefaultServer(c *gin.Context)

@Tags Website @Summary Change default server @Accept json @Param request body request.WebsiteDefaultUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/default/server [post] @x-panel-log {"bodyKeys":["id", "operate"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改默认 server => [domain]","formatEN":"Change default server => [domain]"}

func (*BaseApi) ChangeFileMode ¶

func (b *BaseApi) ChangeFileMode(c *gin.Context)

@Tags File @Summary Change file mode @Accept json @Param request body request.FileCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/mode [post] @x-panel-log {"bodyKeys":["path","mode"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改权限 [paths] => [mode]","formatEN":"Change mode [paths] => [mode]"}

func (*BaseApi) ChangeFileName ¶

func (b *BaseApi) ChangeFileName(c *gin.Context)

@Tags File @Summary Change file name @Accept json @Param request body request.FileRename true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/rename [post] @x-panel-log {"bodyKeys":["oldName","newName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"重命名 [oldName] => [newName]","formatEN":"Rename [oldName] => [newName]"}

func (*BaseApi) ChangeFileOwner ¶

func (b *BaseApi) ChangeFileOwner(c *gin.Context)

@Tags File @Summary Change file owner @Accept json @Param request body request.FileRoleUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/owner [post] @x-panel-log {"bodyKeys":["path","user","group"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改用户/组 [paths] => user/[group]","formatEN":"Change owner [paths] => user/[group]"}

func (*BaseApi) ChangeMysqlAccess ¶

func (b *BaseApi) ChangeMysqlAccess(c *gin.Context)

@Tags Database Mysql @Summary Change mysql access @Accept json @Param request body dto.ChangeDBInfo true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/change/access [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_mysqls","output_column":"name","output_value":"name"}],"formatZH":"更新数据库 [name] 访问权限","formatEN":"Update database [name] access"}

func (*BaseApi) ChangeMysqlPassword ¶

func (b *BaseApi) ChangeMysqlPassword(c *gin.Context)

@Tags Database Mysql @Summary Change mysql password @Accept json @Param request body dto.ChangeDBInfo true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/change/password [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_mysqls","output_column":"name","output_value":"name"}],"formatZH":"更新数据库 [name] 密码","formatEN":"Update database [name] password"}

func (*BaseApi) ChangePHPVersion ¶

func (b *BaseApi) ChangePHPVersion(c *gin.Context)

@Tags Website PHP @Summary Update php version @Accept json @Param request body request.WebsitePHPVersionReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/php/version [post] @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteId","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"php 版本变更 [domain]","formatEN":"php version update [domain]"}

func (*BaseApi) ChangePostgresqlPassword ¶

func (b *BaseApi) ChangePostgresqlPassword(c *gin.Context)

@Tags Database PostgreSQL @Summary Change postgresql password @Accept json @Param request body dto.ChangeDBInfo true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/password [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_postgresqls","output_column":"name","output_value":"name"}],"formatZH":"更新数据库 [name] 密码","formatEN":"Update database [name] password"}

func (*BaseApi) ChangePostgresqlPrivileges ¶

func (b *BaseApi) ChangePostgresqlPrivileges(c *gin.Context)

@Tags Database PostgreSQL @Summary Change postgresql privileges @Accept json @Param request body dto.ChangeDBInfo true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/privileges [post] @x-panel-log {"bodyKeys":["database", "username"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新数据库 [database] 用户 [username] 权限","formatEN":"Update user privileges of database [database]"}

func (*BaseApi) ChangeRedisPassword ¶

func (b *BaseApi) ChangeRedisPassword(c *gin.Context)

@Tags Database Redis @Summary Change redis password @Accept json @Param request body dto.ChangeRedisPass true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/password [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 redis 数据库密码","formatEN":"change the password of the redis database"}

func (*BaseApi) ChangeWebsiteDatabase ¶

func (b *BaseApi) ChangeWebsiteDatabase(c *gin.Context)

@Tags Website @Summary Change website database @Accept json @Param request body request.ChangeDatabase true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/databases [post]

func (*BaseApi) ChangeWebsiteGroup ¶

func (b *BaseApi) ChangeWebsiteGroup(c *gin.Context)

func (*BaseApi) CheckAppInstalled ¶

func (b *BaseApi) CheckAppInstalled(c *gin.Context)

@Tags App @Summary Check app installed @Accept json @Param request body request.AppInstalledInfo true "request" @Success 200 {object} response.AppInstalledCheck @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/check [post]

func (*BaseApi) CheckBackupUsed ¶

func (b *BaseApi) CheckBackupUsed(c *gin.Context)

func (*BaseApi) CheckDNS ¶

func (b *BaseApi) CheckDNS(c *gin.Context)

@Tags Device @Summary Check device DNS conf @Accept json @Param request body dto.SettingUpdate true "request" @Success 200 {boolean} data @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/check/dns [post]

func (*BaseApi) CheckDatabase ¶

func (b *BaseApi) CheckDatabase(c *gin.Context)

@Tags Database @Summary Check database @Accept json @Param request body dto.DatabaseCreate true "request" @Success 200 {boolean} isOk @Security ApiKeyAuth @Security Timestamp @Router /databases/db/check [post] @x-panel-log {"bodyKeys":["name", "type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"检测远程数据库 [name][type] 连接性","formatEN":"check if database [name][type] is connectable"}

func (*BaseApi) CheckFile ¶

func (b *BaseApi) CheckFile(c *gin.Context)

@Tags File @Summary Check file exist @Accept json @Param request body request.FilePathCheck true "request" @Success 200 {boolean} isOk @Security ApiKeyAuth @Security Timestamp @Router /files/check [post]

func (*BaseApi) CheckHasCli ¶

func (b *BaseApi) CheckHasCli(c *gin.Context)

func (*BaseApi) CheckHealth ¶

func (b *BaseApi) CheckHealth(c *gin.Context)

func (*BaseApi) CheckLocalConn ¶

func (b *BaseApi) CheckLocalConn(c *gin.Context)

func (*BaseApi) CheckLocalConnByInfo ¶

func (b *BaseApi) CheckLocalConnByInfo(c *gin.Context)

@Tags System Setting @Summary Check local conn info @Success 200 {bool} isOk @Security ApiKeyAuth @Security Timestamp @Router /settings/ssh/check/info [post]

func (*BaseApi) CheckRepoStatus ¶

func (b *BaseApi) CheckRepoStatus(c *gin.Context)

@Tags Container Image-repo @Summary Load repo status @Accept json @Param request body dto.OperateByID true "request" @Produce json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/repo/status [get]

func (*BaseApi) CleanAlertLogs ¶

func (b *BaseApi) CleanAlertLogs(c *gin.Context)

func (*BaseApi) CleanClamRecord ¶

func (b *BaseApi) CleanClamRecord(c *gin.Context)

@Tags Clam @Summary Clean clam record @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/record/clean [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":true,"db":"clams","output_column":"name","output_value":"name"}],"formatZH":"清空扫描报告 [name]","formatEN":"clean clam record [name]"}

func (*BaseApi) CleanContainerLog ¶

func (b *BaseApi) CleanContainerLog(c *gin.Context)

@Tags Container @Summary Clean container log @Accept json @Param request body dto.OperationWithName true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/clean/log [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理容器 [name] 日志","formatEN":"clean container [name] logs"}

func (*BaseApi) CleanMonitor ¶

func (b *BaseApi) CleanMonitor(c *gin.Context)

@Tags Monitor @Summary Clean monitor data @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/monitor/clean [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清空监控数据","formatEN":"clean monitor datas"}

func (*BaseApi) CleanRecord ¶

func (b *BaseApi) CleanRecord(c *gin.Context)

@Tags Cronjob @Summary Clean job records @Accept json @Param request body dto.CronjobClean true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/records/clean [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"清空计划任务记录 [name]","formatEN":"clean cronjob [name] records"}

func (*BaseApi) ClearProxyCache ¶

func (b *BaseApi) ClearProxyCache(c *gin.Context)

@Tags Website @Summary Clear Website proxy cache @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/proxy/clear [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理 Openresty 代理缓存","formatEN":"Clear nginx proxy cache"}

func (*BaseApi) ClearRecycleBinFile ¶

func (b *BaseApi) ClearRecycleBinFile(c *gin.Context)

@Tags File @Summary Clear RecycleBin files @Accept json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/recycle/clear [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清空回收站","formatEN":"清空回收站"}

func (*BaseApi) CloseOllamaModel ¶

func (b *BaseApi) CloseOllamaModel(c *gin.Context)

@Tags AI @Summary Close Ollama model conn @Accept json @Param request body dto.OllamaModelName true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/close [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"关闭 Ollama 模型连接 [name]","formatEN":"close conn for Ollama model [name]"}

func (*BaseApi) ComposeUpdate ¶

func (b *BaseApi) ComposeUpdate(c *gin.Context)

@Tags Container Compose @Summary Update compose @Accept json @Param request body dto.ComposeUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/compose/update [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 compose [name]","formatEN":"update compose information [name]"}

func (*BaseApi) CompressFile ¶

func (b *BaseApi) CompressFile(c *gin.Context)

@Tags File @Summary Compress file @Accept json @Param request body request.FileCompress true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/compress [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"压缩文件 [name]","formatEN":"Compress file [name]"}

func (*BaseApi) ContainerCommit ¶

func (b *BaseApi) ContainerCommit(c *gin.Context)

@Tags Container @Summary Commit Container @Accept json @Param request body dto.ContainerCommit true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/commit [post]

func (*BaseApi) ContainerCreate ¶

func (b *BaseApi) ContainerCreate(c *gin.Context)

@Tags Container @Summary Create container @Accept json @Param request body dto.ContainerOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers [post] @x-panel-log {"bodyKeys":["name","image"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建容器 [name]image","formatEN":"create container [name]image"}

func (*BaseApi) ContainerCreateByCommand ¶

func (b *BaseApi) ContainerCreateByCommand(c *gin.Context)

@Tags Container @Summary Create container by command @Accept json @Param request body dto.ContainerCreateByCommand true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/command [post]

func (*BaseApi) ContainerInfo ¶

func (b *BaseApi) ContainerInfo(c *gin.Context)

@Tags Container @Summary Load container info @Accept json @Param request body dto.OperationWithName true "request" @Success 200 {object} dto.ContainerOperate @Security ApiKeyAuth @Security Timestamp @Router /containers/info [post]

func (*BaseApi) ContainerListStats ¶

func (b *BaseApi) ContainerListStats(c *gin.Context)

@Summary Load container stats @Success 200 {array} dto.ContainerListStats @Security ApiKeyAuth @Security Timestamp @Router /containers/list/stats [get]

func (*BaseApi) ContainerOperation ¶

func (b *BaseApi) ContainerOperation(c *gin.Context)

@Tags Container @Summary Operate Container @Accept json @Param request body dto.ContainerOperation true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/operate [post] @x-panel-log {"bodyKeys":["names","operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"容器 [names] 执行 [operation]","formatEN":"container [operation] [names]"}

func (*BaseApi) ContainerPrune ¶

func (b *BaseApi) ContainerPrune(c *gin.Context)

@Tags Container @Summary Clean container @Accept json @Param request body dto.ContainerPrune true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/prune [post] @x-panel-log {"bodyKeys":["pruneType"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理容器 [pruneType]","formatEN":"clean container [pruneType]"}

func (*BaseApi) ContainerRename ¶

func (b *BaseApi) ContainerRename(c *gin.Context)

@Tags Container @Summary Rename Container @Accept json @Param request body dto.ContainerRename true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/rename [post] @x-panel-log {"bodyKeys":["name","newName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"容器重命名 [name] => [newName]","formatEN":"rename container [name] => [newName]"}

func (*BaseApi) ContainerStats ¶

func (b *BaseApi) ContainerStats(c *gin.Context)

@Tags Container @Summary Container stats @Param id path string true "容器id" @Success 200 {object} dto.ContainerStats @Security ApiKeyAuth @Security Timestamp @Router /containers/stats/:id [get]

func (*BaseApi) ContainerStreamLogs ¶

func (b *BaseApi) ContainerStreamLogs(c *gin.Context)

@Tags Container @Summary Container logs @Param container query string false "容器名称" @Param since query string false "时间筛选" @Param follow query string false "是否追踪" @Param tail query string false "显示行号" @Security ApiKeyAuth @Security Timestamp @Router /containers/search/log [post]

func (*BaseApi) ContainerUpdate ¶

func (b *BaseApi) ContainerUpdate(c *gin.Context)

@Tags Container @Summary Update container @Accept json @Param request body dto.ContainerOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/update [post] @x-panel-log {"bodyKeys":["name","image"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新容器 [name]image","formatEN":"update container [name]image"}

func (*BaseApi) ContainerUpgrade ¶

func (b *BaseApi) ContainerUpgrade(c *gin.Context)

@Tags Container @Summary Upgrade container @Accept json @Param request body dto.ContainerUpgrade true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/upgrade [post] @x-panel-log {"bodyKeys":["name","image"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新容器镜像 [name]image","formatEN":"upgrade container image [name]image"}

func (*BaseApi) ContainerWsSSH ¶

func (b *BaseApi) ContainerWsSSH(c *gin.Context)

func (*BaseApi) CountExecutingTasks ¶

func (b *BaseApi) CountExecutingTasks(c *gin.Context)

@Tags TaskLog @Summary Get the number of executing tasks @Success 200 {object} int64 @Security ApiKeyAuth @Security Timestamp @Router /logs/tasks/executing/count [get]

func (*BaseApi) CreateAlert ¶

func (b *BaseApi) CreateAlert(c *gin.Context)

func (*BaseApi) CreateBackup ¶

func (b *BaseApi) CreateBackup(c *gin.Context)

@Tags Backup Account @Summary Create backup account @Accept json @Param request body dto.BackupOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups [post] @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建备份账号 [type]","formatEN":"create backup account [type]"}

func (*BaseApi) CreateClam ¶

func (b *BaseApi) CreateClam(c *gin.Context)

@Tags Clam @Summary Create clam @Accept json @Param request body dto.ClamCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam [post] @x-panel-log {"bodyKeys":["name","path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建扫描规则 [name]path","formatEN":"create clam [name]path"}

func (*BaseApi) CreateCompose ¶

func (b *BaseApi) CreateCompose(c *gin.Context)

@Tags Container Compose @Summary Create compose @Accept json @Param request body dto.ComposeCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/compose [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 compose [name]","formatEN":"create compose [name]"}

func (*BaseApi) CreateComposeTemplate ¶

func (b *BaseApi) CreateComposeTemplate(c *gin.Context)

@Tags Container Compose-template @Summary Create compose template @Accept json @Param request body dto.ComposeTemplateCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/template [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 compose 模版 [name]","formatEN":"create compose template [name]"}

func (*BaseApi) CreateCronjob ¶

func (b *BaseApi) CreateCronjob(c *gin.Context)

@Tags Cronjob @Summary Create cronjob @Accept json @Param request body dto.CronjobOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs [post] @x-panel-log {"bodyKeys":["type","name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建计划任务 [type][name]","formatEN":"create cronjob [type][name]"}

func (*BaseApi) CreateDatabase ¶

func (b *BaseApi) CreateDatabase(c *gin.Context)

@Tags Database @Summary Create database @Accept json @Param request body dto.DatabaseCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/db [post] @x-panel-log {"bodyKeys":["name", "type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建远程数据库 [name][type]","formatEN":"create database [name][type]"}

func (*BaseApi) CreateFavorite ¶

func (b *BaseApi) CreateFavorite(c *gin.Context)

@Tags File @Summary Create favorite @Accept json @Param request body request.FavoriteCreate true "request" @Success 200 {object} model.Favorite @Security ApiKeyAuth @Security Timestamp @Router /files/favorite [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"收藏文件/文件夹 path","formatEN":"收藏文件/文件夹 path"}

func (*BaseApi) CreateFile ¶

func (b *BaseApi) CreateFile(c *gin.Context)

@Tags File @Summary Create file @Accept json @Param request body request.FileCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建文件/文件夹 path","formatEN":"Create dir or file path"}

func (*BaseApi) CreateFtp ¶

func (b *BaseApi) CreateFtp(c *gin.Context)

@Tags FTP @Summary Create FTP user @Accept json @Param request body dto.FtpCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp [post] @x-panel-log {"bodyKeys":["user", "path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 FTP 账户 userpath","formatEN":"create FTP userpath"}

func (*BaseApi) CreateGroup ¶

func (b *BaseApi) CreateGroup(c *gin.Context)

@Tags System Group @Summary Create group @Accept json @Param request body dto.GroupCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /agent/groups [post] @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建组 [name][type]","formatEN":"create group [name][type]"}

func (*BaseApi) CreateLoadBalance ¶

func (b *BaseApi) CreateLoadBalance(c *gin.Context)

@Tags Website @Summary Create website upstream @Accept json @Param request body request.WebsiteLBCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/lbs/create [post]

func (*BaseApi) CreateMcpServer ¶

func (b *BaseApi) CreateMcpServer(c *gin.Context)

@Tags McpServer @Summary Create mcp server @Accept json @Param request body request.McpServerCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/server [post]

func (*BaseApi) CreateMysql ¶

func (b *BaseApi) CreateMysql(c *gin.Context)

@Tags Database Mysql @Summary Create mysql database @Accept json @Param request body dto.MysqlDBCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 mysql 数据库 [name]","formatEN":"create mysql database [name]"}

func (*BaseApi) CreateNetwork ¶

func (b *BaseApi) CreateNetwork(c *gin.Context)

@Tags Container Network @Summary Create network @Accept json @Param request body dto.NetworkCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/network [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建容器网络 name","formatEN":"create container network [name]"}

func (*BaseApi) CreateOllamaModel ¶

func (b *BaseApi) CreateOllamaModel(c *gin.Context)

@Tags AI @Summary Create Ollama model @Accept json @Param request body dto.OllamaModelName true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加 Ollama 模型 [name]","formatEN":"add Ollama model [name]"}

func (*BaseApi) CreatePHPExtensions ¶

func (b *BaseApi) CreatePHPExtensions(c *gin.Context)

@Tags PHP Extensions @Summary Create Extensions @Accept json @Param request body request.PHPExtensionsCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions [post]

func (*BaseApi) CreatePostgresql ¶

func (b *BaseApi) CreatePostgresql(c *gin.Context)

@Tags Database PostgreSQL @Summary Create postgresql database @Accept json @Param request body dto.PostgresqlDBCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 postgresql 数据库 [name]","formatEN":"create postgresql database [name]"}

func (*BaseApi) CreateRepo ¶

func (b *BaseApi) CreateRepo(c *gin.Context)

@Tags Container Image-repo @Summary Create image repo @Accept json @Param request body dto.ImageRepoDelete true "request" @Produce json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/repo [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建镜像仓库 [name]","formatEN":"create image repo [name]"}

func (*BaseApi) CreateRootCert ¶

func (b *BaseApi) CreateRootCert(c *gin.Context)

@Tags SSH @Summary Generate host SSH secret @Accept json @Param request body dto.CreateRootCert true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/cert [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"生成 SSH 密钥 ","formatEN":"generate SSH secret"}

func (*BaseApi) CreateRuntime ¶

func (b *BaseApi) CreateRuntime(c *gin.Context)

@Tags Runtime @Summary Create runtime @Accept json @Param request body request.RuntimeCreate true "request" @Success 200 {object} model.Runtime @Security ApiKeyAuth @Security Timestamp @Router /runtimes [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建运行环境 [name]","formatEN":"Create runtime [name]"}

func (*BaseApi) CreateSnapshot ¶

func (b *BaseApi) CreateSnapshot(c *gin.Context)

@Tags System Setting @Summary Create system snapshot @Accept json @Param request body dto.SnapshotCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot [post] @x-panel-log {"bodyKeys":["from", "description"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建系统快照 [description] 到 [from]","formatEN":"Create system backup [description] to [from]"}

func (*BaseApi) CreateVolume ¶

func (b *BaseApi) CreateVolume(c *gin.Context)

@Tags Container Volume @Summary Create volume @Accept json @Param request body dto.VolumeCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/volume [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建容器存储卷 [name]","formatEN":"create container volume [name]"}

func (*BaseApi) CreateWebDomain ¶

func (b *BaseApi) CreateWebDomain(c *gin.Context)

@Tags Website Domain @Summary Create website domain @Accept json @Param request body request.WebsiteDomainCreate true "request" @Success 200 {object} model.WebsiteDomain @Security ApiKeyAuth @Security Timestamp @Router /websites/domains [post] @x-panel-log {"bodyKeys":["domain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建域名 [domain]","formatEN":"Create domain [domain]"}

func (*BaseApi) CreateWebsite ¶

func (b *BaseApi) CreateWebsite(c *gin.Context)

@Tags Website @Summary Create website @Accept json @Param request body request.WebsiteCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites [post] @x-panel-log {"bodyKeys":["primaryDomain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 [primaryDomain]","formatEN":"Create website [primaryDomain]"}

func (*BaseApi) CreateWebsiteAcmeAccount ¶

func (b *BaseApi) CreateWebsiteAcmeAccount(c *gin.Context)

@Tags Website Acme @Summary Create website acme account @Accept json @Param request body request.WebsiteAcmeAccountCreate true "request" @Success 200 {object} response.WebsiteAcmeAccountDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/acme [post] @x-panel-log {"bodyKeys":["email"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 acme [email]","formatEN":"Create website acme [email]"}

func (*BaseApi) CreateWebsiteCA ¶

func (b *BaseApi) CreateWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Create website ca @Accept json @Param request body request.WebsiteCACreate true "request" @Success 200 {object} request.WebsiteCACreate @Security ApiKeyAuth @Security Timestamp @Router /websites/ca [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 ca [name]","formatEN":"Create website ca [name]"}

func (*BaseApi) CreateWebsiteCheck ¶

func (b *BaseApi) CreateWebsiteCheck(c *gin.Context)

@Tags Website @Summary Check before create website @Accept json @Param request body request.WebsiteInstallCheckReq true "request" @Success 200 {array} response.WebsitePreInstallCheck @Security ApiKeyAuth @Security Timestamp @Router /websites/check [post]

func (*BaseApi) CreateWebsiteDnsAccount ¶

func (b *BaseApi) CreateWebsiteDnsAccount(c *gin.Context)

@Tags Website DNS @Summary Create website dns account @Accept json @Param request body request.WebsiteDnsAccountCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/dns [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 dns [name]","formatEN":"Create website dns [name]"}

func (*BaseApi) CreateWebsiteSSL ¶

func (b *BaseApi) CreateWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Create website ssl @Accept json @Param request body request.WebsiteSSLCreate true "request" @Success 200 {object} request.WebsiteSSLCreate @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl [post] @x-panel-log {"bodyKeys":["primaryDomain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 ssl [primaryDomain]","formatEN":"Create website ssl [primaryDomain]"}

func (*BaseApi) DeCompressFile ¶

func (b *BaseApi) DeCompressFile(c *gin.Context)

@Tags File @Summary Decompress file @Accept json @Param request body request.FileDeCompress true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/decompress [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"解压 path","formatEN":"Decompress file path"}

func (*BaseApi) DeleteAlert ¶

func (b *BaseApi) DeleteAlert(c *gin.Context)

func (*BaseApi) DeleteAlertConfig ¶

func (b *BaseApi) DeleteAlertConfig(c *gin.Context)

func (*BaseApi) DeleteBackup ¶

func (b *BaseApi) DeleteBackup(c *gin.Context)

@Tags Backup Account @Summary Delete backup account @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"backup_accounts","output_column":"type","output_value":"types"}],"formatZH":"删除备份账号 [types]","formatEN":"delete backup account [types]"}

func (*BaseApi) DeleteBackupRecord ¶

func (b *BaseApi) DeleteBackupRecord(c *gin.Context)

@Tags Backup Account @Summary Delete backup record @Accept json @Param request body dto.BatchDeleteReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /record/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"backup_records","output_column":"file_name","output_value":"files"}],"formatZH":"删除备份记录 files","formatEN":"delete backup records files"}

func (*BaseApi) DeleteCheck ¶

func (b *BaseApi) DeleteCheck(c *gin.Context)

@Tags App @Summary Check before delete @Accept json @Param appInstallId path integer true "App install id" @Success 200 {array} dto.AppResource @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/delete/check/:appInstallId [get]

func (*BaseApi) DeleteCheckDatabase ¶

func (b *BaseApi) DeleteCheckDatabase(c *gin.Context)

@Tags Database @Summary Check before delete remote database @Accept json @Param request body dto.OperateByID true "request" @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /db/remote/del/check [post]

func (*BaseApi) DeleteCheckMysql ¶

func (b *BaseApi) DeleteCheckMysql(c *gin.Context)

@Tags Database Mysql @Summary Check before delete mysql database @Accept json @Param request body dto.MysqlDBDeleteCheck true "request" @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /databases/del/check [post]

func (*BaseApi) DeleteCheckPostgresql ¶

func (b *BaseApi) DeleteCheckPostgresql(c *gin.Context)

@Tags Database PostgreSQL @Summary Check before delete postgresql database @Accept json @Param request body dto.PostgresqlDBDeleteCheck true "request" @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/del/check [post]

func (*BaseApi) DeleteClam ¶

func (b *BaseApi) DeleteClam(c *gin.Context)

@Tags Clam @Summary Delete clam @Accept json @Param request body dto.ClamDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"clams","output_column":"name","output_value":"names"}],"formatZH":"删除扫描规则 [names]","formatEN":"delete clam [names]"}

func (*BaseApi) DeleteComposeTemplate ¶

func (b *BaseApi) DeleteComposeTemplate(c *gin.Context)

@Tags Container Compose-template @Summary Delete compose template @Accept json @Param request body dto.BatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/template/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"compose_templates","output_column":"name","output_value":"names"}],"formatZH":"删除 compose 模版 [names]","formatEN":"delete compose template [names]"}

func (*BaseApi) DeleteCronjob ¶

func (b *BaseApi) DeleteCronjob(c *gin.Context)

@Tags Cronjob @Summary Delete cronjob @Accept json @Param request body dto.CronjobBatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"cronjobs","output_column":"name","output_value":"names"}],"formatZH":"删除计划任务 [names]","formatEN":"delete cronjob [names]"}

func (*BaseApi) DeleteDatabase ¶

func (b *BaseApi) DeleteDatabase(c *gin.Context)

@Tags Database @Summary Delete database @Accept json @Param request body dto.DatabaseDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/db/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"databases","output_column":"name","output_value":"names"}],"formatZH":"删除远程数据库 [names]","formatEN":"delete database [names]"}

func (*BaseApi) DeleteFavorite ¶

func (b *BaseApi) DeleteFavorite(c *gin.Context)

@Tags File @Summary Delete favorite @Accept json @Param request body request.FavoriteDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/favorite/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"favorites","output_column":"path","output_value":"path"}],"formatZH":"删除收藏 path","formatEN":"delete avorite path"}

func (*BaseApi) DeleteFile ¶

func (b *BaseApi) DeleteFile(c *gin.Context)

@Tags File @Summary Delete file @Accept json @Param request body request.FileDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/del [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除文件/文件夹 path","formatEN":"Delete dir or file path"}

func (*BaseApi) DeleteFtp ¶

func (b *BaseApi) DeleteFtp(c *gin.Context)

@Tags FTP @Summary Delete FTP user @Accept json @Param request body dto.BatchDeleteReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"ftps","output_column":"user","output_value":"users"}],"formatZH":"删除 FTP 账户 [users]","formatEN":"delete FTP users [users]"}

func (*BaseApi) DeleteGroup ¶

func (b *BaseApi) DeleteGroup(c *gin.Context)

@Tags System Group @Summary Delete group @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /agent/groups/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"groups","output_column":"name","output_value":"name"},{"input_column":"id","input_value":"id","isList":false,"db":"groups","output_column":"type","output_value":"type"}],"formatZH":"删除组 [type][name]","formatEN":"delete group [type][name]"}

func (*BaseApi) DeleteLoadBalance ¶

func (b *BaseApi) DeleteLoadBalance(c *gin.Context)

@Tags Website @Summary Delete website upstream @Accept json @Param request body request.WebsiteLBDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/lbs/delete [post]

func (*BaseApi) DeleteMcpServer ¶

func (b *BaseApi) DeleteMcpServer(c *gin.Context)

@Tags McpServer @Summary Delete mcp server @Accept json @Param request body request.McpServerDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/server/del [post]

func (*BaseApi) DeleteMysql ¶

func (b *BaseApi) DeleteMysql(c *gin.Context)

@Tags Database Mysql @Summary Delete mysql database @Accept json @Param request body dto.MysqlDBDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_mysqls","output_column":"name","output_value":"name"}],"formatZH":"删除 mysql 数据库 [name]","formatEN":"delete mysql database [name]"}

func (*BaseApi) DeleteNetwork ¶

func (b *BaseApi) DeleteNetwork(c *gin.Context)

@Tags Container Network @Summary Delete network @Accept json @Param request body dto.BatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/network/del [post] @x-panel-log {"bodyKeys":["names"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除容器网络 [names]","formatEN":"delete container network [names]"}

func (*BaseApi) DeleteOllamaModel ¶

func (b *BaseApi) DeleteOllamaModel(c *gin.Context)

@Tags AI @Summary Delete Ollama model @Accept json @Param request body dto.ForceDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"ollama_models","output_column":"name","output_value":"names"}],"formatZH":"删除 Ollama 模型 [names]","formatEN":"remove Ollama model [names]"}

func (*BaseApi) DeletePHPExtensions ¶

func (b *BaseApi) DeletePHPExtensions(c *gin.Context)

@Tags PHP Extensions @Summary Delete Extensions @Accept json @Param request body request.PHPExtensionsDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions/del [post]

func (*BaseApi) DeletePostgresql ¶

func (b *BaseApi) DeletePostgresql(c *gin.Context)

@Tags Database PostgreSQL @Summary Delete postgresql database @Accept json @Param request body dto.PostgresqlDBDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_postgresqls","output_column":"name","output_value":"name"}],"formatZH":"删除 postgresql 数据库 [name]","formatEN":"delete postgresql database [name]"}

func (*BaseApi) DeleteRepo ¶

func (b *BaseApi) DeleteRepo(c *gin.Context)

@Tags Container Image-repo @Summary Delete image repo @Accept json @Param request body dto.OperateByID true "request" @Produce json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/repo/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"image_repos","output_column":"name","output_value":"name"}],"formatZH":"删除镜像仓库 [name]","formatEN":"delete image repo [name]"}

func (*BaseApi) DeleteRootCert ¶

func (b *BaseApi) DeleteRootCert(c *gin.Context)

@Tags SSH @Summary Delete host SSH secret @Accept json @Param request body dto.ForceDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/cert/delete [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除 SSH 密钥 ","formatEN":"delete SSH secret"}

func (*BaseApi) DeleteRuntime ¶

func (b *BaseApi) DeleteRuntime(c *gin.Context)

@Tags Website @Summary Delete runtime @Accept json @Param request body request.RuntimeDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除运行环境 [name]","formatEN":"Delete runtime [name]"}

func (*BaseApi) DeleteRuntimeCheck ¶

func (b *BaseApi) DeleteRuntimeCheck(c *gin.Context)

@Tags Website @Summary Delete runtime @Accept json @Success 200 {array} dto.AppResource @Security ApiKeyAuth @Security Timestamp @Router /installed/delete/check/:id [get]

func (*BaseApi) DeleteSnapshot ¶

func (b *BaseApi) DeleteSnapshot(c *gin.Context)

@Tags System Setting @Summary Delete system backup @Accept json @Param request body dto.SnapshotBatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"删除系统快照 [name]","formatEN":"Delete system backup [name]"}

func (*BaseApi) DeleteVolume ¶

func (b *BaseApi) DeleteVolume(c *gin.Context)

@Tags Container Volume @Summary Delete volume @Accept json @Param request body dto.BatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/volume/del [post] @x-panel-log {"bodyKeys":["names"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除容器存储卷 [names]","formatEN":"delete container volume [names]"}

func (*BaseApi) DeleteWebDomain ¶

func (b *BaseApi) DeleteWebDomain(c *gin.Context)

@Tags Website Domain @Summary Delete website domain @Accept json @Param request body request.WebsiteDomainDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/domains/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_domains","output_column":"domain","output_value":"domain"}],"formatZH":"删除域名 [domain]","formatEN":"Delete domain [domain]"}

func (*BaseApi) DeleteWebsite ¶

func (b *BaseApi) DeleteWebsite(c *gin.Context)

@Tags Website @Summary Delete website @Accept json @Param request body request.WebsiteDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"删除网站 [domain]","formatEN":"Delete website [domain]"}

func (*BaseApi) DeleteWebsiteAcmeAccount ¶

func (b *BaseApi) DeleteWebsiteAcmeAccount(c *gin.Context)

@Tags Website Acme @Summary Delete website acme account @Accept json @Param request body request.WebsiteResourceReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/acme/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_acme_accounts","output_column":"email","output_value":"email"}],"formatZH":"删除网站 acme [email]","formatEN":"Delete website acme [email]"}

func (*BaseApi) DeleteWebsiteCA ¶

func (b *BaseApi) DeleteWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Delete website ca @Accept json @Param request body request.WebsiteCommonReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_cas","output_column":"name","output_value":"name"}],"formatZH":"删除网站 ca [name]","formatEN":"Delete website ca [name]"}

func (*BaseApi) DeleteWebsiteDnsAccount ¶

func (b *BaseApi) DeleteWebsiteDnsAccount(c *gin.Context)

@Tags Website DNS @Summary Delete website dns account @Accept json @Param request body request.WebsiteResourceReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/dns/del [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_dns_accounts","output_column":"name","output_value":"name"}],"formatZH":"删除网站 dns [name]","formatEN":"Delete website dns [name]"}

func (*BaseApi) DeleteWebsiteSSL ¶

func (b *BaseApi) DeleteWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Delete website ssl @Accept json @Param request body request.WebsiteBatchDelReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/del [post] @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"website_ssls","output_column":"primary_domain","output_value":"domain"}],"formatZH":"删除 ssl [domain]","formatEN":"Delete ssl [domain]"}

func (*BaseApi) DepthDirSize ¶

func (b *BaseApi) DepthDirSize(c *gin.Context)

@Tags File @Summary Multi file size @Accept json @Param request body request.DirSizeReq true "request" @Success 200 {array} response.DepthDirSizeRes @Security ApiKeyAuth @Security Timestamp @Router /files/depth/size [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"获取目录及其第一层子目录文件夹大小 path","formatEN":"Multi file size path"}

func (*BaseApi) Download ¶

func (b *BaseApi) Download(c *gin.Context)

@Tags File @Summary Download file @Accept json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/download [get]

func (*BaseApi) DownloadCAFile ¶

func (b *BaseApi) DownloadCAFile(c *gin.Context)

@Tags Website CA @Summary Download CA file @Accept json @Param request body request.WebsiteResourceReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/download [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_cas","output_column":"name","output_value":"name"}],"formatZH":"下载 CA 证书文件 [name]","formatEN":"download ca file [name]"}

func (*BaseApi) DownloadChunkFiles ¶

func (b *BaseApi) DownloadChunkFiles(c *gin.Context)

@Tags File @Summary Chunk Download file @Accept json @Param request body request.FileDownload true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/chunkdownload [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"下载文件 [name]","formatEN":"Download file [name]"}

func (*BaseApi) DownloadContainerLogs ¶

func (b *BaseApi) DownloadContainerLogs(c *gin.Context)

@Router /containers/download/log [post]

func (*BaseApi) DownloadRecord ¶

func (b *BaseApi) DownloadRecord(c *gin.Context)

@Tags Backup Account @Summary Download backup record @Accept json @Param request body dto.DownloadRecord true "request" @Success 200 {string} filePath @Security ApiKeyAuth @Security Timestamp @Router /backup/record/download [post] @x-panel-log {"bodyKeys":["source","fileName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"下载备份记录 [source][fileName]","formatEN":"download backup records [source][fileName]"}

func (*BaseApi) DownloadWebsiteSSL ¶

func (b *BaseApi) DownloadWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Download SSL file @Accept json @Param request body request.WebsiteResourceReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/download [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_ssls","output_column":"primary_domain","output_value":"domain"}],"formatZH":"下载证书文件 [domain]","formatEN":"download ssl file [domain]"}

func (*BaseApi) ExecComposer ¶

func (b *BaseApi) ExecComposer(c *gin.Context)

@Tags Website @Summary Exec Composer @Accept json @Param request body request.ExecComposerReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/exec/composer [post]

func (*BaseApi) ExportCronjob ¶

func (b *BaseApi) ExportCronjob(c *gin.Context)

@Tags Cronjob @Summary Export cronjob list @Accept json @Param request body dto.OperateByIDs true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/export [post]

func (*BaseApi) ExportSSHLogs ¶

func (b *BaseApi) ExportSSHLogs(c *gin.Context)

@Tags SSH @Summary Export host SSH logs @Accept json @Param request body dto.SearchSSHLog true "request" @Success 200 {string} path @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/log/export [post]

func (*BaseApi) GetAlert ¶

func (b *BaseApi) GetAlert(c *gin.Context)

func (*BaseApi) GetAlertConfig ¶

func (b *BaseApi) GetAlertConfig(c *gin.Context)

func (*BaseApi) GetAlerts ¶

func (b *BaseApi) GetAlerts(c *gin.Context)

func (*BaseApi) GetAntiLeech ¶

func (b *BaseApi) GetAntiLeech(c *gin.Context)

@Tags Website @Summary Get AntiLeech conf @Accept json @Param request body request.NginxCommonReq true "request" @Success 200 {object} response.NginxAntiLeechRes @Security ApiKeyAuth @Security Timestamp @Router /websites/leech [post]

func (*BaseApi) GetApp ¶

func (b *BaseApi) GetApp(c *gin.Context)

@Tags App @Summary Search app by key @Accept json @Param key path string true "app key" @Success 200 {object} response.AppDTO @Security ApiKeyAuth @Security Timestamp @Router /apps/:key [get]

func (*BaseApi) GetAppDetail ¶

func (b *BaseApi) GetAppDetail(c *gin.Context)

@Tags App @Summary Search app detail by appid @Accept json @Param appId path integer true "app id" @Param version path string true "app 版本" @Param version path string true "app 类型" @Success 200 {object} response.AppDetailDTO @Security ApiKeyAuth @Security Timestamp @Router /apps/detail/:appId/:version/:type [get]

func (*BaseApi) GetAppDetailByID ¶

func (b *BaseApi) GetAppDetailByID(c *gin.Context)

@Tags App @Summary Get app detail by id @Accept json @Param appId path integer true "id" @Success 200 {object} response.AppDetailDTO @Security ApiKeyAuth @Security Timestamp @Router /apps/details/:id [get]

func (*BaseApi) GetAppInstallInfo ¶

func (b *BaseApi) GetAppInstallInfo(c *gin.Context)

@Tags App @Summary Get app install info @Accept json @Param appInstallId path integer true "App install id" @Success 200 {object} dto.AppInstallInfo @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/info/:appInstallId [get]

func (*BaseApi) GetAppListUpdate ¶

func (b *BaseApi) GetAppListUpdate(c *gin.Context)

@Tags App @Summary Get app list update @Success 200 {object} response.AppUpdateRes @Security ApiKeyAuth @Security Timestamp @Router /apps/checkupdate [get]

func (*BaseApi) GetAppTags ¶

func (b *BaseApi) GetAppTags(c *gin.Context)

func (*BaseApi) GetAuthConfig ¶

func (b *BaseApi) GetAuthConfig(c *gin.Context)

@Tags Website @Summary Get AuthBasic conf @Accept json @Param request body request.NginxAuthReq true "request" @Success 200 {object} response.NginxAuthRes @Security ApiKeyAuth @Security Timestamp @Router /websites/auths [post]

func (*BaseApi) GetBindDomain ¶

func (b *BaseApi) GetBindDomain(c *gin.Context)

@Tags AI @Summary Get bind domain @Accept json @Param request body dto.OllamaBindDomainReq true "request" @Success 200 {object} dto.OllamaBindDomainRes @Security ApiKeyAuth @Security Timestamp @Router /ai/domain/get [post]

func (*BaseApi) GetClams ¶

func (b *BaseApi) GetClams(c *gin.Context)

func (*BaseApi) GetContent ¶

func (b *BaseApi) GetContent(c *gin.Context)

@Tags File @Summary Load file content @Accept json @Param request body request.FileContentReq true "request" @Success 200 {object} response.FileInfo @Security ApiKeyAuth @Security Timestamp @Router /files/content [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"获取文件内容 path","formatEN":"Load file content path"}

func (*BaseApi) GetCronJobs ¶

func (b *BaseApi) GetCronJobs(c *gin.Context)

func (*BaseApi) GetDNSResolve ¶

func (b *BaseApi) GetDNSResolve(c *gin.Context)

@Tags Website SSL @Summary Resolve website ssl @Accept json @Param request body request.WebsiteDNSReq true "request" @Success 200 {array} response.WebsiteDNSRes @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/resolve [post]

func (*BaseApi) GetDatabase ¶

func (b *BaseApi) GetDatabase(c *gin.Context)

@Tags Database @Summary Get databases @Success 200 {object} dto.DatabaseInfo @Security ApiKeyAuth @Security Timestamp @Router /databases/db/:name [get]

func (*BaseApi) GetDefaultConfig ¶

func (b *BaseApi) GetDefaultConfig(c *gin.Context)

@Tags App @Summary Search default config by key @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/conf [post]

func (*BaseApi) GetDefaultHTTPsStatus ¶

func (b *BaseApi) GetDefaultHTTPsStatus(c *gin.Context)

@Tags OpenResty @Summary Get default HTTPs status @Success 200 {object} response.NginxConfigRes @Security ApiKeyAuth @Security Timestamp @Router /openresty/https [get]

func (*BaseApi) GetDefaultHtml ¶

func (b *BaseApi) GetDefaultHtml(c *gin.Context)

@Tags Website @Summary Get default html @Accept json @Success 200 {object} response.WebsiteHtmlRes @Security ApiKeyAuth @Security Timestamp @Router /websites/default/html/:type [get]

func (*BaseApi) GetDirConfig ¶

func (b *BaseApi) GetDirConfig(c *gin.Context)

@Tags Website @Summary Get website dir @Accept json @Param request body request.WebsiteCommonReq true "request" @Success 200 {object} response.WebsiteDirConfig @Security ApiKeyAuth @Security Timestamp @Router /websites/dir [post]

func (*BaseApi) GetDisks ¶

func (b *BaseApi) GetDisks(c *gin.Context)

func (*BaseApi) GetFPMConfig ¶

func (b *BaseApi) GetFPMConfig(c *gin.Context)

@Tags Runtime @Summary Get fpm config @Accept json @Param id path integer true "request" @Success 200 {object} request.FPMConfig @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/fpm/config/:id [get]

func (*BaseApi) GetFPMStatus ¶

func (b *BaseApi) GetFPMStatus(c *gin.Context)

@Tags Runtime @Summary Get PHP runtime status @Accept json @Param id path integer true "request" @Success 200 {object} map[string]interface{} @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/fpm/status/:id [get]

func (*BaseApi) GetFileTree ¶

func (b *BaseApi) GetFileTree(c *gin.Context)

@Tags File @Summary Load files tree @Accept json @Param request body request.FileOption true "request" @Success 200 {array} response.FileTree @Security ApiKeyAuth @Security Timestamp @Router /files/tree [post]

func (*BaseApi) GetHTTPSConfig ¶

func (b *BaseApi) GetHTTPSConfig(c *gin.Context)

@Tags Website HTTPS @Summary Load https conf @Accept json @Param id path integer true "request" @Success 200 {object} response.WebsiteHTTPS @Security ApiKeyAuth @Security Timestamp @Router /websites/:id/https [get]

func (*BaseApi) GetHostMount ¶

func (b *BaseApi) GetHostMount(c *gin.Context)

@Tags File @Summary system mount @Accept json @Success 200 {object} dto.DiskInfo @Security ApiKeyAuth @Security Timestamp @Router /mount [post]

func (*BaseApi) GetIOOptions ¶

func (b *BaseApi) GetIOOptions(c *gin.Context)

func (*BaseApi) GetLoadBalances ¶

func (b *BaseApi) GetLoadBalances(c *gin.Context)

@Tags Website @Summary Get website upstreams @Accept json @Param request body request.WebsiteCommonReq true "request" @Success 200 {array} dto.NginxUpstream @Security ApiKeyAuth @Security Timestamp @Router /websites/lbs [get]

func (*BaseApi) GetLocalDir ¶

func (b *BaseApi) GetLocalDir(c *gin.Context)

@Tags Backup Account @Summary get local backup dir @Success 200 {string} dir @Security ApiKeyAuth @Security Timestamp @Router /backups/local [get]

func (*BaseApi) GetMcpBindDomain ¶

func (b *BaseApi) GetMcpBindDomain(c *gin.Context)

@Tags McpServer @Summary Get bin Domain for mcp server @Accept json @Success 200 {object} response.McpBindDomainRes @Security ApiKeyAuth @Security Timestamp @Router /mcp/domain/get [get]

func (*BaseApi) GetNetworkOptions ¶

func (b *BaseApi) GetNetworkOptions(c *gin.Context)

func (*BaseApi) GetNginx ¶

func (b *BaseApi) GetNginx(c *gin.Context)

@Tags OpenResty @Summary Load OpenResty conf @Success 200 {object} response.NginxFile @Security ApiKeyAuth @Security Timestamp @Router /openresty [get]

func (*BaseApi) GetNginxConfig ¶

func (b *BaseApi) GetNginxConfig(c *gin.Context)

@Tags Website Nginx @Summary Load nginx conf @Accept json @Param request body request.NginxScopeReq true "request" @Success 200 {object} response.WebsiteNginxConfig @Security ApiKeyAuth @Security Timestamp @Router /websites/config [post]

func (*BaseApi) GetNginxConfigByScope ¶

func (b *BaseApi) GetNginxConfigByScope(c *gin.Context)

@Tags OpenResty @Summary Load partial OpenResty conf @Accept json @Param request body request.NginxScopeReq true "request" @Success 200 {array} response.NginxParam @Security ApiKeyAuth @Security Timestamp @Router /openresty/scope [post]

func (*BaseApi) GetNginxModules ¶

func (b *BaseApi) GetNginxModules(c *gin.Context)

@Tags OpenResty @Summary Get OpenResty modules @Success 200 {object} response.NginxBuildConfig @Security ApiKeyAuth @Security Timestamp @Router /openresty/modules [get]

func (*BaseApi) GetNginxStatus ¶

func (b *BaseApi) GetNginxStatus(c *gin.Context)

@Tags OpenResty @Summary Load OpenResty status info @Success 200 {object} response.NginxStatus @Security ApiKeyAuth @Security Timestamp @Router /openresty/status [get]

func (*BaseApi) GetNodeModules ¶

func (b *BaseApi) GetNodeModules(c *gin.Context)

@Tags Runtime @Summary Get Node modules @Accept json @Param request body request.NodeModuleReq true "request" @Success 200 {array} response.NodeModule @Security ApiKeyAuth @Security Timestamp @Router /runtimes/node/modules [post]

func (*BaseApi) GetNodePackageRunScript ¶

func (b *BaseApi) GetNodePackageRunScript(c *gin.Context)

@Tags Runtime @Summary Get Node package scripts @Accept json @Param request body request.NodePackageReq true "request" @Success 200 {array} response.PackageScripts @Security ApiKeyAuth @Security Timestamp @Router /runtimes/node/package [post]

func (*BaseApi) GetPHPConfig ¶

func (b *BaseApi) GetPHPConfig(c *gin.Context)

@Tags Runtime @Summary Load php runtime conf @Accept json @Param id path integer true "request" @Success 200 {object} response.PHPConfig @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/config/:id [get]

func (*BaseApi) GetPHPConfigFile ¶

func (b *BaseApi) GetPHPConfigFile(c *gin.Context)

@Tags Runtime @Summary Get php conf file @Accept json @Param request body request.PHPFileReq true "request" @Success 200 {object} response.FileInfo @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/file [post]

func (*BaseApi) GetPHPContainerConfig ¶

func (b *BaseApi) GetPHPContainerConfig(c *gin.Context)

@Tags Runtime @Summary Get PHP container config @Accept json @Param id path integer true "request" @Success 200 {object} response.PHPContainerConfig @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/container/:id [get]

func (*BaseApi) GetParams ¶

func (b *BaseApi) GetParams(c *gin.Context)

@Tags App @Summary Search params by appInstallId @Accept json @Param appInstallId path string true "request" @Success 200 {object} response.AppConfig @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/params/:appInstallId [get]

func (*BaseApi) GetPathAuthConfig ¶

func (b *BaseApi) GetPathAuthConfig(c *gin.Context)

@Tags Website @Summary Get AuthBasic conf @Accept json @Param request body request.NginxAuthReq true "request" @Success 200 {object} response.NginxPathAuthRes @Security ApiKeyAuth @Security Timestamp @Router /websites/auths/path [post]

func (*BaseApi) GetPathByType ¶

func (b *BaseApi) GetPathByType(c *gin.Context)

func (*BaseApi) GetProcess ¶

func (b *BaseApi) GetProcess(c *gin.Context)

@Tags Host tool @Summary Get Supervisor process config @Accept json @Success 200 {object} response.SupervisorProcessConfig @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/supervisor/process [get]

func (*BaseApi) GetProcessFile ¶

func (b *BaseApi) GetProcessFile(c *gin.Context)

@Tags Host tool @Summary Get Supervisor process config file @Accept json @Param request body request.SupervisorProcessFileReq true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/supervisor/process/file [post] @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] Supervisor 进程文件 ","formatEN":"[operate] Supervisor Process Config file"}

func (*BaseApi) GetProxyCache ¶

func (b *BaseApi) GetProxyCache(c *gin.Context)

@Summary Get website proxy cache config @Accept json @Param id path int true "id" @Success 200 {object} response.NginxProxyCache @Security ApiKeyAuth @Security Timestamp @Router /websites/proxy/config/{id} [get]

func (*BaseApi) GetProxyConfig ¶

func (b *BaseApi) GetProxyConfig(c *gin.Context)

@Tags Website @Summary Get proxy conf @Accept json @Param request body request.WebsiteProxyReq true "request" @Success 200 {array} request.WebsiteProxyConfig @Security ApiKeyAuth @Security Timestamp @Router /websites/proxies [post]

func (*BaseApi) GetRealIPConfig ¶

func (b *BaseApi) GetRealIPConfig(c *gin.Context)

@Tags Website @Summary Get Real IP Config @Accept json @Param id path int true "id" @Success 200 {object} response.WebsiteRealIP @Security ApiKeyAuth @Security Timestamp @Router /websites/realip/config/{id} [get]

func (*BaseApi) GetRecycleStatus ¶

func (b *BaseApi) GetRecycleStatus(c *gin.Context)

@Tags File @Summary Get RecycleBin status @Accept json @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /files/recycle/status [get]

func (*BaseApi) GetRedirectConfig ¶

func (b *BaseApi) GetRedirectConfig(c *gin.Context)

@Tags Website @Summary Get redirect conf @Accept json @Param request body request.WebsiteProxyReq true "request" @Success 200 {array} response.NginxRedirectConfig @Security ApiKeyAuth @Security Timestamp @Router /websites/redirect [post]

func (*BaseApi) GetRewriteConfig ¶

func (b *BaseApi) GetRewriteConfig(c *gin.Context)

@Tags Website @Summary Get rewrite conf @Accept json @Param request body request.NginxRewriteReq true "request" @Success 200 {object} response.NginxRewriteRes @Security ApiKeyAuth @Security Timestamp @Router /websites/rewrite [post]

func (*BaseApi) GetRuntime ¶

func (b *BaseApi) GetRuntime(c *gin.Context)

@Tags Runtime @Summary Get runtime @Accept json @Param id path string true "request" @Success 200 {object} response.RuntimeDTO @Security ApiKeyAuth @Security Timestamp @Router /runtimes/:id [get]

func (*BaseApi) GetRuntimeExtension ¶

func (b *BaseApi) GetRuntimeExtension(c *gin.Context)

@Tags Runtime @Summary Get php runtime extension @Accept json @Param id path string true "request" @Success 200 {object} response.PHPExtensionRes @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/:id/extensions [get]

func (*BaseApi) GetSSHInfo ¶

func (b *BaseApi) GetSSHInfo(c *gin.Context)

@Tags SSH @Summary Load host SSH setting info @Success 200 {object} dto.SSHInfo @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/search [post]

func (*BaseApi) GetServices ¶

func (b *BaseApi) GetServices(c *gin.Context)

@Tags App @Summary Search app service by key @Accept json @Param key path string true "request" @Success 200 {array} response.AppService @Security ApiKeyAuth @Security Timestamp @Router /apps/services/:key [get]

func (*BaseApi) GetSettingByKey ¶

func (b *BaseApi) GetSettingByKey(c *gin.Context)

@Tags System Setting @Summary Load system setting by key @Param key path string true "key" @Success 200 {object} dto.SettingInfo @Security ApiKeyAuth @Security Timestamp @Router /settings/get/{key} [get]

func (*BaseApi) GetSettingInfo ¶

func (b *BaseApi) GetSettingInfo(c *gin.Context)

@Tags System Setting @Summary Load system setting info @Success 200 {object} dto.SettingInfo @Security ApiKeyAuth @Security Timestamp @Router /settings/search [post]

func (*BaseApi) GetSupervisorProcess ¶

func (b *BaseApi) GetSupervisorProcess(c *gin.Context)

@Tags Runtime @Summary Get supervisor process @Accept json @Param id path integer true "request" @Success 200 {array} response.SupervisorProcessConfig @Security ApiKeyAuth @Security Timestamp @Router /runtimes/supervisor/process/:id [get]

func (*BaseApi) GetSystemAvailable ¶

func (b *BaseApi) GetSystemAvailable(c *gin.Context)

@Tags System Setting @Summary Load system available status @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/search/available [get]

func (*BaseApi) GetSystemFiles ¶

func (b *BaseApi) GetSystemFiles(c *gin.Context)

@Tags Logs @Summary Load system log files @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /logs/system/files [get]

func (*BaseApi) GetToolLog ¶

func (b *BaseApi) GetToolLog(c *gin.Context)

@Tags Host tool @Summary Get tool logs @Accept json @Param request body request.HostToolLogReq true "request" @Success 200 {string} logContent @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/log [post]

func (*BaseApi) GetToolStatus ¶

func (b *BaseApi) GetToolStatus(c *gin.Context)

@Tags Host tool @Summary Get tool status @Accept json @Param request body request.HostToolReq true "request" @Success 200 {object} response.HostToolRes @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool [post]

func (*BaseApi) GetUpdateVersions ¶

func (b *BaseApi) GetUpdateVersions(c *gin.Context)

@Tags App @Summary Search app update version by install id @Accept json @Param appInstallId path integer true "request" @Success 200 {array} dto.AppVersion @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/update/versions [post]

func (*BaseApi) GetUsersAndGroups ¶

func (b *BaseApi) GetUsersAndGroups(c *gin.Context)

@Tags File @Summary system user and group @Accept json @Success 200 {object} response.UserGroupResponse @Security ApiKeyAuth @Security Timestamp @Router /user/group [post]

func (*BaseApi) GetWebDomains ¶

func (b *BaseApi) GetWebDomains(c *gin.Context)

@Tags Website Domain @Summary Search website domains by websiteId @Accept json @Param websiteId path integer true "request" @Success 200 {array} model.WebsiteDomain @Security ApiKeyAuth @Security Timestamp @Router /websites/domains/:websiteId [get]

func (*BaseApi) GetWebsite ¶

func (b *BaseApi) GetWebsite(c *gin.Context)

@Tags Website @Summary Search website by id @Accept json @Param id path integer true "request" @Success 200 {object} response.WebsiteDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/:id [get]

func (*BaseApi) GetWebsiteCA ¶

func (b *BaseApi) GetWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Get website ca @Accept json @Param id path int true "id" @Success 200 {object} response.WebsiteCADTO @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/{id} [get]

func (*BaseApi) GetWebsiteDatabase ¶

func (b *BaseApi) GetWebsiteDatabase(c *gin.Context)

@Tags Website @Summary Get databases @Accept json @Success 200 {object} response.Database @Security ApiKeyAuth @Security Timestamp @Router /websites/databases [get]

func (*BaseApi) GetWebsiteNginx ¶

func (b *BaseApi) GetWebsiteNginx(c *gin.Context)

@Tags Website Nginx @Summary Search website nginx by id @Accept json @Param id path integer true "request" @Success 200 {object} response.FileInfo @Security ApiKeyAuth @Security Timestamp @Router /websites/:id/config/:type [get]

func (*BaseApi) GetWebsiteOptions ¶

func (b *BaseApi) GetWebsiteOptions(c *gin.Context)

@Tags Website @Summary List website names @Success 200 {array} response.WebsiteOption @Security ApiKeyAuth @Security Timestamp @Router /websites/options [post]

func (*BaseApi) GetWebsiteResource ¶

func (b *BaseApi) GetWebsiteResource(c *gin.Context)

@Tags Website @Summary Get website resource @Accept json @Param id path int true "id" @Success 200 {object} response.Resource @Security ApiKeyAuth @Security Timestamp @Router /websites/resource/{id} [get]

func (*BaseApi) GetWebsiteSSLById ¶

func (b *BaseApi) GetWebsiteSSLById(c *gin.Context)

@Tags Website SSL @Summary Search website ssl by id @Accept json @Param id path integer true "request" @Success 200 {object} response.WebsiteSSLDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/:id [get]

func (*BaseApi) GetWebsiteSSLByWebsiteId ¶

func (b *BaseApi) GetWebsiteSSLByWebsiteId(c *gin.Context)

@Tags Website SSL @Summary Search website ssl by website id @Accept json @Param websiteId path integer true "request" @Success 200 {object} response.WebsiteSSLDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/website/:websiteId [get]

func (*BaseApi) GetWebsites ¶

func (b *BaseApi) GetWebsites(c *gin.Context)

@Tags Website @Summary List websites @Success 200 {array} response.WebsiteDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/list [get]

func (*BaseApi) HandleClamScan ¶

func (b *BaseApi) HandleClamScan(c *gin.Context)

@Tags Clam @Summary Handle clam scan @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/handle [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":true,"db":"clams","output_column":"name","output_value":"name"}],"formatZH":"执行病毒扫描 [name]","formatEN":"handle clam scan [name]"}

func (*BaseApi) HandleOnce ¶

func (b *BaseApi) HandleOnce(c *gin.Context)

@Tags Cronjob @Summary Handle cronjob once @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/handle [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"手动执行计划任务 [name]","formatEN":"manually execute the cronjob [name]"}

func (*BaseApi) IgnoreAppUpgrade ¶

func (b *BaseApi) IgnoreAppUpgrade(c *gin.Context)

@Tags App @Summary Ignore Upgrade App @Accept json @Param request body request.AppIgnoreUpgradeReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/ignore [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"忽略应用升级","formatEN":"Ignore application upgrade"}

func (*BaseApi) ImageBuild ¶

func (b *BaseApi) ImageBuild(c *gin.Context)

@Tags Container Image @Summary Build image @Accept json @Param request body dto.ImageBuild true "request" @Success 200 {string} log @Security ApiKeyAuth @Security Timestamp @Router /containers/image/build [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"构建镜像 [name]","formatEN":"build image [name]"}

func (*BaseApi) ImageLoad ¶

func (b *BaseApi) ImageLoad(c *gin.Context)

@Tags Container Image @Summary Load image @Accept json @Param request body dto.ImageLoad true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/load [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"从 path 加载镜像","formatEN":"load image from path"}

func (*BaseApi) ImagePull ¶

func (b *BaseApi) ImagePull(c *gin.Context)

@Tags Container Image @Summary Pull image @Accept json @Param request body dto.ImagePull true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/pull [post] @x-panel-log {"bodyKeys":["repoID","imageName"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"repoID","isList":false,"db":"image_repos","output_column":"name","output_value":"reponame"}],"formatZH":"镜像拉取 [reponame][imageName]","formatEN":"image pull [reponame][imageName]"}

func (*BaseApi) ImagePush ¶

func (b *BaseApi) ImagePush(c *gin.Context)

@Tags Container Image @Summary Push image @Accept json @Param request body dto.ImagePush true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/push [post] @x-panel-log {"bodyKeys":["repoID","tagName","name"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"repoID","isList":false,"db":"image_repos","output_column":"name","output_value":"reponame"}],"formatZH":"[tagName] 推送到 [reponame][name]","formatEN":"push [tagName] to [reponame][name]"}

func (*BaseApi) ImageRemove ¶

func (b *BaseApi) ImageRemove(c *gin.Context)

@Tags Container Image @Summary Delete image @Accept json @Param request body dto.BatchDelete true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/remove [post] @x-panel-log {"bodyKeys":["names"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"移除镜像 [names]","formatEN":"remove image [names]"}

func (*BaseApi) ImageSave ¶

func (b *BaseApi) ImageSave(c *gin.Context)

@Tags Container Image @Summary Save image @Accept json @Param request body dto.ImageSave true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/save [post] @x-panel-log {"bodyKeys":["tagName","path","name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"保留 [tagName] 为 path/[name]","formatEN":"save [tagName] as path/[name]"}

func (*BaseApi) ImageTag ¶

func (b *BaseApi) ImageTag(c *gin.Context)

@Tags Container Image @Summary Tag image @Accept json @Param request body dto.ImageTag true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/image/tag [post] @x-panel-log {"bodyKeys":["repoID","targetName"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"repoID","isList":false,"db":"image_repos","output_column":"name","output_value":"reponame"}],"formatZH":"tag 镜像 [reponame][targetName]","formatEN":"tag image [reponame][targetName]"}

func (*BaseApi) ImportCronjob ¶

func (b *BaseApi) ImportCronjob(c *gin.Context)

@Tags Cronjob @Summary Import cronjob list @Accept json @Param request body dto.CronjobImport true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/import [post]

func (*BaseApi) ImportMasterSSL ¶

func (b *BaseApi) ImportMasterSSL(c *gin.Context)

func (*BaseApi) ImportSnapshot ¶

func (b *BaseApi) ImportSnapshot(c *gin.Context)

@Tags System Setting @Summary Import system snapshot @Accept json @Param request body dto.SnapshotImport true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/import [post] @x-panel-log {"bodyKeys":["from", "names"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"从 [from] 同步系统快照 [names]","formatEN":"Sync system snapshots [names] from [from]"}

func (*BaseApi) InitToolConfig ¶

func (b *BaseApi) InitToolConfig(c *gin.Context)

@Tags Host tool @Summary Create Host tool Config @Accept json @Param request body request.HostToolCreate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/create [post] @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 [type] 配置","formatEN":"create [type] config"}

func (*BaseApi) Inspect ¶

func (b *BaseApi) Inspect(c *gin.Context)

@Tags Container @Summary Container inspect @Accept json @Param request body dto.InspectReq true "request" @Success 200 {string} result @Security ApiKeyAuth @Security Timestamp @Router /containers/inspect [post]

func (*BaseApi) InstallApp ¶

func (b *BaseApi) InstallApp(c *gin.Context)

@Tags App @Summary Install app @Accept json @Param request body request.AppInstallCreate true "request" @Success 200 {object} model.AppInstall @Security ApiKeyAuth @Security Timestamp @Router /apps/install [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"安装应用 [name]","formatEN":"Install app [name]"}

func (*BaseApi) InstallCli ¶

func (b *BaseApi) InstallCli(c *gin.Context)

@Tags Database Redis @Summary Install redis-cli @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/install/cli [post]

func (*BaseApi) InstallPHPExtension ¶

func (b *BaseApi) InstallPHPExtension(c *gin.Context)

@Tags Runtime @Summary Install php extension @Accept json @Param request body request.PHPExtensionInstallReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions/install [post]

func (*BaseApi) ListAllImage ¶

func (b *BaseApi) ListAllImage(c *gin.Context)

@Tags Container Image @Summary List all images @Produce json @Success 200 {array} dto.ImageInfo @Security ApiKeyAuth @Security Timestamp @Router /containers/image/all [get]

func (*BaseApi) ListAppIgnored ¶

func (b *BaseApi) ListAppIgnored(c *gin.Context)

@Tags App @Summary List Upgrade Ignored App @Accept json @Success 200 {array} model.AppIgnoreUpgrade @Security ApiKeyAuth @Security Timestamp @Router /apps/ignored/detail [get]

func (*BaseApi) ListAppInstalled ¶

func (b *BaseApi) ListAppInstalled(c *gin.Context)

@Tags App @Summary List app installed @Accept json @Success 200 {array} dto.AppInstallInfo @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/list [get]

func (*BaseApi) ListBuckets ¶

func (b *BaseApi) ListBuckets(c *gin.Context)

@Tags Backup Account @Summary List buckets @Accept json @Param request body dto.ForBuckets true "request" @Success 200 {array} object @Security ApiKeyAuth @Security Timestamp @Router /buckets [post]

func (*BaseApi) ListComposeTemplate ¶

func (b *BaseApi) ListComposeTemplate(c *gin.Context)

@Tags Container Compose-template @Summary List compose templates @Produce json @Success 200 {array} dto.ComposeTemplateInfo @Security ApiKeyAuth @Security Timestamp @Router /containers/template [get]

func (*BaseApi) ListContainer ¶

func (b *BaseApi) ListContainer(c *gin.Context)

@Tags Container @Summary List containers @Accept json @Produce json @Success 200 {array} dto.ContainerOptions @Security ApiKeyAuth @Security Timestamp @Router /containers/list [post]

func (*BaseApi) ListContainerByImage ¶

func (b *BaseApi) ListContainerByImage(c *gin.Context)

@Tags Container @Summary List containers by image @Accept json @Produce json @Success 200 {array} dto.ContainerOptions @Security ApiKeyAuth @Security Timestamp @Router /containers/list/byimage [post]

func (*BaseApi) ListCustomRewrite ¶

func (b *BaseApi) ListCustomRewrite(c *gin.Context)

@Tags Website @Summary List custom rewrite @Accept json @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /websites/rewrite/custom [get]

func (*BaseApi) ListDBName ¶

func (b *BaseApi) ListDBName(c *gin.Context)

@Tags Database Mysql @Summary List mysql database names @Accept json @Param request body dto.PageInfo true "request" @Success 200 {array} dto.MysqlOption @Security ApiKeyAuth @Security Timestamp @Router /databases/options [get]

func (*BaseApi) ListDatabase ¶

func (b *BaseApi) ListDatabase(c *gin.Context)

@Tags Database @Summary List databases @Success 200 {array} dto.DatabaseOption @Security ApiKeyAuth @Security Timestamp @Router /databases/db/list/:type [get]

func (*BaseApi) ListFiles ¶

func (b *BaseApi) ListFiles(c *gin.Context)

@Tags File @Summary List files @Accept json @Param request body request.FileOption true "request" @Success 200 {object} response.FileInfo @Security ApiKeyAuth @Security Timestamp @Router /files/search [post]

func (*BaseApi) ListGroup ¶

func (b *BaseApi) ListGroup(c *gin.Context)

@Tags System Group @Summary List groups @Accept json @Param request body dto.GroupSearch true "request" @Success 200 {array} dto.OperateByType @Security ApiKeyAuth @Security Timestamp @Router /agent/groups/search [post]

func (*BaseApi) ListImage ¶

func (b *BaseApi) ListImage(c *gin.Context)

@Tags Container Image @Summary load images options @Produce json @Success 200 {array} dto.Options @Security ApiKeyAuth @Security Timestamp @Router /containers/image [get]

func (*BaseApi) ListNetwork ¶

func (b *BaseApi) ListNetwork(c *gin.Context)

@Tags Container Network @Summary List networks @Accept json @Produce json @Success 200 {array} dto.Options @Security ApiKeyAuth @Security Timestamp @Router /containers/network [get]

func (*BaseApi) ListRepo ¶

func (b *BaseApi) ListRepo(c *gin.Context)

@Tags Container Image-repo @Summary List image repos @Produce json @Success 200 {array} dto.ImageRepoOption @Security ApiKeyAuth @Security Timestamp @Router /containers/repo [get]

func (*BaseApi) ListVolume ¶

func (b *BaseApi) ListVolume(c *gin.Context)

@Tags Container Volume @Summary List volumes @Accept json @Produce json @Success 200 {array} dto.Options @Security ApiKeyAuth @Security Timestamp @Router /containers/volume [get]

func (*BaseApi) LoadAppLauncher ¶

func (b *BaseApi) LoadAppLauncher(c *gin.Context)

@Tags Dashboard @Summary Load app launcher @Accept json @Success 200 {Array} dto.AppLauncher @Security ApiKeyAuth @Security Timestamp @Router /dashboard/app/launcher [get]

func (*BaseApi) LoadAppLauncherOption ¶

func (b *BaseApi) LoadAppLauncherOption(c *gin.Context)

@Tags Dashboard @Summary Load app launcher options @Accept json @Param request body dto.SearchByFilter true "request" @Success 200 {Array} dto.LauncherOption @Security ApiKeyAuth @Security Timestamp @Router /dashboard/app/launcher/option [post]

func (*BaseApi) LoadBackupOptions ¶

func (b *BaseApi) LoadBackupOptions(c *gin.Context)

@Tags Backup Account @Summary Load backup account options @Accept json @Success 200 {array} dto.BackupOption @Security ApiKeyAuth @Security Timestamp @Router /backups/options [get]

func (*BaseApi) LoadBackupRecordSize ¶

func (b *BaseApi) LoadBackupRecordSize(c *gin.Context)

@Tags Backup Account @Summary Load backup record size @Accept json @Param request body dto.SearchForSize true "request" @Success 200 {array} dto.RecordFileSize @Security ApiKeyAuth @Security Timestamp @Router /backups/record/size [post]

func (*BaseApi) LoadBaseDir ¶

func (b *BaseApi) LoadBaseDir(c *gin.Context)

@Tags System Setting @Summary Load local backup dir @Success 200 {string} path @Security ApiKeyAuth @Security Timestamp @Router /settings/basedir [get]

func (*BaseApi) LoadClamBaseInfo ¶

func (b *BaseApi) LoadClamBaseInfo(c *gin.Context)

@Tags Clam @Summary Load clam base info @Accept json @Success 200 {object} dto.ClamBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/base [get]

func (*BaseApi) LoadConnInfo ¶

func (b *BaseApi) LoadConnInfo(c *gin.Context)

@Tags App @Summary Search app password by key @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {object} response.DatabaseConn @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/conninfo/:key [get]

func (*BaseApi) LoadContainerStatus ¶

func (b *BaseApi) LoadContainerStatus(c *gin.Context)

@Tags Container @Summary Load containers status @Accept json @Produce json @Success 200 {object} dto.ContainerStatus @Security ApiKeyAuth @Security Timestamp @Router /containers/status [get]

func (*BaseApi) LoadContainerUsers ¶

func (b *BaseApi) LoadContainerUsers(c *gin.Context)

@Tags Container @Summary Load container users @Accept json @Param request body dto.OperationWithName true "request" @Produce json @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /containers/users [post]

func (*BaseApi) LoadCronjobInfo ¶

func (b *BaseApi) LoadCronjobInfo(c *gin.Context)

@Tags Cronjob @Summary Load cronjob info @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/load/info [post]

func (*BaseApi) LoadCurrentInfoForNode ¶

func (b *BaseApi) LoadCurrentInfoForNode(c *gin.Context)

@Tags Dashboard @Summary Load dashboard current info for node @Success 200 {object} dto.NodeCurrent @Security ApiKeyAuth @Security Timestamp @Router /dashboard/current/node [get]

func (*BaseApi) LoadDBBaseInfo ¶

func (b *BaseApi) LoadDBBaseInfo(c *gin.Context)

@Tags Database Common @Summary Load base info @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {object} dto.DBBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /databases/common/info [post]

func (*BaseApi) LoadDBFile ¶

func (b *BaseApi) LoadDBFile(c *gin.Context)

@Tags Database Common @Summary Load Database conf @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /databases/common/load/file [post]

func (*BaseApi) LoadDBFromRemote ¶

func (b *BaseApi) LoadDBFromRemote(c *gin.Context)

@Tags Database Mysql @Summary Load mysql database from remote @Accept json @Param request body dto.MysqlLoadDB true "request" @Security ApiKeyAuth @Security Timestamp @Router /databases/load [post]

func (*BaseApi) LoadDaemonJson ¶

func (b *BaseApi) LoadDaemonJson(c *gin.Context)

@Tags Container Docker @Summary Load docker daemon.json @Produce json @Success 200 {object} dto.DaemonJsonConf @Security ApiKeyAuth @Security Timestamp @Router /containers/daemonjson [get]

func (*BaseApi) LoadDaemonJsonFile ¶

func (b *BaseApi) LoadDaemonJsonFile(c *gin.Context)

@Tags Container Docker @Summary Load docker daemon.json @Produce json @Success 200 {object} string @Security ApiKeyAuth @Security Timestamp @Router /containers/daemonjson/file [get]

func (*BaseApi) LoadDashboardBaseInfo ¶

func (b *BaseApi) LoadDashboardBaseInfo(c *gin.Context)

@Tags Dashboard @Summary Load dashboard base info @Accept json @Param ioOption path string true "request" @Param netOption path string true "request" @Success 200 {object} dto.DashboardBase @Security ApiKeyAuth @Security Timestamp @Router /dashboard/base/:ioOption/:netOption [get]

func (*BaseApi) LoadDashboardCurrentInfo ¶

func (b *BaseApi) LoadDashboardCurrentInfo(c *gin.Context)

@Tags Dashboard @Summary Load dashboard current info @Accept json @Param ioOption path string true "request" @Param netOption path string true "request" @Success 200 {object} dto.DashboardCurrent @Security ApiKeyAuth @Security Timestamp @Router /dashboard/current/:ioOption/:netOption [get]

func (*BaseApi) LoadDashboardOsInfo ¶

func (b *BaseApi) LoadDashboardOsInfo(c *gin.Context)

@Tags Dashboard @Summary Load os info @Accept json @Success 200 {object} dto.OsInfo @Security ApiKeyAuth @Security Timestamp @Router /dashboard/base/os [get]

func (*BaseApi) LoadDatabaseItems ¶

func (b *BaseApi) LoadDatabaseItems(c *gin.Context)

@Tags Database @Summary List databases @Success 200 {array} dto.DatabaseItem @Security ApiKeyAuth @Security Timestamp @Router /databases/db/item/:type [get]

func (*BaseApi) LoadDeviceBaseInfo ¶

func (b *BaseApi) LoadDeviceBaseInfo(c *gin.Context)

@Tags Device @Summary Load device base info @Success 200 {object} dto.DeviceBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/base [post]

func (*BaseApi) LoadDeviceConf ¶

func (b *BaseApi) LoadDeviceConf(c *gin.Context)

@Tags Device @Summary load conf @Accept json @Param request body dto.OperationWithName true "request" @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/conf [post]

func (*BaseApi) LoadDockerStatus ¶

func (b *BaseApi) LoadDockerStatus(c *gin.Context)

@Tags Container Docker @Summary Load docker status @Produce json @Success 200 {string} dto.DockerStatus @Security ApiKeyAuth @Security Timestamp @Router /containers/docker/status [get]

func (*BaseApi) LoadFail2BanBaseInfo ¶

func (b *BaseApi) LoadFail2BanBaseInfo(c *gin.Context)

@Tags Fail2ban @Summary Load fail2ban base info @Success 200 {object} dto.Fail2BanBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/base [get]

func (*BaseApi) LoadFail2BanConf ¶

func (b *BaseApi) LoadFail2BanConf(c *gin.Context)

@Tags Fail2ban @Summary Load fail2ban conf @Accept json @Success 200 {string} file @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/load/conf [get]

func (*BaseApi) LoadFilesFromBackup ¶

func (b *BaseApi) LoadFilesFromBackup(c *gin.Context)

@Tags Backup Account @Summary List files from backup accounts @Accept json @Param request body dto.OperateByID true "request" @Success 200 {array} string @Security ApiKeyAuth @Security Timestamp @Router /backups/search/files [post]

func (*BaseApi) LoadFirewallBaseInfo ¶

func (b *BaseApi) LoadFirewallBaseInfo(c *gin.Context)

@Tags Firewall @Summary Load firewall base info @Success 200 {object} dto.FirewallBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/base [get]

func (*BaseApi) LoadFtpBaseInfo ¶

func (b *BaseApi) LoadFtpBaseInfo(c *gin.Context)

@Tags FTP @Summary Load FTP base info @Success 200 {object} dto.FtpBaseInfo @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/base [get]

func (*BaseApi) LoadFtpLogInfo ¶

func (b *BaseApi) LoadFtpLogInfo(c *gin.Context)

@Tags FTP @Summary Load FTP operation log @Accept json @Param request body dto.FtpLogSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/log/search [post]

func (*BaseApi) LoadGpuInfo ¶

func (b *BaseApi) LoadGpuInfo(c *gin.Context)

@Tags AI @Summary Load gpu / xpu info @Accept json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/gpu/load [get]

func (*BaseApi) LoadMonitor ¶

func (b *BaseApi) LoadMonitor(c *gin.Context)

@Tags Monitor @Summary Load monitor data @Param request body dto.MonitorSearch true "request" @Success 200 {array} dto.MonitorData @Security ApiKeyAuth @Security Timestamp @Router /hosts/monitor/search [post]

func (*BaseApi) LoadMonitorSetting ¶

func (b *BaseApi) LoadMonitorSetting(c *gin.Context)

@Tags Monitor @Summary Load monitor setting @Success 200 {object} dto.MonitorSetting @Security ApiKeyAuth @Security Timestamp @Router /hosts/monitor/setting [get]

func (*BaseApi) LoadNextHandle ¶

func (b *BaseApi) LoadNextHandle(c *gin.Context)

@Tags Cronjob @Summary Load cronjob spec time @Accept json @Param request body dto.CronjobSpec true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/next [post]

func (*BaseApi) LoadOllamaModelDetail ¶

func (b *BaseApi) LoadOllamaModelDetail(c *gin.Context)

@Tags AI @Summary Page Ollama models @Accept json @Param request body dto.OllamaModelName true "request" @Success 200 {string} details @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/load [post]

func (*BaseApi) LoadPersistenceConf ¶

func (b *BaseApi) LoadPersistenceConf(c *gin.Context)

@Tags Database Redis @Summary Load redis persistence conf @Accept json @Param request body dto.LoadRedisStatus true "request" @Success 200 {object} dto.RedisPersistence @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/persistence/conf [post]

func (*BaseApi) LoadPort ¶

func (b *BaseApi) LoadPort(c *gin.Context)

@Tags App @Summary Search app port by key @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {integer} port @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/loadport [post]

func (*BaseApi) LoadPostgresqlDBFromRemote ¶

func (b *BaseApi) LoadPostgresqlDBFromRemote(c *gin.Context)

@Tags Database PostgreSQL @Summary Load postgresql database from remote @Accept json @Param request body dto.PostgresqlLoadDB true "request" @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/:database/load [post]

func (*BaseApi) LoadQuickOption ¶

func (b *BaseApi) LoadQuickOption(c *gin.Context)

@Tags Dashboard @Summary Load quick jump options @Success 200 {Array} dto.QuickJump @Security ApiKeyAuth @Security Timestamp @Router /dashboard/quick/option [post]

func (*BaseApi) LoadRecordLog ¶

func (b *BaseApi) LoadRecordLog(c *gin.Context)

@Tags Cronjob @Summary Load Cronjob record log @Accept json @Param request body dto.OperateByID true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/records/log [post]

func (*BaseApi) LoadRedisConf ¶

func (b *BaseApi) LoadRedisConf(c *gin.Context)

@Tags Database Redis @Summary Load redis conf @Accept json @Param request body dto.LoadRedisStatus true "request" @Success 200 {object} dto.RedisConf @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/conf [post]

func (*BaseApi) LoadRedisStatus ¶

func (b *BaseApi) LoadRedisStatus(c *gin.Context)

@Tags Database Redis @Summary Load redis status info @Accept json @Param request body dto.LoadRedisStatus true "request" @Success 200 {object} dto.RedisStatus @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/status [post]

func (*BaseApi) LoadRemoteAccess ¶

func (b *BaseApi) LoadRemoteAccess(c *gin.Context)

@Tags Database Mysql @Summary Load mysql remote access @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {boolean} isRemote @Security ApiKeyAuth @Security Timestamp @Router /databases/remote [post]

func (*BaseApi) LoadResourceLimit ¶

func (b *BaseApi) LoadResourceLimit(c *gin.Context)

@Summary Load container limits @Success 200 {object} dto.ResourceLimit @Security ApiKeyAuth @Security Timestamp @Router /containers/limit [get]

func (*BaseApi) LoadSSHConf ¶

func (b *BaseApi) LoadSSHConf(c *gin.Context)

@Tags SSH @Summary Load host SSH conf @Success 200 {string} conf @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/conf [get]

func (*BaseApi) LoadSSHLogs ¶

func (b *BaseApi) LoadSSHLogs(c *gin.Context)

@Tags SSH @Summary Load host SSH logs @Accept json @Param request body dto.SearchSSHLog true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/log [post]

func (*BaseApi) LoadScriptOptions ¶

func (b *BaseApi) LoadScriptOptions(c *gin.Context)

@Tags Cronjob @Summary Load script options @Success 200 {array} dto.ScriptOptions @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/script/options [get]

func (*BaseApi) LoadSnapshotData ¶

func (b *BaseApi) LoadSnapshotData(c *gin.Context)

@Tags System Setting @Summary Load system snapshot data @Success 200 {object} dto.SnapshotData @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/load [get]

func (*BaseApi) LoadStatus ¶

func (b *BaseApi) LoadStatus(c *gin.Context)

@Tags Database Mysql @Summary Load mysql status info @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {object} dto.MysqlStatus @Security ApiKeyAuth @Security Timestamp @Router /databases/status [post]

func (*BaseApi) LoadTimeOption ¶

func (b *BaseApi) LoadTimeOption(c *gin.Context)

@Tags Device @Summary list time zone options @Accept json @Success 200 {Array} string @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/zone/options [get]

func (*BaseApi) LoadUsers ¶

func (b *BaseApi) LoadUsers(c *gin.Context)

@Tags Device @Summary Load user list @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/users [get]

func (*BaseApi) LoadVariables ¶

func (b *BaseApi) LoadVariables(c *gin.Context)

@Tags Database Mysql @Summary Load mysql variables info @Accept json @Param request body dto.OperationWithNameAndType true "request" @Success 200 {object} dto.MysqlVariables @Security ApiKeyAuth @Security Timestamp @Router /databases/variables [post]

func (*BaseApi) MoveFile ¶

func (b *BaseApi) MoveFile(c *gin.Context)

@Tags File @Summary Move file @Accept json @Param request body request.FileMove true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/move [post] @x-panel-log {"bodyKeys":["oldPaths","newPath"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"移动文件 [oldPaths] => [newPath]","formatEN":"Move [oldPaths] => [newPath]"}

func (*BaseApi) ObtainWebsiteCA ¶

func (b *BaseApi) ObtainWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Obtain SSL @Accept json @Param request body request.WebsiteCAObtain true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/obtain [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_cas","output_column":"name","output_value":"name"}],"formatZH":"自签 SSL 证书 [name]","formatEN":"Obtain SSL [name]"}

func (*BaseApi) OpWebsite ¶

func (b *BaseApi) OpWebsite(c *gin.Context)

@Tags Website @Summary Operate website @Accept json @Param request body request.WebsiteOp true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/operate [post] @x-panel-log {"bodyKeys":["id", "operate"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"[operate] 网站 [domain]","formatEN":"[operate] website [domain]"}

func (*BaseApi) OpWebsiteLog ¶

func (b *BaseApi) OpWebsiteLog(c *gin.Context)

@Tags Website @Summary Operate website log @Accept json @Param request body request.WebsiteLogReq true "request" @Success 200 {object} response.WebsiteLog @Security ApiKeyAuth @Security Timestamp @Router /websites/log [post] @x-panel-log {"bodyKeys":["id", "operate"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"[domain][operate] 日志","formatEN":"[domain][operate] logs"}

func (*BaseApi) OperateClam ¶

func (b *BaseApi) OperateClam(c *gin.Context)

@Tags Clam @Summary Operate Clam @Accept json @Success 200 @Param request body dto.Operate true "request" @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] Clam","formatEN":"[operation] FTP"}

func (*BaseApi) OperateCrossSiteAccess ¶

func (b *BaseApi) OperateCrossSiteAccess(c *gin.Context)

@Tags Website @Summary Operate Cross Site Access @Accept json @Param request body request.CrossSiteAccessOp true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/crosssite [post]

func (*BaseApi) OperateCustomRewrite ¶

func (b *BaseApi) OperateCustomRewrite(c *gin.Context)

@Tags Website @Summary Operate custom rewrite @Accept json @Param request body request.CustomRewriteOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/rewrite/custom [post]

func (*BaseApi) OperateDefaultHTTPs ¶

func (b *BaseApi) OperateDefaultHTTPs(c *gin.Context)

@Tags OpenResty @Summary Operate default HTTPs @Accept json @Param request body request.NginxOperateReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /openresty/https [post]

func (*BaseApi) OperateDocker ¶

func (b *BaseApi) OperateDocker(c *gin.Context)

@Tags Container Docker @Summary Operate docker @Accept json @Param request body dto.DockerOperation true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/docker/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"docker 服务 [operation]","formatEN":"[operation] docker service"}

func (*BaseApi) OperateFail2Ban ¶

func (b *BaseApi) OperateFail2Ban(c *gin.Context)

@Tags Fail2ban @Summary Operate fail2ban @Accept json @Param request body dto.Operate true "request" @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] Fail2ban","formatEN":"[operation] Fail2ban"}

func (*BaseApi) OperateFirewall ¶

func (b *BaseApi) OperateFirewall(c *gin.Context)

@Tags Firewall @Summary Operate firewall @Accept json @Param request body dto.FirewallOperation true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] 防火墙","formatEN":"[operation] firewall"}

func (*BaseApi) OperateForwardRule ¶

func (b *BaseApi) OperateForwardRule(c *gin.Context)

OperateForwardRule @Tags Firewall @Summary Create group @Accept json @Param request body dto.ForwardRuleOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/forward [post] @x-panel-log {"bodyKeys":["source_port"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新端口转发规则 [source_port]","formatEN":"update port forward rules [source_port]"}

func (*BaseApi) OperateFtp ¶

func (b *BaseApi) OperateFtp(c *gin.Context)

@Tags FTP @Summary Operate FTP @Accept json @Param request body dto.Operate true "request" @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] FTP","formatEN":"[operation] FTP"}

func (*BaseApi) OperateIPRule ¶

func (b *BaseApi) OperateIPRule(c *gin.Context)

@Tags Firewall @Summary Create group @Accept json @Param request body dto.AddrRuleOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/ip [post] @x-panel-log {"bodyKeys":["strategy","address"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加 ip 规则 [strategy] [address]","formatEN":"create address rules [strategy][address]"}

func (*BaseApi) OperateInstalled ¶

func (b *BaseApi) OperateInstalled(c *gin.Context)

@Tags App @Summary Operate installed app @Accept json @Param request body request.AppInstalledOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/op [post] @x-panel-log {"bodyKeys":["installId","operate"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"installId","isList":false,"db":"app_installs","output_column":"app_id","output_value":"appId"},{"input_column":"id","input_value":"installId","isList":false,"db":"app_installs","output_column":"name","output_value":"appName"},{"input_column":"id","input_value":"appId","isList":false,"db":"apps","output_column":"key","output_value":"appKey"}],"formatZH":"[operate] 应用 [appKey][appName]","formatEN":"[operate] App [appKey][appName]"}

func (*BaseApi) OperateMcpServer ¶

func (b *BaseApi) OperateMcpServer(c *gin.Context)

@Tags McpServer @Summary Operate mcp server @Accept json @Param request body request.McpServerOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/server/op [post]

func (*BaseApi) OperateNodeModules ¶

func (b *BaseApi) OperateNodeModules(c *gin.Context)

@Tags Runtime @Summary Operate Node modules @Accept json @Param request body request.NodeModuleReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/node/modules/operate [post]

func (*BaseApi) OperatePortRule ¶

func (b *BaseApi) OperatePortRule(c *gin.Context)

@Tags Firewall @Summary Create group @Accept json @Param request body dto.PortRuleOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/port [post] @x-panel-log {"bodyKeys":["port","strategy"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加端口规则 [strategy] [port]","formatEN":"create port rules [strategy][port]"}

func (*BaseApi) OperateProcess ¶

func (b *BaseApi) OperateProcess(c *gin.Context)

@Tags Host tool @Summary Create Supervisor process @Accept json @Param request body request.SupervisorProcessConfig true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/supervisor/process [post] @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 守护进程 ","formatEN":"[operate] process"}

func (*BaseApi) OperateRuntime ¶

func (b *BaseApi) OperateRuntime(c *gin.Context)

@Tags Runtime @Summary Operate runtime @Accept json @Param request body request.RuntimeOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/operate [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"操作运行环境 [name]","formatEN":"Operate runtime [name]"}

func (*BaseApi) OperateSSH ¶

func (b *BaseApi) OperateSSH(c *gin.Context)

@Tags SSH @Summary Operate SSH @Accept json @Param request body dto.Operate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/operate [post] @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] SSH ","formatEN":"[operation] SSH"}

func (*BaseApi) OperateSSHD ¶

func (b *BaseApi) OperateSSHD(c *gin.Context)

@Tags Fail2ban @Summary Operate sshd of fail2ban @Accept json @Param request body dto.Operate true "request" @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/operate/sshd [post]

func (*BaseApi) OperateSupervisorProcess ¶

func (b *BaseApi) OperateSupervisorProcess(c *gin.Context)

@Tags Runtime @Summary Operate supervisor process @Accept json @Param request body request.PHPSupervisorProcessConfig true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/supervisor/process/operate [post]

func (*BaseApi) OperateSupervisorProcessFile ¶

func (b *BaseApi) OperateSupervisorProcessFile(c *gin.Context)

@Tags Runtime @Summary Operate supervisor process file @Accept json @Param request body request.PHPSupervisorProcessFileReq true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /runtimes/supervisor/process/file/operate [post]

func (*BaseApi) OperateTool ¶

func (b *BaseApi) OperateTool(c *gin.Context)

@Tags Host tool @Summary Operate tool @Accept json @Param request body request.HostToolReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/operate [post] @x-panel-log {"bodyKeys":["operate","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] [type] ","formatEN":"[operate] [type]"}

func (*BaseApi) OperateToolConfig ¶

func (b *BaseApi) OperateToolConfig(c *gin.Context)

@Tags Host tool @Summary Get tool config @Accept json @Param request body request.HostToolConfig true "request" @Success 200 {object} response.HostToolConfig @Security ApiKeyAuth @Security Timestamp @Router /hosts/tool/config [post] @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 主机工具配置文件 ","formatEN":"[operate] tool config"}

func (*BaseApi) OperatorCompose ¶

func (b *BaseApi) OperatorCompose(c *gin.Context)

@Tags Container Compose @Summary Operate compose @Accept json @Param request body dto.ComposeOperation true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/compose/operate [post] @x-panel-log {"bodyKeys":["name","operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"compose [operation] [name]","formatEN":"compose [operation] [name]"}

func (*BaseApi) PageAlert ¶

func (b *BaseApi) PageAlert(c *gin.Context)

func (*BaseApi) PageAlertLogs ¶

func (b *BaseApi) PageAlertLogs(c *gin.Context)

func (*BaseApi) PageMcpServers ¶

func (b *BaseApi) PageMcpServers(c *gin.Context)

@Tags McpServer @Summary List mcp servers @Accept json @Param request body request.McpServerSearch true "request" @Success 200 {object} response.McpServersRes @Security ApiKeyAuth @Security Timestamp @Router /mcp/search [post]

func (*BaseApi) PagePHPExtensions ¶

func (b *BaseApi) PagePHPExtensions(c *gin.Context)

@Tags PHP Extensions @Summary Page Extensions @Accept json @Param request body request.PHPExtensionsSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions/search [post]

func (*BaseApi) PageTasks ¶

func (b *BaseApi) PageTasks(c *gin.Context)

@Tags TaskLog @Summary Page task logs @Accept json @Param request body dto.SearchTaskLogReq true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /logs/tasks/search [post]

func (*BaseApi) PageWebsite ¶

func (b *BaseApi) PageWebsite(c *gin.Context)

@Tags Website @Summary Page websites @Accept json @Param request body request.WebsiteSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /websites/search [post]

func (*BaseApi) PageWebsiteAcmeAccount ¶

func (b *BaseApi) PageWebsiteAcmeAccount(c *gin.Context)

@Tags Website Acme @Summary Page website acme accounts @Accept json @Param request body dto.PageInfo true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /websites/acme/search [post]

func (*BaseApi) PageWebsiteCA ¶

func (b *BaseApi) PageWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Page website ca @Accept json @Param request body request.WebsiteCASearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/search [post]

func (*BaseApi) PageWebsiteDnsAccount ¶

func (b *BaseApi) PageWebsiteDnsAccount(c *gin.Context)

@Tags Website DNS @Summary Page website dns accounts @Accept json @Param request body dto.PageInfo true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /websites/dns/search [post]

func (*BaseApi) PageWebsiteSSL ¶

func (b *BaseApi) PageWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Page website ssl @Accept json @Param request body request.WebsiteSSLSearch true "request" @Success 200 {array} response.WebsiteSSLDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/search [post]

func (*BaseApi) ProcessKeys ¶

func (b *BaseApi) ProcessKeys(c *gin.Context)

func (*BaseApi) ProcessWs ¶

func (b *BaseApi) ProcessWs(c *gin.Context)

func (*BaseApi) ReadFileByLine ¶

func (b *BaseApi) ReadFileByLine(c *gin.Context)

@Tags File @Summary Read file by Line @Param request body request.FileReadByLineReq true "request" @Success 200 {object} response.FileLineContent @Security ApiKeyAuth @Security Timestamp @Router /files/read [post]

func (*BaseApi) Recover ¶

func (b *BaseApi) Recover(c *gin.Context)

@Tags Backup Account @Summary Recover system data @Accept json @Param request body dto.CommonRecover true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/recover [post] @x-panel-log {"bodyKeys":["type","name","detailName","file"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"从 [file] 恢复 [type] 数据 [name][detailName]","formatEN":"recover [type] data [name][detailName] from [file]"}

func (*BaseApi) RecoverByUpload ¶

func (b *BaseApi) RecoverByUpload(c *gin.Context)

@Tags Backup Account @Summary Recover system data by upload @Accept json @Param request body dto.CommonRecover true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/recover/byupload [post] @x-panel-log {"bodyKeys":["type","name","detailName","file"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"从 [file] 恢复 [type] 数据 [name][detailName]","formatEN":"recover [type] data [name][detailName] from [file]"}

func (*BaseApi) RecoverSnapshot ¶

func (b *BaseApi) RecoverSnapshot(c *gin.Context)

@Tags System Setting @Summary Recover system backup @Accept json @Param request body dto.SnapshotRecover true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/recover [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"从系统快照 [name] 恢复","formatEN":"Recover from system backup [name]"}

func (*BaseApi) RecreateOllamaModel ¶

func (b *BaseApi) RecreateOllamaModel(c *gin.Context)

@Tags AI @Summary Rereate Ollama model @Accept json @Param request body dto.OllamaModelName true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/recreate [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加 Ollama 模型重试 [name]","formatEN":"re-add Ollama model [name]"}

func (*BaseApi) RecreateSnapshot ¶

func (b *BaseApi) RecreateSnapshot(c *gin.Context)

@Tags System Setting @Summary Recreate system snapshot @Accept json @Param request body dto.OperateByID true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/recrete [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"重试创建快照 [name]","formatEN":"recrete the snapshot [name]"}

func (*BaseApi) ReduceRecycleBinFile ¶

func (b *BaseApi) ReduceRecycleBinFile(c *gin.Context)

@Tags File @Summary Reduce RecycleBin files @Accept json @Param request body request.RecycleBinReduce true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/recycle/reduce [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"还原回收站文件 [name]","formatEN":"Reduce RecycleBin file [name]"}

func (*BaseApi) RefreshToken ¶

func (b *BaseApi) RefreshToken(c *gin.Context)

@Tags Backup Account @Summary Refresh token @Accept json @Param request body dto.BackupOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/refresh/token [post]

func (*BaseApi) RenewWebsiteCA ¶

func (b *BaseApi) RenewWebsiteCA(c *gin.Context)

@Tags Website CA @Summary Obtain SSL @Accept json @Param request body request.WebsiteCAObtain true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ca/renew [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_cas","output_column":"name","output_value":"name"}],"formatZH":"自签 SSL 证书 [name]","formatEN":"Obtain SSL [name]"}

func (*BaseApi) RollbackSnapshot ¶

func (b *BaseApi) RollbackSnapshot(c *gin.Context)

@Tags System Setting @Summary Rollback system backup @Accept json @Param request body dto.SnapshotRecover true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/rollback [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"从系统快照 [name] 回滚","formatEN":"Rollback from system backup [name]"}

func (*BaseApi) SaveContent ¶

func (b *BaseApi) SaveContent(c *gin.Context)

@Tags File @Summary Update file content @Accept json @Param request body request.FileEdit true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/save [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新文件内容 path","formatEN":"Update file content path"}

func (*BaseApi) SaveLocalConnInfo ¶

func (b *BaseApi) SaveLocalConnInfo(c *gin.Context)

@Tags System Setting @Summary Save local conn info @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/ssh [post]

func (*BaseApi) ScanSystem ¶

func (b *BaseApi) ScanSystem(c *gin.Context)

@Tags Device @Summary Scan system @Success 200 {object} dto.CleanData @Security ApiKeyAuth @Security Timestamp @Router /toolbox/scan [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"扫描系统垃圾文件","formatEN":"scan System Junk Files"}

func (*BaseApi) SearchApp ¶

func (b *BaseApi) SearchApp(c *gin.Context)

@Tags App @Summary List apps @Accept json @Param request body request.AppSearch true "request" @Success 200 {object} response.AppRes @Security ApiKeyAuth @Security Timestamp @Router /apps/search [post]

func (*BaseApi) SearchAppInstalled ¶

func (b *BaseApi) SearchAppInstalled(c *gin.Context)

@Tags App @Summary Page app installed @Accept json @Param request body request.AppInstalledSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/search [post]

func (*BaseApi) SearchBackup ¶

func (b *BaseApi) SearchBackup(c *gin.Context)

@Tags Backup Account @Summary Search backup accounts with page @Accept json @Param request body dto.SearchPageWithType true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/search [post]

func (*BaseApi) SearchBackupRecords ¶

func (b *BaseApi) SearchBackupRecords(c *gin.Context)

@Tags Backup Account @Summary Page backup records @Accept json @Param request body dto.RecordSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /backups/record/search [post]

func (*BaseApi) SearchBackupRecordsByCronjob ¶

func (b *BaseApi) SearchBackupRecordsByCronjob(c *gin.Context)

@Tags Backup Account @Summary Page backup records by cronjob @Accept json @Param request body dto.RecordSearchByCronjob true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /backups/record/search/bycronjob [post]

func (*BaseApi) SearchClam ¶

func (b *BaseApi) SearchClam(c *gin.Context)

@Tags Clam @Summary Page clam @Accept json @Param request body dto.SearchClamWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/search [post]

func (*BaseApi) SearchClamFile ¶

func (b *BaseApi) SearchClamFile(c *gin.Context)

@Tags Clam @Summary Load clam file @Accept json @Param request body dto.ClamFileReq true "request" @Success 200 {string} content @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/file/search [post]

func (*BaseApi) SearchClamRecord ¶

func (b *BaseApi) SearchClamRecord(c *gin.Context)

@Tags Clam @Summary Page clam record @Accept json @Param request body dto.ClamLogSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/record/search [post]

func (*BaseApi) SearchCompose ¶

func (b *BaseApi) SearchCompose(c *gin.Context)

@Tags Container Compose @Summary Page composes @Accept json @Param request body dto.SearchWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/compose/search [post]

func (*BaseApi) SearchComposeTemplate ¶

func (b *BaseApi) SearchComposeTemplate(c *gin.Context)

@Tags Container Compose-template @Summary Page compose templates @Accept json @Param request body dto.SearchWithPage true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/template/search [post]

func (*BaseApi) SearchContainer ¶

func (b *BaseApi) SearchContainer(c *gin.Context)

@Tags Container @Summary Page containers @Accept json @Param request body dto.PageContainer true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/search [post]

func (*BaseApi) SearchCronjob ¶

func (b *BaseApi) SearchCronjob(c *gin.Context)

@Tags Cronjob @Summary Page cronjobs @Accept json @Param request body dto.PageCronjob true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/search [post]

func (*BaseApi) SearchDatabase ¶

func (b *BaseApi) SearchDatabase(c *gin.Context)

@Tags Database @Summary Page databases @Accept json @Param request body dto.DatabaseSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /databases/db/search [post]

func (*BaseApi) SearchFail2Ban ¶

func (b *BaseApi) SearchFail2Ban(c *gin.Context)

@Tags Fail2ban @Summary Page fail2ban ip list @Accept json @Param request body dto.Fail2BanSearch true "request" @Success 200 {Array} string @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/search [post]

func (*BaseApi) SearchFavorite ¶

func (b *BaseApi) SearchFavorite(c *gin.Context)

@Tags File @Summary List favorites @Accept json @Param request body dto.PageInfo true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /files/favorite/search [post]

func (*BaseApi) SearchFirewallRule ¶

func (b *BaseApi) SearchFirewallRule(c *gin.Context)

@Tags Firewall @Summary Page firewall rules @Accept json @Param request body dto.RuleSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/search [post]

func (*BaseApi) SearchFtp ¶

func (b *BaseApi) SearchFtp(c *gin.Context)

@Tags FTP @Summary Page FTP user @Accept json @Param request body dto.SearchWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/search [post]

func (*BaseApi) SearchImage ¶

func (b *BaseApi) SearchImage(c *gin.Context)

@Tags Container Image @Summary Page images @Accept json @Param request body dto.PageImage true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/image/search [post]

func (*BaseApi) SearchJobRecords ¶

func (b *BaseApi) SearchJobRecords(c *gin.Context)

@Tags Cronjob @Summary Page job records @Accept json @Param request body dto.SearchRecord true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/search/records [post]

func (*BaseApi) SearchMysql ¶

func (b *BaseApi) SearchMysql(c *gin.Context)

@Tags Database Mysql @Summary Page mysql databases @Accept json @Param request body dto.MysqlDBSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /databases/search [post]

func (*BaseApi) SearchNetwork ¶

func (b *BaseApi) SearchNetwork(c *gin.Context)

@Tags Container Network @Summary Page networks @Accept json @Param request body dto.SearchWithPage true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/network/search [post]

func (*BaseApi) SearchOllamaModel ¶

func (b *BaseApi) SearchOllamaModel(c *gin.Context)

@Tags AI @Summary Page Ollama models @Accept json @Param request body dto.SearchWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/search [post]

func (*BaseApi) SearchPostgresql ¶

func (b *BaseApi) SearchPostgresql(c *gin.Context)

@Tags Database PostgreSQL @Summary Page postgresql databases @Accept json @Param request body dto.PostgresqlDBSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/search [post]

func (*BaseApi) SearchRecycleBinFile ¶

func (b *BaseApi) SearchRecycleBinFile(c *gin.Context)

@Tags File @Summary List RecycleBin files @Accept json @Param request body dto.PageInfo true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /files/recycle/search [post]

func (*BaseApi) SearchRepo ¶

func (b *BaseApi) SearchRepo(c *gin.Context)

@Tags Container Image-repo @Summary Page image repos @Accept json @Param request body dto.SearchWithPage true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/repo/search [post]

func (*BaseApi) SearchRootCert ¶

func (b *BaseApi) SearchRootCert(c *gin.Context)

@Tags SSH @Summary Load host SSH secret @Accept json @Param request body dto.SearchWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/cert/search [post]

func (*BaseApi) SearchRuntimes ¶

func (b *BaseApi) SearchRuntimes(c *gin.Context)

@Tags Runtime @Summary List runtimes @Accept json @Param request body request.RuntimeSearch true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /runtimes/search [post]

func (*BaseApi) SearchSnapshot ¶

func (b *BaseApi) SearchSnapshot(c *gin.Context)

@Tags System Setting @Summary Page system snapshot @Accept json @Param request body dto.PageSnapshot true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/search [post]

func (*BaseApi) SearchUploadWithPage ¶

func (b *BaseApi) SearchUploadWithPage(c *gin.Context)

@Tags File @Summary Page file @Accept json @Param request body request.SearchUploadWithPage true "request" @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /files/upload/search [post]

func (*BaseApi) SearchVolume ¶

func (b *BaseApi) SearchVolume(c *gin.Context)

@Tags Container Volume @Summary Page volumes @Accept json @Param request body dto.SearchWithPage true "request" @Produce json @Success 200 {object} dto.PageResult @Security ApiKeyAuth @Security Timestamp @Router /containers/volume/search [post]

func (*BaseApi) SetRealIPConfig ¶

func (b *BaseApi) SetRealIPConfig(c *gin.Context)

@Tags Website @Summary Set Real IP @Accept json @Param request body request.WebsiteRealIP true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/realip [post] @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改 [domain] 网站真实IP配置 ","formatEN":"Modify the real IP configuration of [domain] website"}

func (*BaseApi) Size ¶

func (b *BaseApi) Size(c *gin.Context)

@Tags File @Summary Load file size @Accept json @Param request body request.DirSizeReq true "request" @Success 200 {object} response.DirSizeRes @Security ApiKeyAuth @Security Timestamp @Router /files/size [post] @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"获取文件夹大小 path","formatEN":"Load file size path"}

func (*BaseApi) StopProcess ¶

func (b *BaseApi) StopProcess(c *gin.Context)

@Tags Process @Summary Stop Process @Param request body request.ProcessReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /process/stop [post] @x-panel-log {"bodyKeys":["PID"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"结束进程 [PID]","formatEN":"结束进程 [PID]"}

func (*BaseApi) SyncApp ¶

func (b *BaseApi) SyncApp(c *gin.Context)

@Tags App @Summary Sync remote app list @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/sync/remote [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"应用商店同步","formatEN":"App store synchronization"}

func (*BaseApi) SyncFtp ¶

func (b *BaseApi) SyncFtp(c *gin.Context)

@Tags FTP @Summary Sync FTP user @Accept json @Param request body dto.BatchDeleteReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/sync [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 FTP 账户","formatEN":"sync FTP users"}

func (*BaseApi) SyncInstalled ¶

func (b *BaseApi) SyncInstalled(c *gin.Context)

Sync app installed @Tags App @Summary Sync app installed @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/sync [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步已安装应用列表","formatEN":"Sync the list of installed apps"}

func (*BaseApi) SyncLocalApp ¶

func (b *BaseApi) SyncLocalApp(c *gin.Context)

@Tags App @Summary Sync local app list @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/sync/local [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"应用商店同步","formatEN":"App store synchronization"}

func (*BaseApi) SyncOllamaModel ¶

func (b *BaseApi) SyncOllamaModel(c *gin.Context)

@Tags AI @Summary Sync Ollama model list @Success 200 {array} dto.OllamaModelDropList @Security ApiKeyAuth @Security Timestamp @Router /ai/ollama/model/sync [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 Ollama 模型列表","formatEN":"sync Ollama model list"}

func (*BaseApi) SyncRootCert ¶

func (b *BaseApi) SyncRootCert(c *gin.Context)

@Tags SSH @Summary Sycn host SSH secret @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/cert/sync [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 SSH 密钥 ","formatEN":"sync SSH secret"}

func (*BaseApi) SyncStatus ¶

func (b *BaseApi) SyncStatus(c *gin.Context)

@Tags Runtime @Summary Sync runtime status @Accept json @Success 200 @Security ApiKeyAuth @Router /runtimes/sync [post]

func (*BaseApi) SystemClean ¶

func (b *BaseApi) SystemClean(c *gin.Context)

@Tags Device @Summary Clean system @Accept json @Param request body []dto.Clean true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clean [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理系统垃圾文件","formatEN":"Clean system junk files"}

func (*BaseApi) SystemRestart ¶

func (b *BaseApi) SystemRestart(c *gin.Context)

@Tags Dashboard @Summary System restart @Accept json @Param operation path string true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /dashboard/system/restart/:operation [post]

func (*BaseApi) TestAlertConfig ¶

func (b *BaseApi) TestAlertConfig(c *gin.Context)

func (*BaseApi) TestCompose ¶

func (b *BaseApi) TestCompose(c *gin.Context)

@Tags Container Compose @Summary Test compose @Accept json @Param request body dto.ComposeCreate true "request" @Success 200 {boolean} isOK @Security ApiKeyAuth @Security Timestamp @Router /containers/compose/test [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"检测 compose [name] 格式","formatEN":"check compose [name]"}

func (*BaseApi) UnInstallPHPExtension ¶

func (b *BaseApi) UnInstallPHPExtension(c *gin.Context)

@Tags Runtime @Summary UnInstall php extension @Accept json @Param request body request.PHPExtensionInstallReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions/uninstall [post]

func (*BaseApi) UpdateAddrRule ¶

func (b *BaseApi) UpdateAddrRule(c *gin.Context)

@Tags Firewall @Summary Create group @Accept json @Param request body dto.AddrRuleUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/update/addr [post]

func (*BaseApi) UpdateAlert ¶

func (b *BaseApi) UpdateAlert(c *gin.Context)

func (*BaseApi) UpdateAlertConfig ¶

func (b *BaseApi) UpdateAlertConfig(c *gin.Context)

func (*BaseApi) UpdateAlertStatus ¶

func (b *BaseApi) UpdateAlertStatus(c *gin.Context)

func (*BaseApi) UpdateAntiLeech ¶

func (b *BaseApi) UpdateAntiLeech(c *gin.Context)

@Tags Website @Summary Update AntiLeech @Accept json @Param request body request.NginxAntiLeechUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/leech/update [post]

func (*BaseApi) UpdateAppConfig ¶

func (b *BaseApi) UpdateAppConfig(c *gin.Context)

@Tags App @Summary Update app config @Accept json @Param request body request.AppConfigUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/config/update [post] @x-panel-log {"bodyKeys":["installID","webUI"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"应用配置更新 [installID]","formatEN":"Application config update [installID]"}

func (*BaseApi) UpdateAppLauncher ¶

func (b *BaseApi) UpdateAppLauncher(c *gin.Context)

@Tags Dashboard @Summary Update app Launcher @Accept json @Param request body dto.SettingUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /dashboard/app/launcher/show [post] @x-panel-log {"bodyKeys":["key", "value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"首页应用 [key] => 显示：[value]","formatEN":"app launcher [key] => show: [value]"}

func (*BaseApi) UpdateAuthConfig ¶

func (b *BaseApi) UpdateAuthConfig(c *gin.Context)

@Tags Website @Summary Get AuthBasic conf @Accept json @Param request body request.NginxAuthUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/auths/update [post]

func (*BaseApi) UpdateBackup ¶

func (b *BaseApi) UpdateBackup(c *gin.Context)

@Tags Backup Account @Summary Update backup account @Accept json @Param request body dto.BackupOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/update [post] @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新备份账号 [types]","formatEN":"update backup account [types]"}

func (*BaseApi) UpdateBindDomain ¶

func (b *BaseApi) UpdateBindDomain(c *gin.Context)

Tags AI Summary Update bind domain Accept json Param request body dto.OllamaBindDomain true "request" Success 200 Security ApiKeyAuth Security Timestamp Router /ai/domain/update [post]

func (*BaseApi) UpdateClam ¶

func (b *BaseApi) UpdateClam(c *gin.Context)

@Tags Clam @Summary Update clam @Accept json @Param request body dto.ClamUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/update [post] @x-panel-log {"bodyKeys":["name","path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改扫描规则 [name]path","formatEN":"update clam [name]path"}

func (*BaseApi) UpdateClamStatus ¶

func (b *BaseApi) UpdateClamStatus(c *gin.Context)

@Tags Clam @Summary Update clam status @Accept json @Param request body dto.ClamUpdateStatus true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/status/update [post] @x-panel-log {"bodyKeys":["id","status"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"clams","output_column":"name","output_value":"name"}],"formatZH":"修改扫描规则 [name] 状态为 [status]","formatEN":"change the status of clam [name] to [status]."}

func (*BaseApi) UpdateComposeTemplate ¶

func (b *BaseApi) UpdateComposeTemplate(c *gin.Context)

@Tags Container Compose-template @Summary Update compose template @Accept json @Param request body dto.ComposeTemplateUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/template/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"compose_templates","output_column":"name","output_value":"name"}],"formatZH":"更新 compose 模版 [name]","formatEN":"update compose template information [name]"}

func (*BaseApi) UpdateCronjob ¶

func (b *BaseApi) UpdateCronjob(c *gin.Context)

@Tags Cronjob @Summary Update cronjob @Accept json @Param request body dto.CronjobOperate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"更新计划任务 [name]","formatEN":"update cronjob [name]"}

func (*BaseApi) UpdateCronjobGroup ¶

func (b *BaseApi) UpdateCronjobGroup(c *gin.Context)

@Tags Cronjob @Summary Update cronjob group @Accept json @Param request body dto.ChangeGroup true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/group/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"更新计划任务分组 [name]","formatEN":"update cronjob group [name]"}

func (*BaseApi) UpdateCronjobStatus ¶

func (b *BaseApi) UpdateCronjobStatus(c *gin.Context)

@Tags Cronjob @Summary Update cronjob status @Accept json @Param request body dto.CronjobUpdateStatus true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /cronjobs/status [post] @x-panel-log {"bodyKeys":["id","status"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"修改计划任务 [name] 状态为 [status]","formatEN":"change the status of cronjob [name] to [status]."}

func (*BaseApi) UpdateDBConfByFile ¶

func (b *BaseApi) UpdateDBConfByFile(c *gin.Context)

@Tags Database Common @Summary Update conf by upload file @Accept json @Param request body dto.DBConfUpdateByFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/common/update/conf [post] @x-panel-log {"bodyKeys":["type","database"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 [type] 数据库 [database] 配置信息","formatEN":"update the [type] [database] database configuration information"}

func (*BaseApi) UpdateDaemonJson ¶

func (b *BaseApi) UpdateDaemonJson(c *gin.Context)

@Tags Container Docker @Summary Update docker daemon.json @Accept json @Param request body dto.SettingUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/daemonjson/update [post] @x-panel-log {"bodyKeys":["key", "value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新配置 [key]","formatEN":"Updated configuration [key]"}

func (*BaseApi) UpdateDaemonJsonByFile ¶

func (b *BaseApi) UpdateDaemonJsonByFile(c *gin.Context)

@Tags Container Docker @Summary Update docker daemon.json by upload file @Accept json @Param request body dto.DaemonJsonUpdateByFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/daemonjson/update/byfile [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新配置文件","formatEN":"Updated configuration file"}

func (*BaseApi) UpdateDatabase ¶

func (b *BaseApi) UpdateDatabase(c *gin.Context)

@Tags Database @Summary Update database @Accept json @Param request body dto.DatabaseUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/db/update [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新远程数据库 [name]","formatEN":"update database [name]"}

func (*BaseApi) UpdateDefaultHtml ¶

func (b *BaseApi) UpdateDefaultHtml(c *gin.Context)

@Tags Website @Summary Update default html @Accept json @Param request body request.WebsiteHtmlUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/default/html/update [post] @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新默认 html","formatEN":"Update default html"}

func (*BaseApi) UpdateDeviceByFile ¶

func (b *BaseApi) UpdateDeviceByFile(c *gin.Context)

@Tags Device @Summary Update device conf by file @Accept json @Param request body dto.UpdateByNameAndFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/update/byconf [post]

func (*BaseApi) UpdateDeviceConf ¶

func (b *BaseApi) UpdateDeviceConf(c *gin.Context)

@Tags Device @Summary Update device @Accept json @Param request body dto.SettingUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/update/conf [post] @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改主机参数 [key] => [value]","formatEN":"update device conf [key] => [value]"}

func (*BaseApi) UpdateDeviceHost ¶

func (b *BaseApi) UpdateDeviceHost(c *gin.Context)

@Tags Device @Summary Update device hosts @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/update/host [post] @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改主机 Host [key] => [value]","formatEN":"update device host [key] => [value]"}

func (*BaseApi) UpdateDevicePasswd ¶

func (b *BaseApi) UpdateDevicePasswd(c *gin.Context)

@Tags Device @Summary Update device passwd @Accept json @Param request body dto.ChangePasswd true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/update/passwd [post]

func (*BaseApi) UpdateDeviceSwap ¶

func (b *BaseApi) UpdateDeviceSwap(c *gin.Context)

@Tags Device @Summary Update device swap @Accept json @Param request body dto.SwapHelper true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/device/update/swap [post] @x-panel-log {"bodyKeys":["operate","path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 主机 swap path","formatEN":"[operate] device swap path"}

func (*BaseApi) UpdateFPMConfig ¶

func (b *BaseApi) UpdateFPMConfig(c *gin.Context)

@Tags Runtime @Summary Update fpm config @Accept json @Param request body request.FPMConfig true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/fpm/config [post]

func (*BaseApi) UpdateFail2BanConf ¶

func (b *BaseApi) UpdateFail2BanConf(c *gin.Context)

@Tags Fail2ban @Summary Update fail2ban conf @Accept json @Param request body dto.Fail2BanUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/update [post] @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 Fail2ban 配置 [key] => [value]","formatEN":"update fail2ban conf [key] => [value]"}

func (*BaseApi) UpdateFail2BanConfByFile ¶

func (b *BaseApi) UpdateFail2BanConfByFile(c *gin.Context)

@Tags Fail2ban @Summary Update fail2ban conf by file @Accept json @Param request body dto.UpdateByFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/fail2ban/update/byconf [post]

func (*BaseApi) UpdateFile ¶

func (b *BaseApi) UpdateFile(c *gin.Context)

@Tags Clam @Summary Update clam file @Accept json @Param request body dto.UpdateByNameAndFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/clam/file/update [post]

func (*BaseApi) UpdateFirewallDescription ¶

func (b *BaseApi) UpdateFirewallDescription(c *gin.Context)

@Tags Firewall @Summary Update rule description @Accept json @Param request body dto.UpdateFirewallDescription true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/update/description [post]

func (*BaseApi) UpdateFtp ¶

func (b *BaseApi) UpdateFtp(c *gin.Context)

@Tags FTP @Summary Update FTP user @Accept json @Param request body dto.FtpUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /toolbox/ftp/update [post] @x-panel-log {"bodyKeys":["user", "path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 FTP 账户 userpath","formatEN":"update FTP userpath"}

func (*BaseApi) UpdateGroup ¶

func (b *BaseApi) UpdateGroup(c *gin.Context)

@Tags System Group @Summary Update group @Accept json @Param request body dto.GroupUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /agent/groups/update [post] @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新组 [name][type]","formatEN":"update group [name][type]"}

func (*BaseApi) UpdateHTTPSConfig ¶

func (b *BaseApi) UpdateHTTPSConfig(c *gin.Context)

@Tags Website HTTPS @Summary Update https conf @Accept json @Param request body request.WebsiteHTTPSOp true "request" @Success 200 {object} response.WebsiteHTTPS @Security ApiKeyAuth @Security Timestamp @Router /websites/:id/https [post] @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteId","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新网站 [domain] https 配置","formatEN":"Update website https [domain] conf"}

func (*BaseApi) UpdateInstalled ¶

func (b *BaseApi) UpdateInstalled(c *gin.Context)

@Tags App @Summary Change app params @Accept json @Param request body request.AppInstalledUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /apps/installed/params/update [post] @x-panel-log {"bodyKeys":["installId"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"应用参数修改 [installId]","formatEN":"Application param update [installId]"}

func (*BaseApi) UpdateIpv6Option ¶

func (b *BaseApi) UpdateIpv6Option(c *gin.Context)

@Tags Container Docker @Summary Update docker daemon.json ipv6 option @Accept json @Param request body dto.LogOption true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/ipv6option/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 ipv6 配置","formatEN":"Updated the ipv6 option"}

func (*BaseApi) UpdateLoadBalance ¶

func (b *BaseApi) UpdateLoadBalance(c *gin.Context)

@Tags Website @Summary Update website upstream @Accept json @Param request body request.WebsiteLBUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/lbs/update [post]

func (*BaseApi) UpdateLoadBalanceFile ¶

func (b *BaseApi) UpdateLoadBalanceFile(c *gin.Context)

@Tags Website @Summary Update website upstream file @Accept json @Param request body request.WebsiteLBUpdateFile true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/lbs/file [post]

func (*BaseApi) UpdateLogOption ¶

func (b *BaseApi) UpdateLogOption(c *gin.Context)

@Tags Container Docker @Summary Update docker daemon.json log option @Accept json @Param request body dto.LogOption true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/logoption/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新日志配置","formatEN":"Updated the log option"}

func (*BaseApi) UpdateMcpBindDomain ¶

func (b *BaseApi) UpdateMcpBindDomain(c *gin.Context)

@Tags McpServer @Summary Update bind Domain for mcp server @Accept json @Param request body request.McpBindDomainUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/domain/update [post]

func (*BaseApi) UpdateMcpServer ¶

func (b *BaseApi) UpdateMcpServer(c *gin.Context)

@Tags McpServer @Summary Update mcp server @Accept json @Param request body request.McpServerUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /mcp/server/update [post]

func (*BaseApi) UpdateMonitorSetting ¶

func (b *BaseApi) UpdateMonitorSetting(c *gin.Context)

@Tags Monitor @Summary Update monitor setting @Param request body dto.MonitorSettingUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/monitor/setting/update [post] @x-panel-log {"bodyKeys":["key", "value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改默认监控网卡 [name]-[value]","formatEN":"update default monitor [name]-[value]"}

func (*BaseApi) UpdateMysqlDescription ¶

func (b *BaseApi) UpdateMysqlDescription(c *gin.Context)

@Tags Database Mysql @Summary Update mysql database description @Accept json @Param request body dto.UpdateDescription true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/description/update [post] @x-panel-log {"bodyKeys":["id","description"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_mysqls","output_column":"name","output_value":"name"}],"formatZH":"mysql 数据库 [name] 描述信息修改 [description]","formatEN":"The description of the mysql database [name] is modified => [description]"}

func (*BaseApi) UpdateMysqlVariables ¶

func (b *BaseApi) UpdateMysqlVariables(c *gin.Context)

@Tags Database Mysql @Summary Update mysql variables @Accept json @Param request body dto.MysqlVariablesUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/variables/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"调整 mysql 数据库性能参数","formatEN":"adjust mysql database performance parameters"}

func (*BaseApi) UpdateNginxConfig ¶

func (b *BaseApi) UpdateNginxConfig(c *gin.Context)

@Tags Website Nginx @Summary Update nginx conf @Accept json @Param request body request.NginxConfigUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/config/update [post] @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteId","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"nginx 配置修改 [domain]","formatEN":"Nginx conf update [domain]"}

func (*BaseApi) UpdateNginxConfigByScope ¶

func (b *BaseApi) UpdateNginxConfigByScope(c *gin.Context)

@Tags OpenResty @Summary Update OpenResty conf @Accept json @Param request body request.NginxConfigUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /openresty/update [post] @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteId","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新 nginx 配置 [domain]","formatEN":"Update nginx conf [domain]"}

func (*BaseApi) UpdateNginxFile ¶

func (b *BaseApi) UpdateNginxFile(c *gin.Context)

@Tags OpenResty @Summary Update OpenResty conf by upload file @Accept json @Param request body request.NginxConfigFileUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /openresty/file [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 nginx 配置","formatEN":"Update nginx conf"}

func (*BaseApi) UpdateNginxModule ¶

func (b *BaseApi) UpdateNginxModule(c *gin.Context)

@Tags OpenResty @Summary Update OpenResty module @Accept json @Param request body request.NginxModuleUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /openresty/module/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 OpenResty 模块","formatEN":"Update OpenResty module"}

func (*BaseApi) UpdatePHPConfig ¶

func (b *BaseApi) UpdatePHPConfig(c *gin.Context)

@Tags Runtime @Summary Update runtime php conf @Accept json @Param request body request.PHPConfigUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/config [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"[domain] PHP 配置修改","formatEN":"[domain] PHP conf update"}

func (*BaseApi) UpdatePHPContainer ¶

func (b *BaseApi) UpdatePHPContainer(c *gin.Context)

@Tags Runtime @Summary Update PHP container config @Accept json @Param request body request.PHPContainerUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/container/update [post]

func (*BaseApi) UpdatePHPExtensions ¶

func (b *BaseApi) UpdatePHPExtensions(c *gin.Context)

@Tags PHP Extensions @Summary Update Extensions @Accept json @Param request body request.PHPExtensionsUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/extensions/update [post]

func (*BaseApi) UpdatePHPFile ¶

func (b *BaseApi) UpdatePHPFile(c *gin.Context)

@Tags Runtime @Summary Update php conf file @Accept json @Param request body request.PHPFileUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/php/update [post] @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteId","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"php 配置修改 [domain]","formatEN":"Nginx conf update [domain]"}

func (*BaseApi) UpdatePathAuthConfig ¶

func (b *BaseApi) UpdatePathAuthConfig(c *gin.Context)

@Tags Website @Summary Get AuthBasic conf @Accept json @Param request body request.NginxPathAuthUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/auths/path/update [post]

func (*BaseApi) UpdatePortRule ¶

func (b *BaseApi) UpdatePortRule(c *gin.Context)

@Tags Firewall @Summary Create group @Accept json @Param request body dto.PortRuleUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/firewall/update/port [post]

func (*BaseApi) UpdatePostgresqlDescription ¶

func (b *BaseApi) UpdatePostgresqlDescription(c *gin.Context)

@Tags Database PostgreSQL @Summary Update postgresql database description @Accept json @Param request body dto.UpdateDescription true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/pg/description [post] @x-panel-log {"bodyKeys":["id","description"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"database_postgresqls","output_column":"name","output_value":"name"}],"formatZH":"postgresql 数据库 [name] 描述信息修改 [description]","formatEN":"The description of the postgresql database [name] is modified => [description]"}

func (*BaseApi) UpdateProxyCache ¶

func (b *BaseApi) UpdateProxyCache(c *gin.Context)

@Tags Website @Summary update website proxy cache config @Accept json @Param request body request.NginxProxyCacheUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/proxy/config [post]

func (*BaseApi) UpdateProxyConfig ¶

func (b *BaseApi) UpdateProxyConfig(c *gin.Context)

@Tags Website @Summary Update proxy conf @Accept json @Param request body request.WebsiteProxyConfig true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/proxies/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改网站 [domain] 反向代理配置 ","formatEN":"Update domain [domain] proxy config"}

func (*BaseApi) UpdateProxyConfigFile ¶

func (b *BaseApi) UpdateProxyConfigFile(c *gin.Context)

@Tags Website @Summary Update proxy file @Accept json @Param request body request.NginxProxyUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/proxy/file [post] @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新反向代理文件 [domain]","formatEN":"Nginx conf proxy file update [domain]"}

func (*BaseApi) UpdateQuickJump ¶

func (b *BaseApi) UpdateQuickJump(c *gin.Context)

@Tags Dashboard @Summary Update quick jump @Accept json @Param request body dto.ChangeQuicks true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /dashboard/quick/change [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"切换快速跳转","formatEN":"change quick jump"}

func (*BaseApi) UpdateRecordDescription ¶

func (b *BaseApi) UpdateRecordDescription(c *gin.Context)

@Tags Backup Account @Summary Update backup record description @Accept json @Param request body dto.UpdateDescription true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backup/record/description/update [post]

func (*BaseApi) UpdateRedirectConfig ¶

func (b *BaseApi) UpdateRedirectConfig(c *gin.Context)

@Tags Website @Summary Update redirect conf @Accept json @Param request body request.NginxRedirectReq true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/redirect/update [post] @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改网站 [domain] 重定向理配置 ","formatEN":"Update domain [domain] redirect config"}

func (*BaseApi) UpdateRedirectConfigFile ¶

func (b *BaseApi) UpdateRedirectConfigFile(c *gin.Context)

@Tags Website @Summary Update redirect file @Accept json @Param request body request.NginxRedirectUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/redirect/file [post] @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新重定向文件 [domain]","formatEN":"Nginx conf redirect file update [domain]"}

func (*BaseApi) UpdateRedisConf ¶

func (b *BaseApi) UpdateRedisConf(c *gin.Context)

@Tags Database Redis @Summary Update redis conf @Accept json @Param request body dto.RedisConfUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/conf/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 redis 数据库配置信息","formatEN":"update the redis database configuration information"}

func (*BaseApi) UpdateRedisPersistenceConf ¶

func (b *BaseApi) UpdateRedisPersistenceConf(c *gin.Context)

@Tags Database Redis @Summary Update redis persistence conf @Accept json @Param request body dto.RedisConfPersistenceUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /databases/redis/persistence/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"redis 数据库持久化配置更新","formatEN":"redis database persistence configuration update"}

func (*BaseApi) UpdateRepo ¶

func (b *BaseApi) UpdateRepo(c *gin.Context)

@Tags Container Image-repo @Summary Update image repo @Accept json @Param request body dto.ImageRepoUpdate true "request" @Produce json @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /containers/repo/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"image_repos","output_column":"name","output_value":"name"}],"formatZH":"更新镜像仓库 [name]","formatEN":"update image repo information [name]"}

func (*BaseApi) UpdateRewriteConfig ¶

func (b *BaseApi) UpdateRewriteConfig(c *gin.Context)

@Tags Website @Summary Update rewrite conf @Accept json @Param request body request.NginxRewriteUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/rewrite/update [post] @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"伪静态配置修改 [domain]","formatEN":"Nginx conf rewrite update [domain]"}

func (*BaseApi) UpdateRuntime ¶

func (b *BaseApi) UpdateRuntime(c *gin.Context)

@Tags Runtime @Summary Update runtime @Accept json @Param request body request.RuntimeUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/update [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新运行环境 [name]","formatEN":"Update runtime [name]"}

func (*BaseApi) UpdateRuntimeRemark ¶

func (b *BaseApi) UpdateRuntimeRemark(c *gin.Context)

@Tags Runtime @Summary Update runtime remark @Accept json @Param request body request.RuntimeRemarkUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /runtimes/remark [post]

func (*BaseApi) UpdateSSH ¶

func (b *BaseApi) UpdateSSH(c *gin.Context)

@Tags SSH @Summary Update host SSH setting @Accept json @Param request body dto.SSHUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/ssh/update [post] @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置 [key] => [value]","formatEN":"update SSH setting [key] => [value]"}

func (*BaseApi) UpdateSSHByfile ¶

func (b *BaseApi) UpdateSSHByfile(c *gin.Context)

@Tags SSH @Summary Update host SSH setting by file @Accept json @Param request body dto.SSHConf true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /hosts/conffile/update [post] @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置文件","formatEN":"update SSH conf"}

func (*BaseApi) UpdateSetting ¶

func (b *BaseApi) UpdateSetting(c *gin.Context)

@Tags System Setting @Summary Update system setting @Accept json @Param request body dto.SettingUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/update [post] @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改系统配置 [key] => [value]","formatEN":"update system setting [key] => [value]"}

func (*BaseApi) UpdateSiteDir ¶

func (b *BaseApi) UpdateSiteDir(c *gin.Context)

@Tags Website @Summary Update Site Dir @Accept json @Param request body request.WebsiteUpdateDir true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/dir/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新网站 [domain] 目录","formatEN":"Update domain [domain] dir"}

func (*BaseApi) UpdateSiteDirPermission ¶

func (b *BaseApi) UpdateSiteDirPermission(c *gin.Context)

@Tags Website @Summary Update Site Dir permission @Accept json @Param request body request.WebsiteUpdateDirPermission true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/dir/permission [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新网站 [domain] 目录权限","formatEN":"Update domain [domain] dir permission"}

func (*BaseApi) UpdateSnapDescription ¶

func (b *BaseApi) UpdateSnapDescription(c *gin.Context)

@Tags System Setting @Summary Update snapshot description @Accept json @Param request body dto.UpdateDescription true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /settings/snapshot/description/update [post] @x-panel-log {"bodyKeys":["id","description"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"快照 [name] 描述信息修改 [description]","formatEN":"The description of the snapshot [name] is modified => [description]"}

func (*BaseApi) UpdateWebDomain ¶

func (b *BaseApi) UpdateWebDomain(c *gin.Context)

@Tags Website Domain @Summary Update website domain @Accept json @Param request body request.WebsiteDomainUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/domains/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_domains","output_column":"domain","output_value":"domain"}],"formatZH":"更新域名 [domain]","formatEN":"Update domain [domain]"}

func (*BaseApi) UpdateWebsite ¶

func (b *BaseApi) UpdateWebsite(c *gin.Context)

@Tags Website @Summary Update website @Accept json @Param request body request.WebsiteUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/update [post] @x-panel-log {"bodyKeys":["primaryDomain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新网站 [primaryDomain]","formatEN":"Update website [primaryDomain]"}

func (*BaseApi) UpdateWebsiteAcmeAccount ¶

func (b *BaseApi) UpdateWebsiteAcmeAccount(c *gin.Context)

@Tags Website Acme @Summary Update website acme account @Accept json @Param request body request.WebsiteAcmeAccountUpdate true "request" @Success 200 {object} response.WebsiteAcmeAccountDTO @Security ApiKeyAuth @Security Timestamp @Router /websites/acme/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_acme_accounts","output_column":"email","output_value":"email"}],"formatZH":"更新 acme [email]","formatEN":"Update acme [email]"}

func (*BaseApi) UpdateWebsiteDnsAccount ¶

func (b *BaseApi) UpdateWebsiteDnsAccount(c *gin.Context)

@Tags Website DNS @Summary Update website dns account @Accept json @Param request body request.WebsiteDnsAccountUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/dns/update [post] @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新网站 dns [name]","formatEN":"Update website dns [name]"}

func (*BaseApi) UpdateWebsiteNginxConfig ¶

func (b *BaseApi) UpdateWebsiteNginxConfig(c *gin.Context)

@Tags Website Nginx @Summary Update website nginx conf @Accept json @Param request body request.WebsiteNginxUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/nginx/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"[domain] Nginx 配置修改","formatEN":"[domain] Nginx conf update"}

func (*BaseApi) UpdateWebsiteSSL ¶

func (b *BaseApi) UpdateWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Update ssl @Accept json @Param request body request.WebsiteSSLUpdate true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/update [post] @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"website_ssls","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新证书设置 [domain]","formatEN":"Update ssl config [domain]"}

func (*BaseApi) UploadChunkFiles ¶

func (b *BaseApi) UploadChunkFiles(c *gin.Context)

@Tags File @Summary ChunkUpload file @Param file formData file true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/chunkupload [post]

func (*BaseApi) UploadFiles ¶

func (b *BaseApi) UploadFiles(c *gin.Context)

@Tags File @Summary Upload file @Param file formData file true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /files/upload [post] @x-panel-log {"bodyKeys":["path", "file"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传文件 path/[file]","formatEN":"Upload file path/[file]"}

func (*BaseApi) UploadForRecover ¶

func (b *BaseApi) UploadForRecover(c *gin.Context)

@Tags Backup Account @Summary Upload file for recover @Accept json @Param request body dto.UploadForRecover true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /backups/upload [post] @x-panel-log {"bodyKeys":["filePath"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传备份文件 [filePath]","formatEN":"upload backup file [filePath]"}

func (*BaseApi) UploadWebsiteSSL ¶

func (b *BaseApi) UploadWebsiteSSL(c *gin.Context)

@Tags Website SSL @Summary Upload ssl @Accept json @Param request body request.WebsiteSSLUpload true "request" @Success 200 @Security ApiKeyAuth @Security Timestamp @Router /websites/ssl/upload [post] @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传 ssl [type]","formatEN":"Upload ssl [type]"}

func (*BaseApi) WgetFile ¶

func (b *BaseApi) WgetFile(c *gin.Context)

@Tags File @Summary Wget file @Accept json @Param request body request.FileWget true "request" @Success 200 {object} response.FileWgetRes @Security ApiKeyAuth @Security Timestamp @Router /files/wget [post] @x-panel-log {"bodyKeys":["url","path","name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"下载 url => path/[name]","formatEN":"Download url => path/[name]"}

func (*BaseApi) WgetProcess ¶

func (b *BaseApi) WgetProcess(c *gin.Context)

func (*BaseApi) WsSSH ¶

func (b *BaseApi) WsSSH(c *gin.Context)