style: 优化中国地图显示 (#4681)

Refs https://github.com/1Panel-dev/1Panel/issues/4771

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ["https://afdian.net/a/1Panel"]

.github/workflows/build-test.yml

@@ -13,11 +13,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Setup Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
-          node-version: '20.2'
+          node-version: '18.14'
       - name: Build Web
         id: build_frontend
         run: |
@@ -25,10 +25,10 @@ jobs:
         env:
           NODE_OPTIONS: --max-old-space-size=8192
       - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
-          go-version: '1.22'
+          go-version: '1.20.x'
       - name: Build Server
-        uses: goreleaser/goreleaser-action@v6
+        uses: goreleaser/goreleaser-action@v4
         with:
           args: release --snapshot --clean

.github/workflows/release-drafter.yml

@@ -11,9 +11,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Setup Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
           node-version: '20.2'
       - name: Build Web
@@ -22,15 +22,15 @@ jobs:
         env:
           NODE_OPTIONS: --max-old-space-size=8192
       - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
-          go-version: '1.22'
+          go-version: '1.21.x'
       - name: Build Release
-        uses: goreleaser/goreleaser-action@v6
+        uses: goreleaser/goreleaser-action@v4
         with:
           distribution: goreleaser
           version: latest
-          args: release --skip=publish --clean
+          args: release --skip-publish --clean
       - name: Upload Assets
         uses: softprops/action-gh-release@v1
         if: startsWith(github.ref, 'refs/tags/')

.gitignore

@@ -29,7 +29,6 @@ build/1panel
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-
 # Dependency directories
 /pkg/
 backend/__debug_bin
@@ -41,7 +40,9 @@ frontend/auto-imports.d.ts
 frontend/components.d.ts
 frontend/src/xpack
 backend/xpack
-*_xpack.go
+backend/router/entry_xpack.go
+backend/server/init_xpack.go
+backend/utils/xpack/xpack_xpack.go
 
 .history/
 dist/

.goreleaser.yaml

@@ -44,7 +44,7 @@ archives:
 checksum:
   name_template: 'checksums.txt'
 snapshot:
-  version_template: "{{ incpatch .Version }}-next"
+  name_template: "{{ incpatch .Version }}-next"
 release:
   draft: true
   mode: append

CONTRIBUTING.md

@@ -1,16 +1,11 @@
 # Contributing
 
-As a contributor, you should agree that:
-
-- The producer can adjust the open-source agreement to be more strict or relaxed as deemed necessary.
-- Your contributed code may be used for commercial purposes, including but not limited to its cloud business operations.
-
 ## Create pull request
 PR are always welcome, even if they only contain small fixes like typos or a few lines of code. If there will be a significant effort, please document it as an issue and get a discussion going before starting to work on it.
 
-Please submit a PR broken down into small changes bit by bit. A PR consisting of a lot of features and code changes may be hard to review. It is recommended to submit PRs in an incremental fashion.
+Please submit a PR broken down into small changes bit by bit. A PR consisting of a lot features and code changes may be hard to review. It is recommended to submit PRs in an incremental fashion.
 
-This [development guideline](https://1panel.cn/docs/dev_manual/dev_manual/) contains information about repository structure, how to set up development environment, how to run it, and more.
+This [development guideline](https://1panel.cn/docs/dev_manual/dev_manual/) contains information about repository structure, how to setup development environment, how to run it, and more.
 
 Note: If you split your pull request to small changes, please make sure any of the changes goes to master will not break anything. Otherwise, it can not be merged until this feature complete.
 

README.md

@@ -1,34 +1,38 @@
 <p align="center"><a href="https://1panel.cn"><img src="http://1panel.oss-cn-hangzhou.aliyuncs.com/img/1panel-logo.png" alt="1Panel" width="300" /></a></p>
-<p align="center"><b>Web-based linux server management control panel</b></p>
 <p align="center"><b>现代化、开源的 Linux 服务器运维管理面板</b></p>
-<p align="center">
-  <a href="https://trendshift.io/repositories/2462" target="_blank"><img src="https://trendshift.io/api/badge/repositories/2462" alt="1Panel-dev%2F1Panel | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-  <a href="https://hellogithub.com/repository/71791baf930149ac9b84e1acf186573f" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=71791baf930149ac9b84e1acf186573f&claim_uid=p8vB3kP5CMrthiL&theme=dark&theme=neutral" alt="Featured｜HelloGitHub" style="width: 250px; height: 55px;" width="250" height="55" /></a>
-</p>
 <p align="center">
   <a href="https://www.gnu.org/licenses/gpl-3.0.html"><img src="https://shields.io/github/license/1Panel-dev/1Panel?color=%231890FF" alt="License: GPL v3"></a>
   <a href="https://app.codacy.com/gh/1Panel-dev/1Panel?utm_source=github.com&utm_medium=referral&utm_content=1Panel-dev/1Panel&utm_campaign=Badge_Grade_Dashboard"><img src="https://app.codacy.com/project/badge/Grade/da67574fd82b473992781d1386b937ef" alt="Codacy"></a>
   <a href="https://github.com/1Panel-dev/1Panel/releases"><img src="https://img.shields.io/github/v/release/1Panel-dev/1Panel" alt="GitHub release"></a>
-  <a href="https://github.com/1Panel-dev/1Panel"><img src="https://img.shields.io/github/stars/1Panel-dev/1Panel?color=%231890FF&style=flat-square" alt="GitHub Stars"></a>
-  <a href="https://gitee.com/fit2cloud-feizhiyun/1Panel"><img src="https://gitee.com/fit2cloud-feizhiyun/1Panel/badge/star.svg?theme=gvp" alt="Gitee Stars"></a><br>
-  [<a href="docs/README_EN.md">English</a>] | [<a href="docs/README_TW.md">中文(繁體)</a>] | [<a href="docs/README_JP.md">日本語</a>]
+  <a href="https://github.com/1Panel-dev/1Panel"><img src="https://img.shields.io/github/stars/1Panel-dev/1Panel?color=%231890FF&style=flat-square" alt="Stars"></a>
+  <a href="https://app.fossa.com/projects/git%2Bgithub.com%2F1Panel-dev%2F1Panel?ref=badge_shield"><img src="https://app.fossa.com/api/projects/git%2Bgithub.com%2F1Panel-dev%2F1Panel.svg?type=shield" alt="FOSSA Status"></a><br>
+  [<a href="docs/README_TW.md">中文(繁體)</a>] | [<a href="docs/README_EN.md">English</a>] | [<a href="docs/README_JP.md">日本語</a>]
 </p>
 
-[![Watch the video](https://resource.fit2cloud.com/1panel/img/overview_video.png)](https://www.bilibili.com/video/BV1Mt421n7LZ/)
-
 ------------------------------
-## 什么是 1Panel？
 
 1Panel 是新一代的 Linux 服务器运维管理面板。
 
-- **高效管理**：用户可以通过 Web 界面轻松管理 Linux 服务器，如主机监控、文件管理、数据库管理、容器管理等；
+- **高效管理**：用户可以通过 Web 图形界面轻松管理 Linux 服务器，实现主机监控、文件管理、数据库管理、容器管理等功能；
 - **快速建站**：深度集成开源建站软件 WordPress 和 [Halo](https://github.com/halo-dev/halo/)，域名绑定、SSL 证书配置等操作一键搞定；
 - **应用商店**：精选上架各类高质量的开源工具和应用软件，协助用户轻松安装并升级；
-- **安全可靠**：基于容器管理并部署应用，实现最小的漏洞暴露面，同时提供病毒防护、防火墙和日志审计等功能；
+- **安全可靠**：基于容器管理并部署应用，实现最小的漏洞暴露面，同时提供防火墙和日志审计等功能；
 - **一键备份**：支持一键备份和恢复，用户可以将数据备份到各类云端存储介质，永不丢失。
 
+1Panel 三分钟速览：https://www.bilibili.com/video/BV1Mt421n7LZ/
+
+## UI 展示
+
+![UI展示](https://resource.fit2cloud.com/1panel/img/overview.png)
+
 ## 快速开始
 
+**在线体验**
+
+- 环境地址：<https://demo.1panel.cn/>
+- 用户名：demo
+- 密码：1panel
+
 **一键安装**
 
 执行如下命令一键安装 1Panel:
@@ -37,22 +41,33 @@
 curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && sudo bash quick_start.sh
 ```
 
-如果是用于离线环境，推荐使用 [安装包方式](https://1panel.cn/docs/installation/package_installation/) 进行安装部署。
-
 **学习资料**
 
 - [在线文档](https://1panel.cn/docs/)
+- [教学视频](https://space.bilibili.com/510493147/channel/collectiondetail?sid=1199760)
 - [社区论坛](https://bbs.fit2cloud.com/c/1p/7)
 - [如何加入微信交流群?](https://bbs.fit2cloud.com/t/topic/2147)
 
-## 飞致云的其他明星项目
+## 安全说明
 
-- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - 基于 LLM 大语言模型的开源知识库问答系统
+如果您在使用过程中发现任何安全问题，请通过以下方式直接联系我们：
+
+- 邮箱：wanghe@fit2cloud.com
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=1Panel-dev/1Panel&type=Date)](https://star-history.com/#1Panel-dev/1Panel&Date)
+
+## 我们的其他明星项目
 - [JumpServer](https://github.com/jumpserver/jumpserver/) - 广受欢迎的开源堡垒机
-- [Halo](https://github.com/halo-dev/halo/) - 强大易用的开源建站工具
 - [DataEase](https://github.com/dataease/dataease/) - 人人可用的开源数据可视化分析工具
-- [MeterSphere](https://github.com/metersphere/metersphere/) - 开源持续测试工具
-- [KubePi](https://github.com/1Panel-dev/KubePi/) - 现代化、开源的 K8s 面板
+- [MeterSphere](https://github.com/metersphere/metersphere/) - 一站式开源自动化测试平台
+- [Halo](https://github.com/halo-dev/halo/) - 强大易用的开源建站工具
+
+
+## FOSSA Status
+
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2F1Panel-dev%2F1Panel.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2F1Panel-dev%2F1Panel?ref=badge_large)
 
 ## License
 

backend/app/api/v1/app.go

@@ -155,7 +155,7 @@ func (b *BaseApi) GetIgnoredApp(c *gin.Context) {
 // @Success 200 {object} model.AppInstall
 // @Security ApiKeyAuth
 // @Router /apps/install [post]
-// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"安装应用 [name]","formatEN":"Install app [name]"}
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[{"input_column":"name","input_value":"name","isList":false,"db":"app_installs","output_column":"app_id","output_value":"appId"},{"info":"appId","isList":false,"db":"apps","output_column":"key","output_value":"appKey"}],"formatZH":"安装应用 [appKey]-[name]","formatEN":"Install app [appKey]-[name]"}
 func (b *BaseApi) InstallApp(c *gin.Context) {
 	var req request.AppInstallCreate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

backend/app/api/v1/app_install.go

@@ -205,13 +205,14 @@ func (b *BaseApi) GetServices(c *gin.Context) {
 // @Param appInstallId path integer true "request"
 // @Success 200 {array} dto.AppVersion
 // @Security ApiKeyAuth
-// @Router /apps/installed/update/versions [post]
+// @Router /apps/installed/:appInstallId/versions [get]
 func (b *BaseApi) GetUpdateVersions(c *gin.Context) {
-	var req request.AppUpdateVersion
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+	appInstallId, err := helper.GetIntParamByKey(c, "appInstallId")
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
 		return
 	}
-	versions, err := appInstallService.GetUpdateVersions(req)
+	versions, err := appInstallService.GetUpdateVersions(appInstallId)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return

backend/app/api/v1/auth.go

@@ -8,7 +8,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
-	"github.com/1Panel-dev/1Panel/backend/middleware"
 	"github.com/1Panel-dev/1Panel/backend/utils/captcha"
 	"github.com/1Panel-dev/1Panel/backend/utils/qqwry"
 	"github.com/gin-gonic/gin"
@@ -119,19 +118,7 @@ func (b *BaseApi) CheckIsSafety(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	if status == "disable" && len(code) != 0 {
-		helper.ErrorWithDetail(c, constant.CodeErrNotFound, constant.ErrTypeInternalServer, err)
-		return
-	}
-	if status == "unpass" {
-		if middleware.LoadErrCode("err-entrance") != 200 {
-			helper.ErrResponse(c, middleware.LoadErrCode("err-entrance"))
-			return
-		}
-		helper.ErrorWithDetail(c, constant.CodeErrEntrance, constant.ErrTypeInternalServer, nil)
-		return
-	}
-	helper.SuccessWithOutData(c)
+	helper.SuccessWithData(c, status)
 }
 
 func (b *BaseApi) GetResponsePage(c *gin.Context) {

backend/app/api/v1/backup.go

@@ -118,11 +118,11 @@ func (b *BaseApi) LoadOneDriveInfo(c *gin.Context) {
 // @Summary Delete backup account
 // @Description 删除备份账号
 // @Accept json
-// @Param request body dto.OperateByID true "request"
+// @Param request body dto.BatchDeleteReq true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Router /settings/backup/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]"}
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":true,"db":"backup_accounts","output_column":"type","output_value":"types"}],"formatZH":"删除备份账号 [types]","formatEN":"delete backup account [types]"}
 func (b *BaseApi) DeleteBackup(c *gin.Context) {
 	var req dto.OperateByID
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -323,7 +323,7 @@ func (b *BaseApi) Backup(c *gin.Context) {
 
 	switch req.Type {
 	case "app":
-		if _, err := backupService.AppBackup(req); err != nil {
+		if err := backupService.AppBackup(req); err != nil {
 			helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 			return
 		}
@@ -343,7 +343,7 @@ func (b *BaseApi) Backup(c *gin.Context) {
 			return
 		}
 	case "redis":
-		if err := backupService.RedisBackup(req); err != nil {
+		if err := backupService.RedisBackup(); err != nil {
 			helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 			return
 		}

backend/app/api/v1/clam.go

@@ -1,296 +0,0 @@
-package v1
-
-import (
-	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/gin-gonic/gin"
-)
-
-// @Tags Clam
-// @Summary Create clam
-// @Description 创建扫描规则
-// @Accept json
-// @Param request body dto.ClamCreate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/clam [post]
-// @x-panel-log {"bodyKeys":["name","path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建扫描规则 [name][path]","formatEN":"create clam [name][path]"}
-func (b *BaseApi) CreateClam(c *gin.Context) {
-	var req dto.ClamCreate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.Create(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Update clam
-// @Description 修改扫描规则
-// @Accept json
-// @Param request body dto.ClamUpdate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/update [post]
-// @x-panel-log {"bodyKeys":["name","path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改扫描规则 [name][path]","formatEN":"update clam [name][path]"}
-func (b *BaseApi) UpdateClam(c *gin.Context) {
-	var req dto.ClamUpdate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.Update(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Update clam status
-// @Description 修改扫描规则状态
-// @Accept json
-// @Param request body dto.ClamUpdateStatus true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) UpdateClamStatus(c *gin.Context) {
-	var req dto.ClamUpdateStatus
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.UpdateStatus(req.ID, req.Status); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Page clam
-// @Description 获取扫描规则列表分页
-// @Accept json
-// @Param request body dto.SearchClamWithPage true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/search [post]
-func (b *BaseApi) SearchClam(c *gin.Context) {
-	var req dto.SearchClamWithPage
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	total, list, err := clamService.SearchWithPage(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, dto.PageResult{
-		Items: list,
-		Total: total,
-	})
-}
-
-// @Tags Clam
-// @Summary Load clam base info
-// @Description 获取 Clam 基础信息
-// @Accept json
-// @Success 200 {object} dto.ClamBaseInfo
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/base [get]
-func (b *BaseApi) LoadClamBaseInfo(c *gin.Context) {
-	info, err := clamService.LoadBaseInfo()
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, info)
-}
-
-// @Tags Clam
-// @Summary Operate Clam
-// @Description 修改 Clam 状态
-// @Accept json
-// @Param request body dto.Operate true "request"
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/operate [post]
-// @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] Clam","formatEN":"[operation] FTP"}
-func (b *BaseApi) OperateClam(c *gin.Context) {
-	var req dto.Operate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.Operate(req.Operation); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Clean clam record
-// @Description 清空扫描报告
-// @Accept json
-// @Param request body dto.OperateByID true "request"
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) CleanClamRecord(c *gin.Context) {
-	var req dto.OperateByID
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	if err := clamService.CleanRecord(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Page clam record
-// @Description 获取扫描结果列表分页
-// @Accept json
-// @Param request body dto.ClamLogSearch true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/record/search [post]
-func (b *BaseApi) SearchClamRecord(c *gin.Context) {
-	var req dto.ClamLogSearch
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	total, list, err := clamService.LoadRecords(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, dto.PageResult{
-		Items: list,
-		Total: total,
-	})
-}
-
-// @Tags Clam
-// @Summary Load clam record detail
-// @Description 获取扫描结果详情
-// @Accept json
-// @Param request body dto.ClamLogReq true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/record/log [post]
-func (b *BaseApi) LoadClamRecordLog(c *gin.Context) {
-	var req dto.ClamLogReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	content, err := clamService.LoadRecordLog(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, content)
-}
-
-// @Tags Clam
-// @Summary Load clam file
-// @Description 获取扫描文件
-// @Accept json
-// @Param request body dto.ClamFileReq true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/file/search [post]
-func (b *BaseApi) SearchClamFile(c *gin.Context) {
-	var req dto.ClamFileReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	content, err := clamService.LoadFile(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, content)
-}
-
-// @Tags Clam
-// @Summary Update clam file
-// @Description 更新病毒扫描配置文件
-// @Accept json
-// @Param request body dto.UpdateByNameAndFile true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/clam/file/update [post]
-func (b *BaseApi) UpdateFile(c *gin.Context) {
-	var req dto.UpdateByNameAndFile
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	if err := clamService.UpdateFile(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}
-
-// @Tags Clam
-// @Summary Delete clam
-// @Description 删除扫描规则
-// @Accept json
-// @Param request body dto.ClamDelete true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) DeleteClam(c *gin.Context) {
-	var req dto.ClamDelete
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.Delete(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags Clam
-// @Summary Handle clam scan
-// @Description 执行病毒扫描
-// @Accept json
-// @Param request body dto.OperateByID true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) HandleClamScan(c *gin.Context) {
-	var req dto.OperateByID
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := clamService.HandleOnce(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}

backend/app/api/v1/command.go

@@ -29,28 +29,6 @@ func (b *BaseApi) CreateCommand(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-// @Tags Redis Command
-// @Summary Save redis command
-// @Description 保存 Redis 快速命令
-// @Accept json
-// @Param request body dto.RedisCommand true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /hosts/command/redis [post]
-// @x-panel-log {"bodyKeys":["name","command"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"保存 redis 快捷命令 [name][command]","formatEN":"save quick command for redis [name][command]"}
-func (b *BaseApi) SaveRedisCommand(c *gin.Context) {
-	var req dto.RedisCommand
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := commandService.SaveRedisCommand(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
 // @Tags Command
 // @Summary Page commands
 // @Description 获取快速命令列表分页
@@ -77,32 +55,6 @@ func (b *BaseApi) SearchCommand(c *gin.Context) {
 	})
 }
 
-// @Tags Redis Command
-// @Summary Page redis commands
-// @Description 获取 redis 快速命令列表分页
-// @Accept json
-// @Param request body dto.SearchWithPage true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /hosts/command/redis/search [post]
-func (b *BaseApi) SearchRedisCommand(c *gin.Context) {
-	var req dto.SearchWithPage
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	total, list, err := commandService.SearchRedisCommandWithPage(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, dto.PageResult{
-		Items: list,
-		Total: total,
-	})
-}
-
 // @Tags Command
 // @Summary Tree commands
 // @Description 获取快速命令树
@@ -120,22 +72,6 @@ func (b *BaseApi) SearchCommandTree(c *gin.Context) {
 	helper.SuccessWithData(c, list)
 }
 
-// @Tags Redis Command
-// @Summary List redis commands
-// @Description 获取 redis 快速命令列表
-// @Success 200 {Array} dto.RedisCommand
-// @Security ApiKeyAuth
-// @Router /hosts/command/redis [get]
-func (b *BaseApi) ListRedisCommand(c *gin.Context) {
-	list, err := commandService.ListRedisCommand()
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, list)
-}
-
 // @Tags Command
 // @Summary List commands
 // @Description 获取快速命令列表
@@ -174,28 +110,6 @@ func (b *BaseApi) DeleteCommand(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-// @Tags Redis Command
-// @Summary Delete redis command
-// @Description 删除 redis 快速命令
-// @Accept json
-// @Param request body dto.BatchDeleteReq true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /hosts/command/redis/del [post]
-// @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"redis_commands","output_column":"name","output_value":"names"}],"formatZH":"删除 redis 快捷命令 [names]","formatEN":"delete quick command of redis [names]"}
-func (b *BaseApi) DeleteRedisCommand(c *gin.Context) {
-	var req dto.BatchDeleteReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := commandService.DeleteRedisCommand(req.Ids); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
 // @Tags Command
 // @Summary Update command
 // @Description 更新快速命令

backend/app/api/v1/container.go

@@ -7,7 +7,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
-	"strconv"
 )
 
 // @Tags Container
@@ -347,26 +346,6 @@ func (b *BaseApi) ContainerRename(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-// @Tags Container
-// @Summary Commit Container
-// @Description 容器提交生成新镜像
-// @Accept json
-// @Param request body dto.ContainerCommit true "request"
-// @Success 200
-// @Router /containers/commit [post]
-func (b *BaseApi) ContainerCommit(c *gin.Context) {
-	var req dto.ContainerCommit
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := containerService.ContainerCommit(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
 // @Tags Container
 // @Summary Operate Container
 // @Description 容器操作
@@ -461,19 +440,6 @@ func (b *BaseApi) ContainerLogs(c *gin.Context) {
 	}
 }
 
-// @Description 下载容器日志
-// @Router /containers/download/log [post]
-func (b *BaseApi) DownloadContainerLogs(c *gin.Context) {
-	var req dto.ContainerLog
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	err := containerService.DownloadContainerLogs(req.ContainerType, req.Container, req.Since, strconv.Itoa(int(req.Tail)), c)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-	}
-}
-
 // @Tags Container Network
 // @Summary Page networks
 // @Description 获取容器网络列表分页

backend/app/api/v1/cronjob.go

@@ -36,12 +36,12 @@ func (b *BaseApi) CreateCronjob(c *gin.Context) {
 // @Summary Page cronjobs
 // @Description 获取计划任务分页
 // @Accept json
-// @Param request body dto.PageCronjob true "request"
+// @Param request body dto.SearchWithPage true "request"
 // @Success 200 {object} dto.PageResult
 // @Security ApiKeyAuth
 // @Router /cronjobs/search [post]
 func (b *BaseApi) SearchCronjob(c *gin.Context) {
-	var req dto.PageCronjob
+	var req dto.SearchWithPage
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
@@ -72,7 +72,7 @@ func (b *BaseApi) SearchJobRecords(c *gin.Context) {
 		return
 	}
 
-	loc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
+	loc, _ := time.LoadLocation(common.LoadTimeZone())
 	req.StartTime = req.StartTime.In(loc)
 	req.EndTime = req.EndTime.In(loc)
 

backend/app/api/v1/dashboard.go

@@ -2,7 +2,6 @@ package v1
 
 import (
 	"errors"
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
 
 	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
 	"github.com/1Panel-dev/1Panel/backend/constant"
@@ -56,17 +55,25 @@ func (b *BaseApi) LoadDashboardBaseInfo(c *gin.Context) {
 // @Tags Dashboard
 // @Summary Load dashboard current info
 // @Description 获取首页实时数据
-// @Accept json、
-// @Param request body dto.DashboardReq true "request"
+// @Accept json
+// @Param ioOption path string true "request"
+// @Param netOption path string true "request"
 // @Success 200 {object} dto.DashboardCurrent
 // @Security ApiKeyAuth
-// @Router /dashboard/current [post]
+// @Router /dashboard/current/:ioOption/:netOption [get]
 func (b *BaseApi) LoadDashboardCurrentInfo(c *gin.Context) {
-	var req dto.DashboardReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+	ioOption, ok := c.Params.Get("ioOption")
+	if !ok {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, errors.New("error ioOption in path"))
 		return
 	}
-	data := dashboardService.LoadCurrentInfo(req)
+	netOption, ok := c.Params.Get("netOption")
+	if !ok {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, errors.New("error netOption in path"))
+		return
+	}
+
+	data := dashboardService.LoadCurrentInfo(ioOption, netOption)
 	helper.SuccessWithData(c, data)
 }
 

backend/app/api/v1/database_redis.go

@@ -12,17 +12,11 @@ import (
 // @Tags Database Redis
 // @Summary Load redis status info
 // @Description 获取 redis 状态信息
-// @Accept json
-// @Param request body dto.OperationWithName true "request"
 // @Success 200 {object} dto.RedisStatus
 // @Security ApiKeyAuth
-// @Router /databases/redis/status [post]
+// @Router /databases/redis/status [get]
 func (b *BaseApi) LoadRedisStatus(c *gin.Context) {
-	var req dto.OperationWithName
-	if err := helper.CheckBind(&req, c); err != nil {
-		return
-	}
-	data, err := redisService.LoadStatus(req)
+	data, err := redisService.LoadStatus()
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -34,17 +28,11 @@ func (b *BaseApi) LoadRedisStatus(c *gin.Context) {
 // @Tags Database Redis
 // @Summary Load redis conf
 // @Description 获取 redis 配置信息
-// @Accept json
-// @Param request body dto.OperationWithName true "request"
 // @Success 200 {object} dto.RedisConf
 // @Security ApiKeyAuth
-// @Router /databases/redis/conf [post]
+// @Router /databases/redis/conf [get]
 func (b *BaseApi) LoadRedisConf(c *gin.Context) {
-	var req dto.OperationWithName
-	if err := helper.CheckBind(&req, c); err != nil {
-		return
-	}
-	data, err := redisService.LoadConf(req)
+	data, err := redisService.LoadConf()
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -56,17 +44,11 @@ func (b *BaseApi) LoadRedisConf(c *gin.Context) {
 // @Tags Database Redis
 // @Summary Load redis persistence conf
 // @Description 获取 redis 持久化配置
-// @Accept json
-// @Param request body dto.OperationWithName true "request"
 // @Success 200 {object} dto.RedisPersistence
 // @Security ApiKeyAuth
-// @Router /databases/redis/persistence/conf [post]
+// @Router /databases/redis/persistence/conf [get]
 func (b *BaseApi) LoadPersistenceConf(c *gin.Context) {
-	var req dto.OperationWithName
-	if err := helper.CheckBind(&req, c); err != nil {
-		return
-	}
-	data, err := redisService.LoadPersistenceConf(req)
+	data, err := redisService.LoadPersistenceConf()
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -75,25 +57,6 @@ func (b *BaseApi) LoadPersistenceConf(c *gin.Context) {
 	helper.SuccessWithData(c, data)
 }
 
-func (b *BaseApi) CheckHasCli(c *gin.Context) {
-	helper.SuccessWithData(c, redisService.CheckHasCli())
-}
-
-// @Tags Database Redis
-// @Summary Install redis-cli
-// @Description 安装 redis cli
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /databases/redis/install/cli [post]
-func (b *BaseApi) InstallCli(c *gin.Context) {
-	if err := redisService.InstallCli(); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithOutData(c)
-}
-
 // @Tags Database Redis
 // @Summary Update redis conf
 // @Description 更新 redis 配置信息
@@ -168,3 +131,29 @@ func (b *BaseApi) UpdateRedisPersistenceConf(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, nil)
 }
+
+// @Tags Database Redis
+// @Summary Page redis backups
+// @Description 获取 redis 备份记录分页
+// @Accept json
+// @Param request body dto.PageInfo true "request"
+// @Success 200 {object} dto.PageResult
+// @Security ApiKeyAuth
+// @Router /databases/redis/backup/search [post]
+func (b *BaseApi) RedisBackupList(c *gin.Context) {
+	var req dto.PageInfo
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	total, list, err := redisService.SearchBackupListWithPage(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Items: list,
+		Total: total,
+	})
+}

backend/app/api/v1/entry.go

@@ -37,8 +37,6 @@ var (
 
 	deviceService   = service.NewIDeviceService()
 	fail2banService = service.NewIFail2BanService()
-	ftpService      = service.NewIFtpService()
-	clamService     = service.NewIClamService()
 
 	settingService = service.NewISettingService()
 	backupService  = service.NewIBackupService()

backend/app/api/v1/file.go

@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"syscall"
 
 	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -319,7 +318,7 @@ func (b *BaseApi) UploadFiles(c *gin.Context) {
 	}
 	dir := path.Dir(paths[0])
 
-	_, err = os.Stat(dir)
+	info, err := os.Stat(dir)
 	if err != nil && os.IsNotExist(err) {
 		mode, err := files.GetParentMode(dir)
 		if err != nil {
@@ -331,18 +330,14 @@ func (b *BaseApi) UploadFiles(c *gin.Context) {
 			return
 		}
 	}
-	info, err := os.Stat(dir)
+	info, err = os.Stat(dir)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
 	mode := info.Mode()
+
 	fileOp := files.NewFileOp()
-	stat, ok := info.Sys().(*syscall.Stat_t)
-	uid, gid := -1, -1
-	if ok {
-		uid, gid = int(stat.Uid), int(stat.Gid)
-	}
 
 	success := 0
 	failures := make(buserr.MultiErr)
@@ -356,7 +351,6 @@ func (b *BaseApi) UploadFiles(c *gin.Context) {
 				global.LOG.Error(e)
 				continue
 			}
-			_ = os.Chown(dstDir, uid, gid)
 		}
 		tmpFilename := dstFilename + ".tmp"
 		if err := c.SaveUploadedFile(file, tmpFilename); err != nil {
@@ -384,9 +378,6 @@ func (b *BaseApi) UploadFiles(c *gin.Context) {
 		} else {
 			_ = os.Chmod(dstFilename, mode)
 		}
-		if uid != -1 && gid != -1 {
-			_ = os.Chown(dstFilename, uid, gid)
-		}
 		success++
 	}
 	if success == 0 {
@@ -495,7 +486,6 @@ func (b *BaseApi) Download(c *gin.Context) {
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 	}
-	defer file.Close()
 	info, _ := file.Stat()
 	c.Header("Content-Length", strconv.FormatInt(info.Size(), 10))
 	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(info.Name()))
@@ -601,46 +591,24 @@ func (b *BaseApi) Size(c *gin.Context) {
 	helper.SuccessWithData(c, res)
 }
 
-func mergeChunks(fileName string, fileDir string, dstDir string, chunkCount int, overwrite bool) error {
-	defer func() {
-		_ = os.RemoveAll(fileDir)
-	}()
-
+func mergeChunks(fileName string, fileDir string, dstDir string, chunkCount int) error {
 	op := files.NewFileOp()
 	dstDir = strings.TrimSpace(dstDir)
 	mode, _ := files.GetParentMode(dstDir)
 	if mode == 0 {
 		mode = 0755
 	}
-	uid, gid := -1, -1
-	if info, err := os.Stat(dstDir); err != nil {
-		if os.IsNotExist(err) {
-			if err = op.CreateDir(dstDir, mode); err != nil {
-				return err
-			}
+	if _, err := os.Stat(dstDir); err != nil && os.IsNotExist(err) {
+		if err = op.CreateDir(dstDir, mode); err != nil {
+			return err
 		}
-	} else {
-		stat, ok := info.Sys().(*syscall.Stat_t)
-		if ok {
-			uid, gid = int(stat.Uid), int(stat.Gid)
-		}
-	}
-	dstFileName := filepath.Join(dstDir, fileName)
-	dstInfo, statErr := os.Stat(dstFileName)
-	if statErr == nil {
-		mode = dstInfo.Mode()
-	} else {
-		mode = 0644
 	}
 
-	if overwrite {
-		_ = os.Remove(dstFileName)
-	}
-	targetFile, err := os.OpenFile(dstFileName, os.O_RDWR|os.O_CREATE, mode)
+	targetFile, err := os.OpenFile(filepath.Join(dstDir, fileName), os.O_RDWR|os.O_CREATE, mode)
 	if err != nil {
 		return err
 	}
-	defer targetFile.Close()
+
 	for i := 0; i < chunkCount; i++ {
 		chunkPath := filepath.Join(fileDir, fmt.Sprintf("%s.%d", fileName, i))
 		chunkData, err := os.ReadFile(chunkPath)
@@ -651,13 +619,9 @@ func mergeChunks(fileName string, fileDir string, dstDir string, chunkCount int,
 		if err != nil {
 			return err
 		}
-		_ = os.Remove(chunkPath)
-	}
-	if uid != -1 && gid != -1 {
-		_ = os.Chown(dstFileName, uid, gid)
 	}
 
-	return nil
+	return files.NewFileOp().DeleteDir(fileDir)
 }
 
 // @Tags File
@@ -679,7 +643,6 @@ func (b *BaseApi) UploadChunkFiles(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	defer uploadFile.Close()
 	chunkIndex, err := strconv.Atoi(c.PostForm("chunkIndex"))
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
@@ -739,11 +702,7 @@ func (b *BaseApi) UploadChunkFiles(c *gin.Context) {
 	}
 
 	if chunkIndex+1 == chunkCount {
-		overwrite := true
-		if ow := c.PostForm("overwrite"); ow != "" {
-			overwrite, _ = strconv.ParseBool(ow)
-		}
-		err = mergeChunks(filename, fileDir, c.PostForm("path"), chunkCount, overwrite)
+		err = mergeChunks(filename, fileDir, c.PostForm("path"), chunkCount)
 		if err != nil {
 			helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, buserr.WithMap(constant.ErrFileUpload, map[string]interface{}{"name": filename, "detail": err.Error()}, err))
 			return

backend/app/api/v1/firewall.go

@@ -94,29 +94,6 @@ func (b *BaseApi) OperatePortRule(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-// OperateForwardRule
-// @Tags Firewall
-// @Summary Create group
-// @Description 更新防火墙端口转发规则
-// @Accept json
-// @Param request body dto.ForwardRuleOperate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /hosts/firewall/forward [post]
-// @x-panel-log {"bodyKeys":["source_port"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新端口转发规则 [source_port]","formatEN":"update port forward rules [source_port]"}
-func (b *BaseApi) OperateForwardRule(c *gin.Context) {
-	var req dto.ForwardRuleOperate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := firewallService.OperateForwardRule(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
 // @Tags Firewall
 // @Summary Create group
 // @Description 创建防火墙 IP 规则

backend/app/api/v1/ftp.go

@@ -1,199 +0,0 @@
-package v1
-
-import (
-	"encoding/base64"
-
-	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/gin-gonic/gin"
-)
-
-// @Tags FTP
-// @Summary Load FTP base info
-// @Description 获取 FTP 基础信息
-// @Success 200 {object} dto.FtpBaseInfo
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/base [get]
-func (b *BaseApi) LoadFtpBaseInfo(c *gin.Context) {
-	data, err := ftpService.LoadBaseInfo()
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, data)
-}
-
-// @Tags FTP
-// @Summary Load FTP operation log
-// @Description 获取 FTP 操作日志
-// @Accept json
-// @Param request body dto.FtpLogSearch true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/log/search [post]
-func (b *BaseApi) LoadFtpLogInfo(c *gin.Context) {
-	var req dto.FtpLogSearch
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	total, list, err := ftpService.LoadLog(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, dto.PageResult{
-		Items: list,
-		Total: total,
-	})
-}
-
-// @Tags FTP
-// @Summary Operate FTP
-// @Description 修改 FTP 状态
-// @Accept json
-// @Param request body dto.Operate true "request"
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/operate [post]
-// @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] FTP","formatEN":"[operation] FTP"}
-func (b *BaseApi) OperateFtp(c *gin.Context) {
-	var req dto.Operate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := ftpService.Operate(req.Operation); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, nil)
-}
-
-// @Tags FTP
-// @Summary Page FTP user
-// @Description 获取 FTP 账户列表分页
-// @Accept json
-// @Param request body dto.SearchWithPage true "request"
-// @Success 200 {object} dto.PageResult
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/search [post]
-func (b *BaseApi) SearchFtp(c *gin.Context) {
-	var req dto.SearchWithPage
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	total, list, err := ftpService.SearchWithPage(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, dto.PageResult{
-		Items: list,
-		Total: total,
-	})
-}
-
-// @Tags FTP
-// @Summary Create FTP user
-// @Description 创建 FTP 账户
-// @Accept json
-// @Param request body dto.FtpCreate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp [post]
-// @x-panel-log {"bodyKeys":["user", "path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 FTP 账户 [user][path]","formatEN":"create FTP [user][path]"}
-func (b *BaseApi) CreateFtp(c *gin.Context) {
-	var req dto.FtpCreate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if len(req.Password) != 0 {
-		pass, err := base64.StdEncoding.DecodeString(req.Password)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.Password = string(pass)
-	}
-	if _, err := ftpService.Create(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}
-
-// @Tags FTP
-// @Summary Delete FTP user
-// @Description 删除 FTP 账户
-// @Accept json
-// @Param request body dto.BatchDeleteReq true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) DeleteFtp(c *gin.Context) {
-	var req dto.BatchDeleteReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if err := ftpService.Delete(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}
-
-// @Tags FTP
-// @Summary Sync FTP user
-// @Description 同步 FTP 账户
-// @Accept json
-// @Param request body dto.BatchDeleteReq true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/sync [post]
-// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 FTP 账户","formatEN":"sync FTP users"}
-func (b *BaseApi) SyncFtp(c *gin.Context) {
-	if err := ftpService.Sync(); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}
-
-// @Tags FTP
-// @Summary Update FTP user
-// @Description 修改 FTP 账户
-// @Accept json
-// @Param request body dto.FtpUpdate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /toolbox/ftp/update [post]
-// @x-panel-log {"bodyKeys":["user", "path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 FTP 账户 [user][path]","formatEN":"update FTP [user][path]"}
-func (b *BaseApi) UpdateFtp(c *gin.Context) {
-	var req dto.FtpUpdate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if len(req.Password) != 0 {
-		pass, err := base64.StdEncoding.DecodeString(req.Password)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.Password = string(pass)
-	}
-	if err := ftpService.Update(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}

backend/app/api/v1/helper/helper.go

@@ -133,8 +133,3 @@ func CheckBind(req interface{}, c *gin.Context) error {
 	}
 	return nil
 }
-
-func ErrResponse(ctx *gin.Context, code int) {
-	ctx.JSON(code, nil)
-	ctx.Abort()
-}

backend/app/api/v1/monitor.go

@@ -28,7 +28,7 @@ func (b *BaseApi) LoadMonitor(c *gin.Context) {
 		return
 	}
 
-	loc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
+	loc, _ := time.LoadLocation(common.LoadTimeZone())
 	req.StartTime = req.StartTime.In(loc)
 	req.EndTime = req.EndTime.In(loc)
 

backend/app/api/v1/runtime.go

@@ -76,20 +76,6 @@ func (b *BaseApi) DeleteRuntime(c *gin.Context) {
 	helper.SuccessWithOutData(c)
 }
 
-func (b *BaseApi) DeleteRuntimeCheck(c *gin.Context) {
-	runTimeId, err := helper.GetIntParamByKey(c, "runTimeId")
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
-		return
-	}
-	checkData, err := runtimeService.DeleteCheck(runTimeId)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, checkData)
-}
-
 // @Tags Runtime
 // @Summary Update runtime
 // @Description 更新运行环境

backend/app/api/v1/setting.go

@@ -1,7 +1,6 @@
 package v1
 
 import (
-	"encoding/base64"
 	"errors"
 	"os"
 	"path"
@@ -61,37 +60,6 @@ func (b *BaseApi) UpdateSetting(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-// @Tags System Setting
-// @Summary Update proxy setting
-// @Description 服务器代理配置
-// @Accept json
-// @Param request body dto.ProxyUpdate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /settings/proxy/update [post]
-// @x-panel-log {"bodyKeys":["proxyUrl","proxyPort"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"服务器代理配置 [proxyPort]:[proxyPort]","formatEN":"set proxy [proxyPort]:[proxyPort]."}
-func (b *BaseApi) UpdateProxy(c *gin.Context) {
-	var req dto.ProxyUpdate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	if len(req.ProxyPasswd) != 0 && len(req.ProxyType) != 0 {
-		pass, err := base64.StdEncoding.DecodeString(req.ProxyPasswd)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.ProxyPasswd = string(pass)
-	}
-
-	if err := settingService.UpdateProxy(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, nil)
-}
-
 // @Tags System Setting
 // @Summary Update system setting
 // @Description 隐藏高级功能菜单

backend/app/api/v1/snapshot.go

@@ -99,12 +99,12 @@ func (b *BaseApi) UpdateSnapDescription(c *gin.Context) {
 // @Summary Page system snapshot
 // @Description 获取系统快照列表分页
 // @Accept json
-// @Param request body dto.PageSnapshot true "request"
+// @Param request body dto.SearchWithPage true "request"
 // @Success 200 {object} dto.PageResult
 // @Security ApiKeyAuth
 // @Router /settings/snapshot/search [post]
 func (b *BaseApi) SearchSnapshot(c *gin.Context) {
-	var req dto.PageSnapshot
+	var req dto.SearchWithPage
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
@@ -168,13 +168,13 @@ func (b *BaseApi) RollbackSnapshot(c *gin.Context) {
 // @Summary Delete system backup
 // @Description 删除系统快照
 // @Accept json
-// @Param request body dto.SnapshotBatchDelete true "request"
+// @Param request body dto.BatchDeleteReq true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @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 (b *BaseApi) DeleteSnapshot(c *gin.Context) {
-	var req dto.SnapshotBatchDelete
+	var req dto.BatchDeleteReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}

backend/app/api/v1/terminal.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/1Panel-dev/1Panel/backend/utils/copier"
@@ -79,13 +78,6 @@ func (b *BaseApi) RedisWsSsh(c *gin.Context) {
 		global.LOG.Errorf("gin context http handler failed, err: %v", err)
 		return
 	}
-	defer wsConn.Close()
-
-	if global.CONF.System.IsDemo {
-		if wshandleError(wsConn, errors.New("   demo server, prohibit this operation!")) {
-			return
-		}
-	}
 
 	cols, err := strconv.Atoi(c.DefaultQuery("cols", "80"))
 	if wshandleError(wsConn, errors.WithMessage(err, "invalid param cols in request")) {
@@ -95,38 +87,22 @@ func (b *BaseApi) RedisWsSsh(c *gin.Context) {
 	if wshandleError(wsConn, errors.WithMessage(err, "invalid param rows in request")) {
 		return
 	}
-	name := c.Query("name")
-	from := c.Query("from")
-	commands := []string{"redis-cli"}
-	database, err := databaseService.Get(name)
-	if wshandleError(wsConn, errors.WithMessage(err, "no such database in db")) {
+	redisConf, err := redisService.LoadConf()
+	if wshandleError(wsConn, errors.WithMessage(err, "load redis container failed")) {
 		return
 	}
-	if from == "local" {
-		redisInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: name, Type: "redis"})
-		if wshandleError(wsConn, errors.WithMessage(err, "no such database in db")) {
-			return
-		}
-		name = redisInfo.ContainerName
-		if len(database.Password) != 0 {
-			commands = []string{"redis-cli", "-a", database.Password, "--no-auth-warning"}
-		}
-	} else {
-		itemPort := fmt.Sprintf("%v", database.Port)
-		commands = []string{"redis-cli", "-h", database.Address, "-p", itemPort}
-		if len(database.Password) != 0 {
-			commands = []string{"redis-cli", "-h", database.Address, "-p", itemPort, "-a", database.Password, "--no-auth-warning"}
-		}
-		name = "1Panel-redis-cli-tools"
-	}
 
-	pidMap := loadMapFromDockerTop(name)
-	itemCmds := append([]string{"exec", "-it", name}, commands...)
-	slave, err := terminal.NewCommand(itemCmds)
+	defer wsConn.Close()
+	commands := "redis-cli"
+	if len(redisConf.Requirepass) != 0 {
+		commands = fmt.Sprintf("redis-cli -a %s --no-auth-warning", redisConf.Requirepass)
+	}
+	pidMap := loadMapFromDockerTop(redisConf.ContainerName)
+	slave, err := terminal.NewCommand(fmt.Sprintf("docker exec -it %s %s", redisConf.ContainerName, commands))
 	if wshandleError(wsConn, err) {
 		return
 	}
-	defer killBash(name, strings.Join(commands, " "), pidMap)
+	defer killBash(redisConf.ContainerName, pidMap)
 	defer slave.Close()
 
 	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, false)
@@ -154,12 +130,6 @@ func (b *BaseApi) ContainerWsSsh(c *gin.Context) {
 	}
 	defer wsConn.Close()
 
-	if global.CONF.System.IsDemo {
-		if wshandleError(wsConn, errors.New("   demo server, prohibit this operation!")) {
-			return
-		}
-	}
-
 	containerID := c.Query("containerid")
 	command := c.Query("command")
 	user := c.Query("user")
@@ -191,16 +161,16 @@ func (b *BaseApi) ContainerWsSsh(c *gin.Context) {
 		return
 	}
 
-	commands := []string{"exec", "-it", containerID, command}
+	commands := fmt.Sprintf("docker exec -it %s %s", containerID, command)
 	if len(user) != 0 {
-		commands = []string{"exec", "-it", "-u", user, containerID, command}
+		commands = fmt.Sprintf("docker exec -it -u %s %s %s", user, containerID, command)
 	}
 	pidMap := loadMapFromDockerTop(containerID)
 	slave, err := terminal.NewCommand(commands)
 	if wshandleError(wsConn, err) {
 		return
 	}
-	defer killBash(containerID, command, pidMap)
+	defer killBash(containerID, pidMap)
 	defer slave.Close()
 
 	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, true)
@@ -251,26 +221,26 @@ func loadMapFromDockerTop(containerID string) map[string]string {
 	lines := strings.Split(stdout, "\n")
 	for _, line := range lines {
 		parts := strings.Fields(line)
-		if len(parts) < 2 {
+		if len(parts) == 0 {
 			continue
 		}
-		pidMap[parts[0]] = strings.Join(parts[1:], " ")
+		pidMap[parts[0]] = strings.Join(parts, " ")
 	}
 	return pidMap
 }
 
-func killBash(containerID, comm string, pidMap map[string]string) {
+func killBash(containerID string, pidMap map[string]string) {
 	sudo := cmd.SudoHandleCmd()
 	newPidMap := loadMapFromDockerTop(containerID)
-	for pid, command := range newPidMap {
+	for pid, newCmd := range newPidMap {
 		isOld := false
-		for pid2 := range pidMap {
-			if pid == pid2 {
+		for pid2, oldCmd := range pidMap {
+			if pid == pid2 && oldCmd == newCmd {
 				isOld = true
 				break
 			}
 		}
-		if !isOld && command == comm {
+		if !isOld {
 			_, _ = cmd.Execf("%s kill -9 %s", sudo, pid)
 		}
 	}

backend/app/api/v1/website.go

@@ -1,8 +1,6 @@
 package v1
 
 import (
-	"encoding/base64"
-
 	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
@@ -78,14 +76,6 @@ func (b *BaseApi) CreateWebsite(c *gin.Context) {
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-	if len(req.FtpPassword) != 0 {
-		pass, err := base64.StdEncoding.DecodeString(req.FtpPassword)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.FtpPassword = string(pass)
-	}
 	err := websiteService.CreateWebsite(req)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
@@ -778,45 +768,3 @@ func (b *BaseApi) GetDirConfig(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, res)
 }
-
-// @Tags Website
-// @Summary Get default html
-// @Description 获取默认 html
-// @Accept json
-// @Success 200 {object} response.FileInfo
-// @Security ApiKeyAuth
-// @Router /websites/default/html/:type [get]
-func (b *BaseApi) GetDefaultHtml(c *gin.Context) {
-	resourceType, err := helper.GetStrParamByKey(c, "type")
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
-		return
-	}
-	fileInfo, err := websiteService.GetDefaultHtml(resourceType)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithData(c, fileInfo)
-}
-
-// @Tags Website
-// @Summary Update default html
-// @Description 更新默认 html
-// @Accept json
-// @Param request body request.WebsiteHtmlUpdate true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Router /websites/default/html/update [post]
-// @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新默认 html","formatEN":"Update default html"}
-func (b *BaseApi) UpdateDefaultHtml(c *gin.Context) {
-	var req request.WebsiteHtmlUpdate
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	if err := websiteService.UpdateDefaultHtml(req); err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	helper.SuccessWithOutData(c)
-}

backend/app/api/v1/website_ca.go

@@ -6,9 +6,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/gin-gonic/gin"
-	"net/http"
-	"net/url"
-	"strconv"
 )
 
 // @Tags Website CA
@@ -145,33 +142,3 @@ func (b *BaseApi) RenewWebsiteCA(c *gin.Context) {
 	}
 	helper.SuccessWithOutData(c)
 }
-
-// @Tags Website CA
-// @Summary Download CA file
-// @Description 下载 CA 证书文件
-// @Accept json
-// @Param request body request.WebsiteResourceReq true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @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 (b *BaseApi) DownloadCAFile(c *gin.Context) {
-	var req request.WebsiteResourceReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	file, err := websiteCAService.DownloadFile(req.ID)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	defer file.Close()
-	info, err := file.Stat()
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-	c.Header("Content-Length", strconv.FormatInt(info.Size(), 10))
-	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(info.Name()))
-	http.ServeContent(c.Writer, c.Request, info.Name(), info.ModTime(), file)
-}

backend/app/api/v1/website_ssl.go

@@ -236,7 +236,6 @@ func (b *BaseApi) DownloadWebsiteSSL(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	defer file.Close()
 	info, err := file.Stat()
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)

backend/app/dto/app.go

@@ -37,9 +37,8 @@ type AppOssConfig struct {
 }
 
 type AppVersion struct {
-	Version       string `json:"version"`
-	DetailId      uint   `json:"detailId"`
-	DockerCompose string `json:"dockerCompose"`
+	Version  string `json:"version"`
+	DetailId uint   `json:"detailId"`
 }
 
 type AppList struct {

backend/app/dto/backup.go

@@ -35,8 +35,6 @@ type CommonBackup struct {
 	Type       string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql"`
 	Name       string `json:"name"`
 	DetailName string `json:"detailName"`
-	Secret     string `json:"secret"`
-	FileName   string `json:"fileName"`
 }
 type CommonRecover struct {
 	Source     string `json:"source" validate:"required,oneof=OSS S3 SFTP MINIO LOCAL COS KODO OneDrive WebDAV"`
@@ -44,7 +42,6 @@ type CommonRecover struct {
 	Name       string `json:"name"`
 	DetailName string `json:"detailName"`
 	File       string `json:"file"`
-	Secret     string `json:"secret"`
 }
 
 type RecordSearch struct {

backend/app/dto/clam.go

@@ -1,96 +0,0 @@
-package dto
-
-import (
-	"time"
-)
-
-type SearchClamWithPage struct {
-	PageInfo
-	Info    string `json:"info"`
-	OrderBy string `json:"orderBy" validate:"required,oneof=name status created_at"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
-}
-
-type ClamBaseInfo struct {
-	Version  string `json:"version"`
-	IsActive bool   `json:"isActive"`
-	IsExist  bool   `json:"isExist"`
-
-	FreshVersion  string `json:"freshVersion"`
-	FreshIsActive bool   `json:"freshIsActive"`
-	FreshIsExist  bool   `json:"freshIsExist"`
-}
-
-type ClamInfo struct {
-	ID        uint      `json:"id"`
-	CreatedAt time.Time `json:"createdAt"`
-
-	Name             string `json:"name"`
-	Status           string `json:"status"`
-	Path             string `json:"path"`
-	InfectedStrategy string `json:"infectedStrategy"`
-	InfectedDir      string `json:"infectedDir"`
-	LastHandleDate   string `json:"lastHandleDate"`
-	Spec             string `json:"spec"`
-	Description      string `json:"description"`
-}
-
-type ClamLogSearch struct {
-	PageInfo
-
-	ClamID    uint      `json:"clamID"`
-	StartTime time.Time `json:"startTime"`
-	EndTime   time.Time `json:"endTime"`
-}
-
-type ClamLogReq struct {
-	Tail       string `json:"tail"`
-	ClamName   string `json:"clamName"`
-	RecordName string `json:"recordName"`
-}
-
-type ClamFileReq struct {
-	Tail string `json:"tail"`
-	Name string `json:"name" validate:"required"`
-}
-
-type ClamLog struct {
-	Name          string `json:"name"`
-	ScanDate      string `json:"scanDate"`
-	ScanTime      string `json:"scanTime"`
-	InfectedFiles string `json:"infectedFiles"`
-	TotalError    string `json:"totalError"`
-	Status        string `json:"status"`
-}
-
-type ClamCreate struct {
-	Name             string `json:"name"`
-	Status           string `json:"status"`
-	Path             string `json:"path"`
-	InfectedStrategy string `json:"infectedStrategy"`
-	InfectedDir      string `json:"infectedDir"`
-	Spec             string `json:"spec"`
-	Description      string `json:"description"`
-}
-
-type ClamUpdate struct {
-	ID uint `json:"id"`
-
-	Name             string `json:"name"`
-	Path             string `json:"path"`
-	InfectedStrategy string `json:"infectedStrategy"`
-	InfectedDir      string `json:"infectedDir"`
-	Spec             string `json:"spec"`
-	Description      string `json:"description"`
-}
-
-type ClamUpdateStatus struct {
-	ID     uint   `json:"id"`
-	Status string `json:"status"`
-}
-
-type ClamDelete struct {
-	RemoveRecord   bool   `json:"removeRecord"`
-	RemoveInfected bool   `json:"removeInfected"`
-	Ids            []uint `json:"ids" validate:"required"`
-}

backend/app/dto/command.go

@@ -1,9 +1,9 @@
 package dto
 
 type SearchCommandWithPage struct {
-	PageInfo
-	OrderBy string `json:"orderBy" validate:"required,oneof=name command created_at"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
+	SearchWithPage
+	OrderBy string `json:"orderBy"`
+	Order   string `json:"order"`
 	GroupID uint   `json:"groupID"`
 	Info    string `json:"info"`
 	Name    string `json:"name"`
@@ -30,9 +30,3 @@ type CommandTree struct {
 	Label    string        `json:"label"`
 	Children []CommandInfo `json:"children"`
 }
-
-type RedisCommand struct {
-	ID      uint   `json:"id"`
-	Name    string `json:"name"`
-	Command string `json:"command"`
-}

backend/app/dto/common_req.go

@@ -2,7 +2,9 @@ package dto
 
 type SearchWithPage struct {
 	PageInfo
-	Info string `json:"info"`
+	Info    string `json:"info"`
+	OrderBy string `json:"orderBy"`
+	Order   string `json:"order"`
 }
 
 type PageInfo struct {

backend/app/dto/container.go

@@ -1,15 +1,13 @@
 package dto
 
-import (
-	"time"
-)
+import "time"
 
 type PageContainer struct {
 	PageInfo
 	Name            string `json:"name"`
 	State           string `json:"state" validate:"required,oneof=all created running paused restarting removing exited dead"`
-	OrderBy         string `json:"orderBy" validate:"required,oneof=name state created_at"`
-	Order           string `json:"order" validate:"required,oneof=null ascending descending"`
+	OrderBy         string `json:"orderBy"`
+	Order           string `json:"order"`
 	Filters         string `json:"filters"`
 	ExcludeAppStore bool   `json:"excludeAppStore"`
 }
@@ -116,7 +114,7 @@ type PortHelper struct {
 
 type ContainerOperation struct {
 	Names     []string `json:"names" validate:"required"`
-	Operation string   `json:"operation" validate:"required,oneof=up start stop restart kill pause unpause remove"`
+	Operation string   `json:"operation" validate:"required,oneof=start stop restart kill pause unpause remove"`
 }
 
 type ContainerRename struct {
@@ -124,17 +122,8 @@ type ContainerRename struct {
 	NewName string `json:"newName" validate:"required"`
 }
 
-type ContainerCommit struct {
-	ContainerId   string `json:"containerID" validate:"required"`
-	ContainerName string `json:"containerName"`
-	NewImageName  string `json:"newImageName"`
-	Comment       string `json:"comment"`
-	Author        string `json:"author"`
-	Pause         bool   `json:"pause"`
-}
-
 type ContainerPrune struct {
-	PruneType  string `json:"pruneType" validate:"required,oneof=container image volume network buildcache"`
+	PruneType  string `json:"pruneType" validate:"required,oneof=container image volume network"`
 	WithTagAll bool   `json:"withTagAll"`
 }
 
@@ -208,29 +197,20 @@ type ComposeContainer struct {
 	State       string `json:"state"`
 }
 type ComposeCreate struct {
-	Name     string   `json:"name"`
-	From     string   `json:"from" validate:"required,oneof=edit path template"`
-	File     string   `json:"file"`
-	Path     string   `json:"path"`
-	Template uint     `json:"template"`
-	Env      []string `json:"env"`
+	Name     string `json:"name"`
+	From     string `json:"from" validate:"required,oneof=edit path template"`
+	File     string `json:"file"`
+	Path     string `json:"path"`
+	Template uint   `json:"template"`
 }
 type ComposeOperation struct {
 	Name      string `json:"name" validate:"required"`
 	Path      string `json:"path" validate:"required"`
-	Operation string `json:"operation" validate:"required,oneof=up start stop down"`
+	Operation string `json:"operation" validate:"required,oneof=start stop down"`
 	WithFile  bool   `json:"withFile"`
 }
 type ComposeUpdate struct {
-	Name    string   `json:"name" validate:"required"`
-	Path    string   `json:"path" validate:"required"`
-	Content string   `json:"content" validate:"required"`
-	Env     []string `json:"env"`
-}
-
-type ContainerLog struct {
-	Container     string `json:"container" validate:"required"`
-	Since         string `json:"since"`
-	Tail          uint   `json:"tail"`
-	ContainerType string `json:"containerType"`
+	Name    string `json:"name" validate:"required"`
+	Path    string `json:"path" validate:"required"`
+	Content string `json:"content" validate:"required"`
 }

backend/app/dto/cronjob.go

@@ -1,15 +1,6 @@
 package dto
 
-import (
-	"time"
-)
-
-type PageCronjob struct {
-	PageInfo
-	Info    string `json:"info"`
-	OrderBy string `json:"orderBy" validate:"required,oneof=name status created_at"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
-}
+import "time"
 
 type CronjobCreate struct {
 	Name string `json:"name" validate:"required"`
@@ -30,7 +21,6 @@ type CronjobCreate struct {
 	BackupAccounts  string `json:"backupAccounts"`
 	DefaultDownload string `json:"defaultDownload"`
 	RetainCopies    int    `json:"retainCopies" validate:"number,min=1"`
-	Secret          string `json:"secret"`
 }
 
 type CronjobUpdate struct {
@@ -52,7 +42,6 @@ type CronjobUpdate struct {
 	BackupAccounts  string `json:"backupAccounts"`
 	DefaultDownload string `json:"defaultDownload"`
 	RetainCopies    int    `json:"retainCopies" validate:"number,min=1"`
-	Secret          string `json:"secret"`
 }
 
 type CronjobUpdateStatus struct {
@@ -98,7 +87,6 @@ type CronjobInfo struct {
 
 	LastRecordTime string `json:"lastRecordTime"`
 	Status         string `json:"status"`
-	Secret         string `json:"secret"`
 }
 
 type SearchRecord struct {
@@ -110,12 +98,12 @@ type SearchRecord struct {
 }
 
 type Record struct {
-	ID         uint   `json:"id"`
-	StartTime  string `json:"startTime"`
-	Records    string `json:"records"`
-	Status     string `json:"status"`
-	Message    string `json:"message"`
-	TargetPath string `json:"targetPath"`
-	Interval   int    `json:"interval"`
-	File       string `json:"file"`
+	ID         uint      `json:"id"`
+	StartTime  time.Time `json:"startTime"`
+	Records    string    `json:"records"`
+	Status     string    `json:"status"`
+	Message    string    `json:"message"`
+	TargetPath string    `json:"targetPath"`
+	Interval   int       `json:"interval"`
+	File       string    `json:"file"`
 }

backend/app/dto/dashboard.go

@@ -16,11 +16,10 @@ type DashboardBase struct {
 	KernelArch           string `json:"kernelArch"`
 	KernelVersion        string `json:"kernelVersion"`
 	VirtualizationSystem string `json:"virtualizationSystem"`
-	IpV4Addr             string `json:"ipv4Addr"`
-	SystemProxy          string `json:"SystemProxy"`
-	CPUCores             int    `json:"cpuCores"`
-	CPULogicalCores      int    `json:"cpuLogicalCores"`
-	CPUModelName         string `json:"cpuModelName"`
+
+	CPUCores        int    `json:"cpuCores"`
+	CPULogicalCores int    `json:"cpuLogicalCores"`
+	CPUModelName    string `json:"cpuModelName"`
 
 	CurrentInfo DashboardCurrent `json:"currentInfo"`
 }
@@ -31,14 +30,6 @@ type OsInfo struct {
 	PlatformFamily string `json:"platformFamily"`
 	KernelArch     string `json:"kernelArch"`
 	KernelVersion  string `json:"kernelVersion"`
-
-	DiskSize int64 `json:"diskSize"`
-}
-
-type DashboardReq struct {
-	Scope     string `json:"scope"`
-	IoOption  string `json:"ioOption"`
-	NetOption string `json:"netOption"`
 }
 
 type DashboardCurrent struct {
@@ -79,7 +70,6 @@ type DashboardCurrent struct {
 	NetBytesRecv uint64 `json:"netBytesRecv"`
 
 	GPUData []GPUInfo `json:"gpuData"`
-	XPUData []XPUInfo `json:"xpuData"`
 
 	ShotTime time.Time `json:"shotTime"`
 }
@@ -113,13 +103,3 @@ type GPUInfo struct {
 	MemTotal         string `json:"memTotal"`
 	FanSpeed         string `json:"fanSpeed"`
 }
-
-type XPUInfo struct {
-	DeviceID    int    `json:"deviceID"`
-	DeviceName  string `json:"deviceName"`
-	Memory      string `json:"memory"`
-	Temperature string `json:"temperature"`
-	MemoryUsed  string `json:"memoryUsed"`
-	Power       string `json:"power"`
-	MemoryUtil  string `json:"memoryUtil"`
-}

backend/app/dto/database.go

@@ -27,8 +27,8 @@ type MysqlDBSearch struct {
 	PageInfo
 	Info     string `json:"info"`
 	Database string `json:"database" validate:"required"`
-	OrderBy  string `json:"orderBy" validate:"required,oneof=name created_at"`
-	Order    string `json:"order" validate:"required,oneof=null ascending descending"`
+	OrderBy  string `json:"orderBy"`
+	Order    string `json:"order"`
 }
 
 type MysqlDBInfo struct {
@@ -131,7 +131,7 @@ type MysqlStatus struct {
 }
 
 type MysqlVariables struct {
-	BinlogCacheSize      string `json:"binlog_cache_size"`
+	BinlogCacheSize       string `json:"binlog_cache_size"`
 	InnodbBufferPoolSize string `json:"innodb_buffer_pool_size"`
 	InnodbLogBufferSize  string `json:"innodb_log_buffer_size"`
 	JoinBufferSize       string `json:"join_buffer_size"`
@@ -139,7 +139,7 @@ type MysqlVariables struct {
 	MaxConnections       string `json:"max_connections"`
 	MaxHeapTableSize     string `json:"max_heap_table_size"`
 	QueryCacheSize       string `json:"query_cache_size"`
-	QueryCacheType       string `json:"query_cache_type"`
+	QueryCache_type      string `json:"query_cache_type"`
 	ReadBufferSize       string `json:"read_buffer_size"`
 	ReadRndBufferSize    string `json:"read_rnd_buffer_size"`
 	SortBufferSize       string `json:"sort_buffer_size"`
@@ -165,26 +165,26 @@ type MysqlVariablesUpdateHelper struct {
 
 // redis
 type ChangeRedisPass struct {
-	Database string `json:"database" validate:"required"`
-	Value    string `json:"value"`
+	Value string `json:"value" validate:"required"`
 }
 
 type RedisConfUpdate struct {
-	Database   string `json:"database" validate:"required"`
 	Timeout    string `json:"timeout"`
 	Maxclients string `json:"maxclients"`
 	Maxmemory  string `json:"maxmemory"`
 }
 type RedisConfPersistenceUpdate struct {
-	Database    string `json:"database" validate:"required"`
 	Type        string `json:"type" validate:"required,oneof=aof rbd"`
 	Appendonly  string `json:"appendonly"`
 	Appendfsync string `json:"appendfsync"`
 	Save        string `json:"save"`
 }
+type RedisConfUpdateByFile struct {
+	File       string `json:"file" validate:"required"`
+	RestartNow bool   `json:"restartNow"`
+}
 
 type RedisConf struct {
-	Database      string `json:"database" validate:"required"`
 	Name          string `json:"name"`
 	Port          int64  `json:"port"`
 	ContainerName string `json:"containerName"`
@@ -195,20 +195,18 @@ type RedisConf struct {
 }
 
 type RedisPersistence struct {
-	Database    string `json:"database" validate:"required"`
 	Appendonly  string `json:"appendonly"`
 	Appendfsync string `json:"appendfsync"`
 	Save        string `json:"save"`
 }
 
 type RedisStatus struct {
-	Database                 string `json:"database" validate:"required"`
 	TcpPort                  string `json:"tcp_port"`
 	UptimeInDays             string `json:"uptime_in_days"`
 	ConnectedClients         string `json:"connected_clients"`
 	UsedMemory               string `json:"used_memory"`
-	UsedMemoryRss            string `json:"used_memory_rss"`
-	UsedMemoryPeak           string `json:"used_memory_peak"`
+	UsedMemory_rss           string `json:"used_memory_rss"`
+	UsedMemory_peak          string `json:"used_memory_peak"`
 	MemFragmentationRatio    string `json:"mem_fragmentation_ratio"`
 	TotalConnectionsReceived string `json:"total_connections_received"`
 	TotalCommandsProcessed   string `json:"total_commands_processed"`
@@ -219,14 +217,12 @@ type RedisStatus struct {
 }
 
 type DatabaseFileRecords struct {
-	Database  string `json:"database" validate:"required"`
 	FileName  string `json:"fileName"`
 	FileDir   string `json:"fileDir"`
 	CreatedAt string `json:"createdAt"`
 	Size      int    `json:"size"`
 }
 type RedisBackupRecover struct {
-	Database string `json:"database" validate:"required"`
 	FileName string `json:"fileName"`
 	FileDir  string `json:"fileDir"`
 }
@@ -236,8 +232,8 @@ type DatabaseSearch struct {
 	PageInfo
 	Info    string `json:"info"`
 	Type    string `json:"type"`
-	OrderBy string `json:"orderBy" validate:"required,oneof=name created_at"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
+	OrderBy string `json:"orderBy"`
+	Order   string `json:"order"`
 }
 
 type DatabaseInfo struct {
@@ -285,7 +281,7 @@ type DatabaseCreate struct {
 	Address  string `json:"address"`
 	Port     uint   `json:"port"`
 	Username string `json:"username" validate:"required"`
-	Password string `json:"password"`
+	Password string `json:"password" validate:"required"`
 
 	SSL        bool   `json:"ssl"`
 	RootCert   string `json:"rootCert"`
@@ -303,7 +299,7 @@ type DatabaseUpdate struct {
 	Address  string `json:"address"`
 	Port     uint   `json:"port"`
 	Username string `json:"username" validate:"required"`
-	Password string `json:"password"`
+	Password string `json:"password" validate:"required"`
 
 	SSL        bool   `json:"ssl"`
 	RootCert   string `json:"rootCert"`

backend/app/dto/database_postgresql.go

@@ -6,8 +6,8 @@ type PostgresqlDBSearch struct {
 	PageInfo
 	Info     string `json:"info"`
 	Database string `json:"database" validate:"required"`
-	OrderBy  string `json:"orderBy" validate:"required,oneof=name created_at"`
-	Order    string `json:"order" validate:"required,oneof=null ascending descending"`
+	OrderBy  string `json:"orderBy"`
+	Order    string `json:"order"`
 }
 
 type PostgresqlDBInfo struct {

backend/app/dto/firewall.go

@@ -29,17 +29,6 @@ type PortRuleOperate struct {
 	Description string `json:"description"`
 }
 
-type ForwardRuleOperate struct {
-	Rules []struct {
-		Operation  string `json:"operation" validate:"required,oneof=add remove"`
-		Num        string `json:"num"`
-		Protocol   string `json:"protocol" validate:"required,oneof=tcp udp tcp/udp"`
-		Port       string `json:"port" validate:"required"`
-		TargetIP   string `json:"targetIP"`
-		TargetPort string `json:"targetPort" validate:"required"`
-	} `json:"rules"`
-}
-
 type UpdateFirewallDescription struct {
 	Type     string `json:"type"`
 	Address  string `json:"address"`

backend/app/dto/ftp.go

@@ -1,43 +0,0 @@
-package dto
-
-import (
-	"time"
-)
-
-type FtpInfo struct {
-	ID        uint      `json:"id"`
-	CreatedAt time.Time `json:"createdAt"`
-
-	User        string `json:"user"`
-	Password    string `json:"password"`
-	Path        string `json:"path"`
-	Status      string `json:"status"`
-	Description string `json:"description"`
-}
-
-type FtpBaseInfo struct {
-	IsActive bool `json:"isActive"`
-	IsExist  bool `json:"isExist"`
-}
-
-type FtpLogSearch struct {
-	PageInfo
-	User      string `json:"user"`
-	Operation string `json:"operation"`
-}
-
-type FtpCreate struct {
-	User        string `json:"user" validate:"required"`
-	Password    string `json:"password" validate:"required"`
-	Path        string `json:"path" validate:"required"`
-	Description string `json:"description"`
-}
-
-type FtpUpdate struct {
-	ID uint `json:"id"`
-
-	Password    string `json:"password" validate:"required"`
-	Path        string `json:"path" validate:"required"`
-	Status      string `json:"status"`
-	Description string `json:"description"`
-}

backend/app/dto/request/app.go

@@ -43,7 +43,6 @@ type AppInstalledSearch struct {
 	Update bool     `json:"update"`
 	Unused bool     `json:"unused"`
 	All    bool     `json:"all"`
-	Sync   bool     `json:"sync"`
 }
 
 type AppInstalledInfo struct {
@@ -61,24 +60,15 @@ type AppBackupDelete struct {
 }
 
 type AppInstalledOperate struct {
-	InstallId     uint                `json:"installId" validate:"required"`
-	BackupId      uint                `json:"backupId"`
-	DetailId      uint                `json:"detailId"`
-	Operate       constant.AppOperate `json:"operate" validate:"required"`
-	ForceDelete   bool                `json:"forceDelete"`
-	DeleteBackup  bool                `json:"deleteBackup"`
-	DeleteDB      bool                `json:"deleteDB"`
-	Backup        bool                `json:"backup"`
-	PullImage     bool                `json:"pullImage"`
-	DockerCompose string              `json:"dockerCompose"`
-}
-
-type AppInstallUpgrade struct {
-	InstallID     uint   `json:"installId"`
-	DetailID      uint   `json:"detailId"`
-	Backup        bool   `json:"backup"`
-	PullImage     bool   `json:"pullImage"`
-	DockerCompose string `json:"dockerCompose"`
+	InstallId    uint                `json:"installId" validate:"required"`
+	BackupId     uint                `json:"backupId"`
+	DetailId     uint                `json:"detailId"`
+	Operate      constant.AppOperate `json:"operate" validate:"required"`
+	ForceDelete  bool                `json:"forceDelete"`
+	DeleteBackup bool                `json:"deleteBackup"`
+	DeleteDB     bool                `json:"deleteDB"`
+	Backup       bool                `json:"backup"`
+	PullImage    bool                `json:"pullImage"`
 }
 
 type AppInstalledUpdate struct {
@@ -97,8 +87,3 @@ type PortUpdate struct {
 	Name string `json:"name"`
 	Port int64  `json:"port"`
 }
-
-type AppUpdateVersion struct {
-	AppInstallID  uint   `json:"appInstallID" validate:"required"`
-	UpdateVersion string `json:"updateVersion"`
-}

backend/app/dto/request/file.go

@@ -10,8 +10,7 @@ type FileOption struct {
 }
 
 type FileContentReq struct {
-	Path     string `json:"path" validate:"required"`
-	IsDetail bool   `json:"isDetail"`
+	Path string `json:"path" validate:"required"`
 }
 
 type SearchUploadWithPage struct {
@@ -55,14 +54,12 @@ type FileCompress struct {
 	Type    string   `json:"type" validate:"required"`
 	Name    string   `json:"name" validate:"required"`
 	Replace bool     `json:"replace"`
-	Secret  string   `json:"secret"`
 }
 
 type FileDeCompress struct {
-	Dst    string `json:"dst"  validate:"required"`
-	Type   string `json:"type"  validate:"required"`
-	Path   string `json:"path" validate:"required"`
-	Secret string `json:"secret"`
+	Dst  string `json:"dst"  validate:"required"`
+	Type string `json:"type"  validate:"required"`
+	Path string `json:"path" validate:"required"`
 }
 
 type FileEdit struct {
@@ -127,7 +124,6 @@ type FileReadByLineReq struct {
 	Type     string `json:"type" validate:"required"`
 	ID       uint   `json:"ID"`
 	Name     string `json:"name"`
-	Latest   bool   `json:"latest"`
 }
 
 type FileExistReq struct {

backend/app/dto/request/nginx.go

@@ -27,7 +27,7 @@ type NginxRewriteReq struct {
 type NginxRewriteUpdate struct {
 	WebsiteID uint   `json:"websiteId" validate:"required"`
 	Name      string `json:"name" validate:"required"`
-	Content   string `json:"content"`
+	Content   string `json:"content" validate:"required"`
 }
 
 type NginxProxyUpdate struct {

backend/app/dto/request/website.go

@@ -7,8 +7,8 @@ import (
 type WebsiteSearch struct {
 	dto.PageInfo
 	Name           string `json:"name"`
-	OrderBy        string `json:"orderBy" validate:"required,oneof=primary_domain type status created_at expire_date"`
-	Order          string `json:"order" validate:"required,oneof=null ascending descending"`
+	OrderBy        string `json:"orderBy"`
+	Order          string `json:"order"`
 	WebsiteGroupID uint   `json:"websiteGroupId"`
 }
 
@@ -27,9 +27,6 @@ type WebsiteCreate struct {
 	AppID        uint          `json:"appID"`
 	AppInstallID uint          `json:"appInstallID"`
 
-	FtpUser     string `json:"ftpUser"`
-	FtpPassword string `json:"ftpPassword"`
-
 	RuntimeID uint `json:"runtimeID"`
 	RuntimeConfig
 }
@@ -55,7 +52,7 @@ type WebsiteUpdate struct {
 	ID             uint   `json:"id" validate:"required"`
 	PrimaryDomain  string `json:"primaryDomain" validate:"required"`
 	Remark         string `json:"remark"`
-	WebsiteGroupID uint   `json:"webSiteGroupID"`
+	WebsiteGroupID uint   `json:"webSiteGroupID" validate:"required"`
 	ExpireDate     string `json:"expireDate"`
 	IPV6           bool   `json:"IPV6"`
 }
@@ -123,7 +120,6 @@ type WebsiteHTTPSOp struct {
 	HttpConfig      string   `json:"httpConfig"  validate:"oneof=HTTPSOnly HTTPAlso HTTPToHTTPS"`
 	SSLProtocol     []string `json:"SSLProtocol"`
 	Algorithm       string   `json:"algorithm"`
-	Hsts            bool     `json:"hsts"`
 }
 
 type WebsiteNginxUpdate struct {
@@ -189,7 +185,6 @@ type WebsiteProxyConfig struct {
 	Content   string            `json:"content"`
 	FilePath  string            `json:"filePath"`
 	Replaces  map[string]string `json:"replaces"`
-	SNI       bool              `json:"sni"`
 }
 
 type WebsiteProxyReq struct {
@@ -209,12 +204,3 @@ type WafWebsite struct {
 	Domains []string `json:"domains"`
 	Host    []string `json:"host"`
 }
-
-type WebsiteHtmlReq struct {
-	Type string `json:"type" validate:"required"`
-}
-
-type WebsiteHtmlUpdate struct {
-	Type    string `json:"type" validate:"required"`
-	Content string `json:"content" validate:"required"`
-}

backend/app/dto/request/website_ssl.go

@@ -20,12 +20,6 @@ type WebsiteSSLCreate struct {
 	Dir           string `json:"dir"`
 	ID            uint   `json:"id"`
 	Description   string `json:"description"`
-	DisableCNAME  bool   `json:"disableCNAME"`
-	SkipDNS       bool   `json:"skipDNS"`
-	Nameserver1   string `json:"nameserver1"`
-	Nameserver2   string `json:"nameserver2"`
-	ExecShell     bool   `json:"execShell"`
-	Shell         string `json:"shell"`
 }
 
 type WebsiteDNSReq struct {
@@ -38,9 +32,8 @@ type WebsiteSSLRenew struct {
 }
 
 type WebsiteSSLApply struct {
-	ID           uint     `json:"ID" validate:"required"`
-	SkipDNSCheck bool     `json:"skipDNSCheck"`
-	Nameservers  []string `json:"nameservers"`
+	ID           uint `json:"ID" validate:"required"`
+	SkipDNSCheck bool `json:"SkipDNSCheck"`
 }
 
 type WebsiteAcmeAccountCreate struct {
@@ -73,24 +66,9 @@ type WebsiteBatchDelReq struct {
 }
 
 type WebsiteSSLUpdate struct {
-	ID            uint   `json:"id" validate:"required"`
-	AutoRenew     bool   `json:"autoRenew"`
-	Description   string `json:"description"`
-	PrimaryDomain string `json:"primaryDomain" validate:"required"`
-	OtherDomains  string `json:"otherDomains"`
-	Provider      string `json:"provider" validate:"required"`
-	AcmeAccountID uint   `json:"acmeAccountId"`
-	DnsAccountID  uint   `json:"dnsAccountId"`
-	KeyType       string `json:"keyType"`
-	Apply         bool   `json:"apply"`
-	PushDir       bool   `json:"pushDir"`
-	Dir           string `json:"dir"`
-	DisableCNAME  bool   `json:"disableCNAME"`
-	SkipDNS       bool   `json:"skipDNS"`
-	Nameserver1   string `json:"nameserver1"`
-	Nameserver2   string `json:"nameserver2"`
-	ExecShell     bool   `json:"execShell"`
-	Shell         string `json:"shell"`
+	ID          uint   `json:"id" validate:"required"`
+	AutoRenew   bool   `json:"autoRenew"`
+	Description string `json:"description"`
 }
 
 type WebsiteSSLUpload struct {
@@ -130,8 +108,6 @@ type WebsiteCAObtain struct {
 	Renew       bool   `json:"renew"`
 	SSLID       uint   `json:"sslID"`
 	Description string `json:"description"`
-	ExecShell   bool   `json:"execShell"`
-	Shell       string `json:"shell"`
 }
 
 type WebsiteCARenew struct {

backend/app/dto/response/app.go

@@ -10,7 +10,7 @@ import (
 )
 
 type AppRes struct {
-	Items []*AppDto `json:"items"`
+	Items []*AppDTO `json:"items"`
 	Total int64     `json:"total"`
 }
 
@@ -28,22 +28,6 @@ type AppDTO struct {
 	Tags      []model.Tag `json:"tags"`
 }
 
-type AppDto struct {
-	Name        string      `json:"name"`
-	Key         string      `json:"key"`
-	ID          uint        `json:"id"`
-	ShortDescZh string      `json:"shortDescZh"`
-	ShortDescEn string      `json:"shortDescEn"`
-	Icon        string      `json:"icon"`
-	Type        string      `json:"type"`
-	Status      string      `json:"status"`
-	Resource    string      `json:"resource"`
-	Installed   bool        `json:"installed"`
-	Versions    []string    `json:"versions"`
-	Limit       int         `json:"limit"`
-	Tags        []model.Tag `json:"tags"`
-}
-
 type TagDTO struct {
 	model.Tag
 }
@@ -88,38 +72,7 @@ type AppInstalledDTO struct {
 	Path      string `json:"path"`
 }
 
-type AppDetail struct {
-	Website  string `json:"website"`
-	Document string `json:"document"`
-	Github   string `json:"github"`
-}
-
-type AppInstallDTO struct {
-	ID            uint      `json:"id"`
-	Name          string    `json:"name"`
-	AppID         uint      `json:"appID"`
-	AppDetailID   uint      `json:"appDetailID"`
-	Version       string    `json:"version"`
-	Status        string    `json:"status"`
-	Message       string    `json:"message"`
-	HttpPort      int       `json:"httpPort"`
-	HttpsPort     int       `json:"httpsPort"`
-	Path          string    `json:"path"`
-	CanUpdate     bool      `json:"canUpdate"`
-	Icon          string    `json:"icon"`
-	AppName       string    `json:"appName"`
-	Ready         int       `json:"ready"`
-	Total         int       `json:"total"`
-	AppKey        string    `json:"appKey"`
-	AppType       string    `json:"appType"`
-	AppStatus     string    `json:"appStatus"`
-	DockerCompose string    `json:"dockerCompose"`
-	CreatedAt     time.Time `json:"createdAt"`
-	App           AppDetail `json:"app"`
-}
-
 type DatabaseConn struct {
-	Status        string `json:"status"`
 	Username      string `json:"username"`
 	Password      string `json:"password"`
 	ContainerName string `json:"containerName"`

backend/app/dto/response/file.go

@@ -15,12 +15,10 @@ type UploadInfo struct {
 }
 
 type FileTree struct {
-	ID        string     `json:"id"`
-	Name      string     `json:"name"`
-	Path      string     `json:"path"`
-	IsDir     bool       `json:"isDir"`
-	Extension string     `json:"extension"`
-	Children  []FileTree `json:"children"`
+	ID       string     `json:"id"`
+	Name     string     `json:"name"`
+	Path     string     `json:"path"`
+	Children []FileTree `json:"children"`
 }
 
 type DirSizeRes struct {
@@ -36,11 +34,9 @@ type FileWgetRes struct {
 }
 
 type FileLineContent struct {
-	Content string   `json:"content"`
-	End     bool     `json:"end"`
-	Path    string   `json:"path"`
-	Total   int      `json:"total"`
-	Lines   []string `json:"lines"`
+	Content string `json:"content"`
+	End     bool   `json:"end"`
+	Path    string `json:"path"`
 }
 
 type FileExist struct {

backend/app/dto/response/website.go

@@ -2,7 +2,6 @@ package response
 
 import (
 	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"time"
 )
 
 type WebsiteDTO struct {
@@ -12,26 +11,6 @@ type WebsiteDTO struct {
 	SitePath      string `json:"sitePath"`
 	AppName       string `json:"appName"`
 	RuntimeName   string `json:"runtimeName"`
-	SiteDir       string `gorm:"type:varchar;" json:"siteDir"`
-}
-
-type WebsiteRes struct {
-	ID            uint      `json:"id"`
-	CreatedAt     time.Time `json:"createdAt"`
-	Protocol      string    `json:"protocol"`
-	PrimaryDomain string    `json:"primaryDomain"`
-	Type          string    `json:"type"`
-	Alias         string    `json:"alias"`
-	Remark        string    `json:"remark"`
-	Status        string    `json:"status"`
-	ExpireDate    time.Time `json:"expireDate"`
-	SitePath      string    `json:"sitePath"`
-	AppName       string    `json:"appName"`
-	RuntimeName   string    `json:"runtimeName"`
-	SSLExpireDate time.Time `json:"sslExpireDate"`
-	SSLStatus     string    `json:"sslStatus"`
-	AppInstallID  uint      `json:"appInstallId"`
-	RuntimeType   string    `json:"runtimeType"`
 }
 
 type WebsiteOption struct {
@@ -58,7 +37,6 @@ type WebsiteHTTPS struct {
 	SSL         model.WebsiteSSL `json:"SSL"`
 	SSLProtocol []string         `json:"SSLProtocol"`
 	Algorithm   string           `json:"algorithm"`
-	Hsts        bool             `json:"hsts"`
 }
 
 type WebsiteLog struct {
@@ -84,7 +62,3 @@ type WebsiteDirConfig struct {
 	UserGroup string   `json:"userGroup"`
 	Msg       string   `json:"msg"`
 }
-
-type WebsiteHtmlRes struct {
-	Content string `json:"content"`
-}

backend/app/dto/setting.go

@@ -8,7 +8,6 @@ type SettingInfo struct {
 	SystemIP       string `json:"systemIP"`
 	SystemVersion  string `json:"systemVersion"`
 	DockerSockPath string `json:"dockerSockPath"`
-	DeveloperMode  string `json:"developerMode"`
 
 	SessionTimeout string `json:"sessionTimeout"`
 	LocalTime      string `json:"localTime"`
@@ -58,13 +57,6 @@ type SettingInfo struct {
 	SnapshotIgnore string `json:"snapshotIgnore"`
 	XpackHideMenu  string `json:"xpackHideMenu"`
 	NoAuthSetting  string `json:"noAuthSetting"`
-
-	ProxyUrl        string `json:"proxyUrl"`
-	ProxyType       string `json:"proxyType"`
-	ProxyPort       string `json:"proxyPort"`
-	ProxyUser       string `json:"proxyUser"`
-	ProxyPasswd     string `json:"proxyPasswd"`
-	ProxyPasswdKeep string `json:"proxyPasswdKeep"`
 }
 
 type SettingUpdate struct {
@@ -98,12 +90,6 @@ type PortUpdate struct {
 	ServerPort uint `json:"serverPort" validate:"required,number,max=65535,min=1"`
 }
 
-type PageSnapshot struct {
-	PageInfo
-	Info    string `json:"info"`
-	OrderBy string `json:"orderBy" validate:"required,oneof=name created_at"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
-}
 type SnapshotStatus struct {
 	Panel      string `json:"panel"`
 	PanelInfo  string `json:"panelInfo"`
@@ -122,17 +108,11 @@ type SnapshotCreate struct {
 	From            string `json:"from" validate:"required"`
 	DefaultDownload string `json:"defaultDownload" validate:"required"`
 	Description     string `json:"description" validate:"max=256"`
-	Secret          string `json:"secret"`
 }
 type SnapshotRecover struct {
-	IsNew      bool   `json:"isNew"`
-	ReDownload bool   `json:"reDownload"`
-	ID         uint   `json:"id" validate:"required"`
-	Secret     string `json:"secret"`
-}
-type SnapshotBatchDelete struct {
-	DeleteWithFile bool   `json:"deleteWithFile"`
-	Ids            []uint `json:"ids" validate:"required"`
+	IsNew      bool `json:"isNew"`
+	ReDownload bool `json:"reDownload"`
+	ID         uint `json:"id" validate:"required"`
 }
 type SnapshotImport struct {
 	From        string   `json:"from"`
@@ -149,7 +129,6 @@ type SnapshotInfo struct {
 	Message         string    `json:"message"`
 	CreatedAt       time.Time `json:"createdAt"`
 	Version         string    `json:"version"`
-	Size            int64     `json:"size"`
 
 	InterruptStep    string `json:"interruptStep"`
 	RecoverStatus    string `json:"recoverStatus"`
@@ -161,7 +140,6 @@ type SnapshotInfo struct {
 }
 
 type UpgradeInfo struct {
-	TestVersion   string `json:"testVersion"`
 	NewVersion    string `json:"newVersion"`
 	LatestVersion string `json:"latestVersion"`
 	ReleaseNote   string `json:"releaseNote"`
@@ -180,21 +158,11 @@ type Upgrade struct {
 	Version string `json:"version" validate:"required"`
 }
 
-type ProxyUpdate struct {
-	ProxyUrl        string `json:"proxyUrl"`
-	ProxyType       string `json:"proxyType"`
-	ProxyPort       string `json:"proxyPort"`
-	ProxyUser       string `json:"proxyUser"`
-	ProxyPasswd     string `json:"proxyPasswd"`
-	ProxyPasswdKeep string `json:"proxyPasswdKeep"`
-}
-
 type CleanData struct {
 	SystemClean    []CleanTree `json:"systemClean"`
 	UploadClean    []CleanTree `json:"uploadClean"`
 	DownloadClean  []CleanTree `json:"downloadClean"`
 	SystemLogClean []CleanTree `json:"systemLogClean"`
-	ContainerClean []CleanTree `json:"containerClean"`
 }
 
 type CleanTree struct {
@@ -215,12 +183,3 @@ type Clean struct {
 	Name     string `json:"name"`
 	Size     uint64 `json:"size"`
 }
-
-type XpackHideMenu struct {
-	ID       string          `json:"id"`
-	Label    string          `json:"label"`
-	IsCheck  bool            `json:"isCheck"`
-	Title    string          `json:"title"`
-	Path     string          `json:"path,omitempty"`
-	Children []XpackHideMenu `json:"children,omitempty"`
-}

backend/app/model/app.go

@@ -16,7 +16,7 @@ type App struct {
 	Type               string `json:"type" gorm:"type:varchar(64);not null"`
 	Status             string `json:"status" gorm:"type:varchar(64);not null"`
 	Required           string `json:"required" gorm:"type:varchar(64);"`
-	CrossVersionUpdate bool   `json:"crossVersionUpdate" yaml:"crossVersionUpdate"`
+	CrossVersionUpdate bool   `json:"crossVersionUpdate"`
 	Limit              int    `json:"limit" gorm:"type:Integer;not null"`
 	Website            string `json:"website" gorm:"type:varchar(64);not null"`
 	Github             string `json:"github" gorm:"type:varchar(64);not null"`

backend/app/model/clam.go

@@ -1,14 +0,0 @@
-package model
-
-type Clam struct {
-	BaseModel
-
-	Name             string `gorm:"type:varchar(64);not null" json:"name"`
-	Status           string `gorm:"type:varchar(64)" json:"status"`
-	Path             string `gorm:"type:varchar(64);not null" json:"path"`
-	InfectedStrategy string `gorm:"type:varchar(64)" json:"infectedStrategy"`
-	InfectedDir      string `gorm:"type:varchar(64)" json:"infectedDir"`
-	Spec             string `gorm:"type:varchar(64)" json:"spec"`
-	EntryID          int    `gorm:"type:varchar(64)" json:"entryID"`
-	Description      string `gorm:"type:varchar(64)" json:"description"`
-}

backend/app/model/command.go

@@ -6,9 +6,3 @@ type Command struct {
 	GroupID uint   `gorm:"type:decimal" json:"groupID"`
 	Command string `gorm:"type:varchar(256);not null" json:"command"`
 }
-
-type RedisCommand struct {
-	BaseModel
-	Name    string `gorm:"type:varchar(64);unique;not null" json:"name"`
-	Command string `gorm:"type:varchar(256);not null" json:"command"`
-}

backend/app/model/compose_template.go

@@ -12,5 +12,4 @@ type Compose struct {
 	BaseModel
 
 	Name string `gorm:"type:varchar(256)" json:"name"`
-	Path string `gorm:"type:varchar(256)" json:"path"`
 }

backend/app/model/cronjob.go

@@ -1,8 +1,6 @@
 package model
 
-import (
-	"time"
-)
+import "time"
 
 type Cronjob struct {
 	BaseModel
@@ -33,7 +31,6 @@ type Cronjob struct {
 	Status   string       `gorm:"type:varchar(64)" json:"status"`
 	EntryIDs string       `gorm:"type:varchar(64)" json:"entryIDs"`
 	Records  []JobRecords `json:"records"`
-	Secret   string       `gorm:"type:varchar(64)" json:"secret"`
 }
 
 type JobRecords struct {

backend/app/model/firewall.go

@@ -10,12 +10,3 @@ type Firewall struct {
 	Strategy    string `gorm:"type:varchar(64);not null" json:"strategy"`
 	Description string `gorm:"type:varchar(64);not null" json:"description"`
 }
-
-type Forward struct {
-	BaseModel
-
-	Protocol   string `gorm:"type:varchar(64);not null" json:"protocol"`
-	Port       string `gorm:"type:varchar(64);not null" json:"port"`
-	TargetIP   string `gorm:"type:varchar(64);not null" json:"targetIP"`
-	TargetPort string `gorm:"type:varchar(64);not null" json:"targetPort"`
-}

backend/app/model/ftp.go

@@ -1,11 +0,0 @@
-package model
-
-type Ftp struct {
-	BaseModel
-
-	User        string `gorm:"type:varchar(64);not null" json:"user"`
-	Password    string `gorm:"type:varchar(64);not null" json:"password"`
-	Status      string `gorm:"type:varchar(64);not null" json:"status"`
-	Path        string `gorm:"type:varchar(64);not null" json:"path"`
-	Description string `gorm:"type:varchar(64);not null" json:"description"`
-}

backend/app/model/website.go

@@ -26,7 +26,6 @@ type Website struct {
 	WebsiteSSLID   uint `gorm:"type:integer" json:"webSiteSSLId"`
 	RuntimeID      uint `gorm:"type:integer" json:"runtimeID"`
 	AppInstallID   uint `gorm:"type:integer" json:"appInstallId"`
-	FtpID          uint `gorm:"type:integer" json:"ftpId"`
 
 	User  string `gorm:"type:varchar;" json:"user"`
 	Group string `gorm:"type:varchar;" json:"group"`

backend/app/model/website_ssl.go

@@ -9,32 +9,26 @@ import (
 
 type WebsiteSSL struct {
 	BaseModel
-	PrimaryDomain string    `json:"primaryDomain"`
-	PrivateKey    string    `json:"privateKey"`
-	Pem           string    `json:"pem"`
-	Domains       string    `json:"domains"`
-	CertURL       string    `json:"certURL"`
-	Type          string    `json:"type"`
-	Provider      string    `json:"provider"`
-	Organization  string    `json:"organization"`
-	DnsAccountID  uint      `json:"dnsAccountId"`
-	AcmeAccountID uint      `gorm:"column:acme_account_id" json:"acmeAccountId" `
-	CaID          uint      `json:"caId"`
-	AutoRenew     bool      `json:"autoRenew"`
+	PrimaryDomain string    `gorm:"type:varchar(256);not null" json:"primaryDomain"`
+	PrivateKey    string    `gorm:"type:longtext;not null" json:"privateKey"`
+	Pem           string    `gorm:"type:longtext;not null" json:"pem"`
+	Domains       string    `gorm:"type:varchar(256);not null" json:"domains"`
+	CertURL       string    `gorm:"type:varchar(256);not null" json:"certURL"`
+	Type          string    `gorm:"type:varchar(64);not null" json:"type"`
+	Provider      string    `gorm:"type:varchar(64);not null" json:"provider"`
+	Organization  string    `gorm:"type:varchar(64);not null" json:"organization"`
+	DnsAccountID  uint      `gorm:"type:integer;not null" json:"dnsAccountId"`
+	AcmeAccountID uint      `gorm:"type:integer;not null" json:"acmeAccountId"`
+	CaID          uint      `gorm:"type:integer;not null;default:0" json:"caId"`
+	AutoRenew     bool      `gorm:"type:varchar(64);not null" json:"autoRenew"`
 	ExpireDate    time.Time `json:"expireDate"`
 	StartDate     time.Time `json:"startDate"`
-	Status        string    `json:"status"`
+	Status        string    `gorm:"not null;default:ready" json:"status"`
 	Message       string    `json:"message"`
-	KeyType       string    `json:"keyType"`
-	PushDir       bool      `json:"pushDir"`
+	KeyType       string    `gorm:"not null;default:2048" json:"keyType"`
+	PushDir       bool      `gorm:"not null;default:0" json:"pushDir"`
 	Dir           string    `json:"dir"`
 	Description   string    `json:"description"`
-	SkipDNS       bool      `json:"skipDNS"`
-	Nameserver1   string    `json:"nameserver1"`
-	Nameserver2   string    `json:"nameserver2"`
-	DisableCNAME  bool      `json:"disableCNAME"`
-	ExecShell     bool      `json:"execShell"`
-	Shell         string    `json:"shell"`
 
 	AcmeAccount WebsiteAcmeAccount `json:"acmeAccount" gorm:"-:migration"`
 	DnsAccount  WebsiteDnsAccount  `json:"dnsAccount" gorm:"-:migration"`

backend/app/repo/app_install.go

@@ -3,7 +3,6 @@ package repo
 import (
 	"context"
 	"encoding/json"
-
 	"github.com/1Panel-dev/1Panel/backend/constant"
 
 	"gorm.io/gorm/clause"
@@ -161,7 +160,6 @@ func (a *AppInstallRepo) BatchUpdateBy(maps map[string]interface{}, opts ...DBOp
 type RootInfo struct {
 	ID            uint   `json:"id"`
 	Name          string `json:"name"`
-	Status        string `json:"status"`
 	Port          int64  `json:"port"`
 	HttpsPort     int64  `json:"httpsPort"`
 	UserName      string `json:"userName"`
@@ -236,6 +234,5 @@ func (a *AppInstallRepo) LoadBaseInfo(key string, name string) (*RootInfo, error
 	info.Key = app.Key
 	appInstall.App = app
 	info.AppPath = appInstall.GetAppPath()
-	info.Status = appInstall.Status
 	return &info, nil
 }

backend/app/repo/backup.go

@@ -25,7 +25,6 @@ type IBackupRepo interface {
 	WithByFileName(fileName string) DBOption
 	WithByType(backupType string) DBOption
 	WithByCronID(cronjobID uint) DBOption
-	WithFileNameStartWith(filePrefix string) DBOption
 }
 
 func NewIBackupRepo() IBackupRepo {
@@ -82,12 +81,6 @@ func (u *BackupRepo) WithByFileName(fileName string) DBOption {
 	}
 }
 
-func (u *BackupRepo) WithFileNameStartWith(filePrefix string) DBOption {
-	return func(g *gorm.DB) *gorm.DB {
-		return g.Where("file_name LIKE ?", filePrefix+"%")
-	}
-}
-
 func (u *BackupRepo) WithByType(backupType string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(backupType) == 0 {

backend/app/repo/clam.go

@@ -1,69 +0,0 @@
-package repo
-
-import (
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/global"
-)
-
-type ClamRepo struct{}
-
-type IClamRepo interface {
-	Page(limit, offset int, opts ...DBOption) (int64, []model.Clam, error)
-	Create(clam *model.Clam) error
-	Update(id uint, vars map[string]interface{}) error
-	Delete(opts ...DBOption) error
-	Get(opts ...DBOption) (model.Clam, error)
-	List(opts ...DBOption) ([]model.Clam, error)
-}
-
-func NewIClamRepo() IClamRepo {
-	return &ClamRepo{}
-}
-
-func (u *ClamRepo) Get(opts ...DBOption) (model.Clam, error) {
-	var clam model.Clam
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.First(&clam).Error
-	return clam, err
-}
-
-func (u *ClamRepo) List(opts ...DBOption) ([]model.Clam, error) {
-	var clam []model.Clam
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.Find(&clam).Error
-	return clam, err
-}
-
-func (u *ClamRepo) Page(page, size int, opts ...DBOption) (int64, []model.Clam, error) {
-	var users []model.Clam
-	db := global.DB.Model(&model.Clam{})
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	count := int64(0)
-	db = db.Count(&count)
-	err := db.Limit(size).Offset(size * (page - 1)).Find(&users).Error
-	return count, users, err
-}
-
-func (u *ClamRepo) Create(clam *model.Clam) error {
-	return global.DB.Create(clam).Error
-}
-
-func (u *ClamRepo) Update(id uint, vars map[string]interface{}) error {
-	return global.DB.Model(&model.Clam{}).Where("id = ?", id).Updates(vars).Error
-}
-
-func (u *ClamRepo) Delete(opts ...DBOption) error {
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	return db.Delete(&model.Clam{}).Error
-}

backend/app/repo/command.go

@@ -17,12 +17,6 @@ type ICommandRepo interface {
 	Delete(opts ...DBOption) error
 	Get(opts ...DBOption) (model.Command, error)
 	WithLikeName(name string) DBOption
-
-	PageRedis(limit, offset int, opts ...DBOption) (int64, []model.RedisCommand, error)
-	GetRedis(opts ...DBOption) (model.RedisCommand, error)
-	GetRedisList(opts ...DBOption) ([]model.RedisCommand, error)
-	SaveRedis(command *model.RedisCommand) error
-	DeleteRedis(opts ...DBOption) error
 }
 
 func NewICommandRepo() ICommandRepo {
@@ -39,16 +33,6 @@ func (u *CommandRepo) Get(opts ...DBOption) (model.Command, error) {
 	return command, err
 }
 
-func (u *CommandRepo) GetRedis(opts ...DBOption) (model.RedisCommand, error) {
-	var command model.RedisCommand
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.First(&command).Error
-	return command, err
-}
-
 func (u *CommandRepo) Page(page, size int, opts ...DBOption) (int64, []model.Command, error) {
 	var users []model.Command
 	db := global.DB.Model(&model.Command{})
@@ -61,18 +45,6 @@ func (u *CommandRepo) Page(page, size int, opts ...DBOption) (int64, []model.Com
 	return count, users, err
 }
 
-func (u *CommandRepo) PageRedis(page, size int, opts ...DBOption) (int64, []model.RedisCommand, error) {
-	var users []model.RedisCommand
-	db := global.DB.Model(&model.RedisCommand{})
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	count := int64(0)
-	db = db.Count(&count)
-	err := db.Limit(size).Offset(size * (page - 1)).Find(&users).Error
-	return count, users, err
-}
-
 func (u *CommandRepo) GetList(opts ...DBOption) ([]model.Command, error) {
 	var commands []model.Command
 	db := global.DB.Model(&model.Command{})
@@ -83,16 +55,6 @@ func (u *CommandRepo) GetList(opts ...DBOption) ([]model.Command, error) {
 	return commands, err
 }
 
-func (u *CommandRepo) GetRedisList(opts ...DBOption) ([]model.RedisCommand, error) {
-	var commands []model.RedisCommand
-	db := global.DB.Model(&model.RedisCommand{})
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.Find(&commands).Error
-	return commands, err
-}
-
 func (c *CommandRepo) WithByInfo(info string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(info) == 0 {
@@ -107,10 +69,6 @@ func (u *CommandRepo) Create(command *model.Command) error {
 	return global.DB.Create(command).Error
 }
 
-func (u *CommandRepo) SaveRedis(command *model.RedisCommand) error {
-	return global.DB.Save(command).Error
-}
-
 func (u *CommandRepo) Update(id uint, vars map[string]interface{}) error {
 	return global.DB.Model(&model.Command{}).Where("id = ?", id).Updates(vars).Error
 }
@@ -123,14 +81,6 @@ func (u *CommandRepo) Delete(opts ...DBOption) error {
 	return db.Delete(&model.Command{}).Error
 }
 
-func (u *CommandRepo) DeleteRedis(opts ...DBOption) error {
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	return db.Delete(&model.RedisCommand{}).Error
-}
-
 func (a CommandRepo) WithLikeName(name string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(name) == 0 {

backend/app/repo/compose_template.go

@@ -19,7 +19,6 @@ type IComposeTemplateRepo interface {
 	CreateRecord(compose *model.Compose) error
 	DeleteRecord(opts ...DBOption) error
 	ListRecord() ([]model.Compose, error)
-	UpdateRecord(name string, vars map[string]interface{}) error
 }
 
 func NewIComposeTemplateRepo() IComposeTemplateRepo {
@@ -103,7 +102,3 @@ func (u *ComposeTemplateRepo) DeleteRecord(opts ...DBOption) error {
 	}
 	return db.Delete(&model.Compose{}).Error
 }
-
-func (u *ComposeTemplateRepo) UpdateRecord(name string, vars map[string]interface{}) error {
-	return global.DB.Model(&model.Compose{}).Where("name = ?", name).Updates(vars).Error
-}

backend/app/repo/ftp.go

@@ -1,80 +0,0 @@
-package repo
-
-import (
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/global"
-	"gorm.io/gorm"
-)
-
-type FtpRepo struct{}
-
-type IFtpRepo interface {
-	Get(opts ...DBOption) (model.Ftp, error)
-	GetList(opts ...DBOption) ([]model.Ftp, error)
-	Page(limit, offset int, opts ...DBOption) (int64, []model.Ftp, error)
-	Create(ftp *model.Ftp) error
-	Update(id uint, vars map[string]interface{}) error
-	Delete(opts ...DBOption) error
-	WithByUser(user string) DBOption
-}
-
-func NewIFtpRepo() IFtpRepo {
-	return &FtpRepo{}
-}
-
-func (u *FtpRepo) Get(opts ...DBOption) (model.Ftp, error) {
-	var ftp model.Ftp
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.First(&ftp).Error
-	return ftp, err
-}
-
-func (h *FtpRepo) WithByUser(user string) DBOption {
-	return func(g *gorm.DB) *gorm.DB {
-		if len(user) == 0 {
-			return g
-		}
-		return g.Where("user like ?", "%"+user+"%")
-	}
-}
-
-func (u *FtpRepo) GetList(opts ...DBOption) ([]model.Ftp, error) {
-	var ftps []model.Ftp
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	err := db.Find(&ftps).Error
-	return ftps, err
-}
-
-func (h *FtpRepo) Page(page, size int, opts ...DBOption) (int64, []model.Ftp, error) {
-	var users []model.Ftp
-	db := global.DB.Model(&model.Ftp{})
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	count := int64(0)
-	db = db.Count(&count)
-	err := db.Limit(size).Offset(size * (page - 1)).Find(&users).Error
-	return count, users, err
-}
-
-func (h *FtpRepo) Create(ftp *model.Ftp) error {
-	return global.DB.Create(ftp).Error
-}
-
-func (h *FtpRepo) Update(id uint, vars map[string]interface{}) error {
-	return global.DB.Model(&model.Ftp{}).Where("id = ?", id).Updates(vars).Error
-}
-
-func (h *FtpRepo) Delete(opts ...DBOption) error {
-	db := global.DB
-	for _, opt := range opts {
-		db = opt(db)
-	}
-	return db.Delete(&model.Ftp{}).Error
-}

backend/app/repo/website.go

@@ -96,7 +96,7 @@ func (w *WebsiteRepo) Page(page, size int, opts ...DBOption) (int64, []model.Web
 	db := getDb(opts...).Model(&model.Website{})
 	count := int64(0)
 	db = db.Count(&count)
-	err := db.Debug().Limit(size).Offset(size * (page - 1)).Preload("WebsiteSSL").Find(&websites).Error
+	err := db.Limit(size).Offset(size * (page - 1)).Preload("WebsiteSSL").Find(&websites).Error
 	return count, websites, err
 }
 

backend/app/repo/website_ssl.go

@@ -21,7 +21,6 @@ type ISSLRepo interface {
 	Create(ctx context.Context, ssl *model.WebsiteSSL) error
 	Save(ssl *model.WebsiteSSL) error
 	DeleteBy(opts ...DBOption) error
-	SaveByMap(ssl *model.WebsiteSSL, params map[string]interface{}) error
 }
 
 type WebsiteSSLRepo struct {
@@ -50,6 +49,7 @@ func (w WebsiteSSLRepo) WithByCAID(caID uint) DBOption {
 		return db.Where("ca_id = ?", caID)
 	}
 }
+
 func (w WebsiteSSLRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteSSL, error) {
 	var sslList []model.WebsiteSSL
 	db := getDb(opts...).Model(&model.WebsiteSSL{})
@@ -82,15 +82,7 @@ func (w WebsiteSSLRepo) Create(ctx context.Context, ssl *model.WebsiteSSL) error
 }
 
 func (w WebsiteSSLRepo) Save(ssl *model.WebsiteSSL) error {
-	return getDb().Model(&model.WebsiteSSL{BaseModel: model.BaseModel{
-		ID: ssl.ID,
-	}}).Save(&ssl).Error
-}
-
-func (w WebsiteSSLRepo) SaveByMap(ssl *model.WebsiteSSL, params map[string]interface{}) error {
-	return getDb().Model(&model.WebsiteSSL{BaseModel: model.BaseModel{
-		ID: ssl.ID,
-	}}).Updates(params).Error
+	return getDb().Save(&ssl).Error
 }
 
 func (w WebsiteSSLRepo) DeleteBy(opts ...DBOption) error {

backend/app/service/app.go

@@ -5,6 +5,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -25,8 +26,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/utils/docker"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	http2 "github.com/1Panel-dev/1Panel/backend/utils/http"
-	httpUtil "github.com/1Panel-dev/1Panel/backend/utils/http"
-	"github.com/1Panel-dev/1Panel/backend/utils/xpack"
 	"gopkg.in/yaml.v3"
 )
 
@@ -89,22 +88,14 @@ func (a AppService) PageApp(req request.AppSearch) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	var appDTOs []*response.AppDto
+	var appDTOs []*response.AppDTO
 	for _, ap := range apps {
-		// ap.ReadMe = ""
-		// ap.Website = ""
-		// ap.Document = ""
-		// ap.Github = ""
-		appDTO := &response.AppDto{
-			ID:          ap.ID,
-			Name:        ap.Name,
-			Key:         ap.Key,
-			Type:        ap.Type,
-			Icon:        ap.Icon,
-			ShortDescZh: ap.ShortDescZh,
-			ShortDescEn: ap.ShortDescEn,
-			Resource:    ap.Resource,
-			Limit:       ap.Limit,
+		ap.ReadMe = ""
+		ap.Website = ""
+		ap.Document = ""
+		ap.Github = ""
+		appDTO := &response.AppDTO{
+			App: ap,
 		}
 		appDTOs = append(appDTOs, appDTO)
 		appTags, err := appTagRepo.GetByAppId(ap.ID)
@@ -145,9 +136,6 @@ func (a AppService) GetAppTags() ([]response.TagDTO, error) {
 
 func (a AppService) GetApp(key string) (*response.AppDTO, error) {
 	var appDTO response.AppDTO
-	if key == "postgres" {
-		key = "postgresql"
-	}
 	app, err := appRepo.GetFirst(appRepo.WithKey(key))
 	if err != nil {
 		return nil, err
@@ -188,7 +176,7 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 
 		versionPath := filepath.Join(app.GetAppResourcePath(), detail.Version)
 		if !fileOp.Stat(versionPath) || detail.Update {
-			if err = downloadApp(app, detail, nil); err != nil && !fileOp.Stat(versionPath) {
+			if err = downloadApp(app, detail, nil); err != nil {
 				return appDetailDTO, err
 			}
 		}
@@ -238,16 +226,20 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 	if appDetailDTO.DockerCompose == "" {
 		filename := filepath.Base(appDetailDTO.DownloadUrl)
 		dockerComposeUrl := fmt.Sprintf("%s%s", strings.TrimSuffix(appDetailDTO.DownloadUrl, filename), "docker-compose.yml")
-		statusCode, composeRes, err := httpUtil.HandleGet(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
+		composeRes, err := http.Get(dockerComposeUrl)
 		if err != nil {
 			return appDetailDTO, buserr.WithDetail("ErrGetCompose", err.Error(), err)
 		}
-		if statusCode > 200 {
-			return appDetailDTO, buserr.WithDetail("ErrGetCompose", string(composeRes), err)
+		bodyContent, err := io.ReadAll(composeRes.Body)
+		if err != nil {
+			return appDetailDTO, buserr.WithDetail("ErrGetCompose", err.Error(), err)
 		}
-		detail.DockerCompose = string(composeRes)
+		if composeRes.StatusCode > 200 {
+			return appDetailDTO, buserr.WithDetail("ErrGetCompose", string(bodyContent), err)
+		}
+		detail.DockerCompose = string(bodyContent)
 		_ = appDetailRepo.Update(context.Background(), detail)
-		appDetailDTO.DockerCompose = string(composeRes)
+		appDetailDTO.DockerCompose = string(bodyContent)
 	}
 
 	appDetailDTO.HostMode = isHostModel(appDetailDTO.DockerCompose)
@@ -370,7 +362,7 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 	}
 
 	value, ok := composeMap["services"]
-	if !ok || value == nil {
+	if !ok {
 		err = buserr.New(constant.ErrFileParse)
 		return
 	}
@@ -447,7 +439,6 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 		return
 	}
 	appInstall.Env = string(paramByte)
-
 	if err = appInstallRepo.Create(ctx, appInstall); err != nil {
 		return
 	}
@@ -457,7 +448,7 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 	go func() {
 		defer func() {
 			if err != nil {
-				appInstall.Status = constant.UpErr
+				appInstall.Status = constant.Error
 				appInstall.Message = err.Error()
 				_ = appInstallRepo.Save(context.Background(), appInstall)
 			}
@@ -707,11 +698,16 @@ func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
 	}
 
 	versionUrl := fmt.Sprintf("%s/%s/1panel.json.version.txt", global.CONF.System.AppRepo, global.CONF.System.Mode)
-	_, versionRes, err := http2.HandleGet(versionUrl, http.MethodGet, constant.TimeOut20s)
+	versionRes, err := http2.GetHttpRes(versionUrl)
 	if err != nil {
 		return nil, err
 	}
-	lastModifiedStr := string(versionRes)
+	defer versionRes.Body.Close()
+	body, err := io.ReadAll(versionRes.Body)
+	if err != nil {
+		return nil, err
+	}
+	lastModifiedStr := string(body)
 	lastModified, err := strconv.Atoi(lastModifiedStr)
 	if err != nil {
 		return nil, err
@@ -731,14 +727,6 @@ func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
 		res.CanUpdate = true
 		return res, err
 	}
-	apps, _ := appRepo.GetBy(appRepo.WithResource(constant.AppResourceRemote))
-	for _, app := range apps {
-		if app.Icon == "" {
-			res.CanUpdate = true
-			return res, err
-		}
-	}
-
 	list, err := getAppList()
 	if err != nil {
 		return res, err
@@ -756,10 +744,10 @@ func getAppFromRepo(downloadPath string) error {
 	global.LOG.Infof("[AppStore] download file from %s", downloadUrl)
 	fileOp := files.NewFileOp()
 	packagePath := filepath.Join(constant.ResourceDir, filepath.Base(downloadUrl))
-	if err := fileOp.DownloadFileWithProxy(downloadUrl, packagePath); err != nil {
+	if err := fileOp.DownloadFile(downloadUrl, packagePath); err != nil {
 		return err
 	}
-	if err := fileOp.Decompress(packagePath, constant.ResourceDir, files.SdkZip, ""); err != nil {
+	if err := fileOp.Decompress(packagePath, constant.ResourceDir, files.SdkZip); err != nil {
 		return err
 	}
 	defer func() {
@@ -837,22 +825,21 @@ func (a AppService) SyncAppListFromRemote() (err error) {
 		oldAppIds = append(oldAppIds, old.ID)
 	}
 
-	transport := xpack.LoadRequestTransport()
 	baseRemoteUrl := fmt.Sprintf("%s/%s/1panel", global.CONF.System.AppRepo, global.CONF.System.Mode)
 	appsMap := getApps(oldApps, list.Apps)
 
 	global.LOG.Infof("Starting synchronization of application details...")
 	for _, l := range list.Apps {
 		app := appsMap[l.AppProperty.Key]
-		_, iconRes, err := httpUtil.HandleGetWithTransport(l.Icon, http.MethodGet, transport, constant.TimeOut20s)
+		iconRes, err := http.Get(l.Icon)
 		if err != nil {
 			return err
 		}
-		iconStr := ""
-		if !strings.Contains(string(iconRes), "<xml>") {
-			iconStr = base64.StdEncoding.EncodeToString(iconRes)
+		body, err := io.ReadAll(iconRes.Body)
+		if err != nil {
+			return err
 		}
-
+		iconStr := base64.StdEncoding.EncodeToString(body)
 		app.Icon = iconStr
 		app.TagsKey = l.AppProperty.Tags
 		if l.AppProperty.Recommend > 0 {
@@ -871,11 +858,15 @@ func (a AppService) SyncAppListFromRemote() (err error) {
 
 			if _, ok := InitTypes[app.Type]; ok {
 				dockerComposeUrl := fmt.Sprintf("%s/%s", versionUrl, "docker-compose.yml")
-				_, composeRes, err := httpUtil.HandleGetWithTransport(dockerComposeUrl, http.MethodGet, transport, constant.TimeOut20s)
+				composeRes, err := http.Get(dockerComposeUrl)
 				if err != nil {
 					return err
 				}
-				detail.DockerCompose = string(composeRes)
+				bodyContent, err := io.ReadAll(composeRes.Body)
+				if err != nil {
+					return err
+				}
+				detail.DockerCompose = string(bodyContent)
 			} else {
 				detail.DockerCompose = ""
 			}

backend/app/service/app_install.go

@@ -5,18 +5,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
-	"net/http"
 	"os"
 	"path"
-	"path/filepath"
 	"reflect"
 	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
-	httpUtil "github.com/1Panel-dev/1Panel/backend/utils/http"
-	"github.com/docker/docker/api/types"
 	"gopkg.in/yaml.v3"
 
 	"github.com/1Panel-dev/1Panel/backend/utils/env"
@@ -43,17 +39,17 @@ type AppInstallService struct {
 }
 
 type IAppInstallService interface {
-	Page(req request.AppInstalledSearch) (int64, []response.AppInstallDTO, error)
+	Page(req request.AppInstalledSearch) (int64, []response.AppInstalledDTO, error)
 	CheckExist(req request.AppInstalledInfo) (*response.AppInstalledCheck, error)
 	LoadPort(req dto.OperationWithNameAndType) (int64, error)
 	LoadConnInfo(req dto.OperationWithNameAndType) (response.DatabaseConn, error)
-	SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstallDTO, error)
+	SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstalledDTO, error)
 	Operate(req request.AppInstalledOperate) error
 	Update(req request.AppInstalledUpdate) error
 	IgnoreUpgrade(req request.AppInstalledIgnoreUpgrade) error
 	SyncAll(systemInit bool) error
 	GetServices(key string) ([]response.AppService, error)
-	GetUpdateVersions(req request.AppUpdateVersion) ([]dto.AppVersion, error)
+	GetUpdateVersions(installId uint) ([]dto.AppVersion, error)
 	GetParams(id uint) (*response.AppConfig, error)
 	ChangeAppPort(req request.PortUpdate) error
 	GetDefaultConfigByKey(key, name string) (string, error)
@@ -78,7 +74,7 @@ func (a *AppInstallService) GetInstallList() ([]dto.AppInstallInfo, error) {
 	return datas, nil
 }
 
-func (a *AppInstallService) Page(req request.AppInstalledSearch) (int64, []response.AppInstallDTO, error) {
+func (a *AppInstallService) Page(req request.AppInstalledSearch) (int64, []response.AppInstalledDTO, error) {
 	var (
 		opts     []repo.DBOption
 		total    int64
@@ -122,7 +118,7 @@ func (a *AppInstallService) Page(req request.AppInstalledSearch) (int64, []respo
 		}
 	}
 
-	installDTOs, err := handleInstalled(installs, req.Update, req.Sync)
+	installDTOs, err := handleInstalled(installs, req.Update)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -154,7 +150,7 @@ func (a *AppInstallService) CheckExist(req request.AppInstalledInfo) (*response.
 	if reflect.DeepEqual(appInstall, model.AppInstall{}) {
 		return res, nil
 	}
-	if err = syncAppInstallStatus(&appInstall, false); err != nil {
+	if err = syncAppInstallStatus(&appInstall); err != nil {
 		return nil, err
 	}
 
@@ -186,7 +182,6 @@ func (a *AppInstallService) LoadConnInfo(req dto.OperationWithNameAndType) (resp
 	if err != nil {
 		return data, nil
 	}
-	data.Status = app.Status
 	data.Username = app.UserName
 	data.Password = app.Password
 	data.ServiceName = app.ServiceName
@@ -195,7 +190,7 @@ func (a *AppInstallService) LoadConnInfo(req dto.OperationWithNameAndType) (resp
 	return data, nil
 }
 
-func (a *AppInstallService) SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstallDTO, error) {
+func (a *AppInstallService) SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstalledDTO, error) {
 	var (
 		installs []model.AppInstall
 		err      error
@@ -225,7 +220,7 @@ func (a *AppInstallService) SearchForWebsite(req request.AppInstalledSearch) ([]
 		}
 	}
 
-	return handleInstalled(installs, false, true)
+	return handleInstalled(installs, false)
 }
 
 func (a *AppInstallService) Operate(req request.AppInstalledOperate) error {
@@ -245,35 +240,28 @@ func (a *AppInstallService) Operate(req request.AppInstalledOperate) error {
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncAppInstallStatus(&install, false)
+		return syncAppInstallStatus(&install)
 	case constant.Stop:
 		out, err := compose.Stop(dockerComposePath)
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncAppInstallStatus(&install, false)
+		return syncAppInstallStatus(&install)
 	case constant.Restart:
 		out, err := compose.Restart(dockerComposePath)
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncAppInstallStatus(&install, false)
+		return syncAppInstallStatus(&install)
 	case constant.Delete:
 		if err := deleteAppInstall(install, req.DeleteBackup, req.ForceDelete, req.DeleteDB); err != nil && !req.ForceDelete {
 			return err
 		}
 		return nil
 	case constant.Sync:
-		return syncAppInstallStatus(&install, true)
+		return syncAppInstallStatus(&install)
 	case constant.Upgrade:
-		upgradeReq := request.AppInstallUpgrade{
-			InstallID:     install.ID,
-			DetailID:      req.DetailId,
-			Backup:        req.Backup,
-			PullImage:     req.PullImage,
-			DockerCompose: req.DockerCompose,
-		}
-		return upgradeInstall(upgradeReq)
+		return upgradeInstall(install.ID, req.DetailId, req.Backup, req.PullImage)
 	case constant.Reload:
 		return opNginx(install.ContainerName, constant.NginxReload)
 	default:
@@ -432,7 +420,7 @@ func (a *AppInstallService) SyncAll(systemInit bool) error {
 			continue
 		}
 		if !systemInit {
-			if err = syncAppInstallStatus(&i, false); err != nil {
+			if err = syncAppInstallStatus(&i); err != nil {
 				global.LOG.Errorf("sync install app[%s] error,mgs: %s", i.Name, err.Error())
 			}
 		}
@@ -495,8 +483,8 @@ func (a *AppInstallService) GetServices(key string) ([]response.AppService, erro
 	return res, nil
 }
 
-func (a *AppInstallService) GetUpdateVersions(req request.AppUpdateVersion) ([]dto.AppVersion, error) {
-	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(req.AppInstallID))
+func (a *AppInstallService) GetUpdateVersions(installId uint) ([]dto.AppVersion, error) {
+	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(installId))
 	var versions []dto.AppVersion
 	if err != nil {
 		return versions, err
@@ -517,34 +505,9 @@ func (a *AppInstallService) GetUpdateVersions(req request.AppUpdateVersion) ([]d
 			continue
 		}
 		if common.CompareVersion(detail.Version, install.Version) {
-			var newCompose string
-			if req.UpdateVersion != "" && req.UpdateVersion == detail.Version && detail.DockerCompose == "" && !app.IsLocalApp() {
-				filename := filepath.Base(detail.DownloadUrl)
-				dockerComposeUrl := fmt.Sprintf("%s%s", strings.TrimSuffix(detail.DownloadUrl, filename), "docker-compose.yml")
-				statusCode, composeRes, err := httpUtil.HandleGet(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
-				if err != nil {
-					return versions, err
-				}
-				if statusCode > 200 {
-					return versions, err
-				}
-				detail.DockerCompose = string(composeRes)
-				_ = appDetailRepo.Update(context.Background(), detail)
-			}
-			newCompose, err = getUpgradeCompose(install, detail)
-			if err != nil {
-				return versions, err
-			}
-			if app.Key == constant.AppMysql {
-				majorVersion := getMajorVersion(install.Version)
-				if !strings.HasPrefix(detail.Version, majorVersion) {
-					continue
-				}
-			}
 			versions = append(versions, dto.AppVersion{
-				Version:       detail.Version,
-				DetailId:      detail.ID,
-				DockerCompose: newCompose,
+				Version:  detail.Version,
+				DetailId: detail.ID,
 			})
 		}
 	}
@@ -709,22 +672,6 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 					}
 				}
 				appParam.Values = form.Values
-			} else if form.Type == "apps" {
-				if m, ok := form.Child.(map[string]interface{}); ok {
-					result := make(map[string]string)
-					for key, value := range m {
-						if strVal, ok := value.(string); ok {
-							result[key] = strVal
-						}
-					}
-					if envKey, ok := result["envKey"]; ok {
-						serviceName := envs[envKey]
-						if serviceName != nil {
-							appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithServiceName(serviceName.(string)))
-							appParam.ShowValue = appInstall.Name
-						}
-					}
-				}
 			}
 			params = append(params, appParam)
 		} else {
@@ -753,30 +700,81 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	return &res, nil
 }
 
-func syncAppInstallStatus(appInstall *model.AppInstall, force bool) error {
+func syncAppInstallStatus(appInstall *model.AppInstall) error {
 	if appInstall.Status == constant.Installing || appInstall.Status == constant.Rebuilding || appInstall.Status == constant.Upgrading {
 		return nil
 	}
+	containerNames, err := getContainerNames(*appInstall)
+	if err != nil {
+		return err
+	}
 	cli, err := docker.NewClient()
 	if err != nil {
 		return err
 	}
-	defer cli.Close()
-
-	var (
-		containers     []types.Container
-		containersMap  map[string]types.Container
-		containerNames = strings.Split(appInstall.ContainerName, ",")
-	)
-	containers, err = cli.ListContainersByName(containerNames)
+	containers, err := cli.ListContainersByName(containerNames)
 	if err != nil {
 		return err
 	}
-	containersMap = make(map[string]types.Container)
+
+	var (
+		runningCount         int
+		exitedCount          int
+		pausedCount          int
+		exitedContainerNames []string
+		total                = len(containerNames)
+		count                = len(containers)
+	)
+
+	foundNames := make(map[string]bool)
 	for _, con := range containers {
-		containersMap[con.Names[0]] = con
+		foundNames[con.Names[0]] = true
+		switch con.State {
+		case "exited":
+			exitedContainerNames = append(exitedContainerNames, strings.TrimPrefix(con.Names[0], "/"))
+			exitedCount++
+		case "running":
+			runningCount++
+		case "paused":
+			pausedCount++
+		}
 	}
-	synAppInstall(containersMap, appInstall, force)
+
+	var notFoundNames []string
+	for _, name := range containerNames {
+		if !foundNames["/"+name] {
+			notFoundNames = append(notFoundNames, name)
+		}
+	}
+
+	switch {
+	case count == 0:
+		if appInstall.Status != constant.Error {
+			appInstall.Status = constant.SyncErr
+			appInstall.Message = buserr.WithName("ErrContainerNotFound", strings.Join(containerNames, ",")).Error()
+		}
+	case exitedCount == total:
+		appInstall.Status = constant.Stopped
+	case runningCount == total:
+		appInstall.Status = constant.Running
+	case pausedCount == total:
+		appInstall.Status = constant.Paused
+	default:
+		var msg string
+		if exitedCount > 0 {
+			msg = buserr.WithName("ErrContainerMsg", strings.Join(exitedContainerNames, ",")).Error()
+		}
+		if len(notFoundNames) > 0 {
+			msg += buserr.WithName("ErrContainerNotFound", strings.Join(notFoundNames, ",")).Error()
+		}
+		if msg == "" {
+			msg = buserr.New("ErrAppWarn").Error()
+		}
+		appInstall.Message = msg
+		appInstall.Status = constant.UnHealthy
+	}
+	_ = appInstallRepo.Save(context.Background(), appInstall)
+
 	return nil
 }
 
@@ -804,7 +802,7 @@ func updateInstallInfoInDB(appKey, appName, param string, value interface{}) err
 		}
 	case "port":
 		envKey = "PANEL_APP_PORT_HTTP="
-	default:
+	case "user-password":
 		envKey = "PANEL_DB_USER_PASSWORD="
 	}
 	files := strings.Split(string(lineBytes), "\n")

backend/app/service/app_utils.go

@@ -5,6 +5,8 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/utils/xpack"
+	"github.com/docker/docker/api/types/container"
 	"math"
 	"net/http"
 	"os"
@@ -14,13 +16,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"time"
-
-	"github.com/docker/docker/api/types"
-
-	httpUtil "github.com/1Panel-dev/1Panel/backend/utils/http"
-	"github.com/1Panel-dev/1Panel/backend/utils/xpack"
-	"github.com/docker/docker/api/types/container"
 
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 
@@ -42,7 +37,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
-	"github.com/1Panel-dev/1Panel/backend/utils/docker"
 	composeV2 "github.com/1Panel-dev/1Panel/backend/utils/docker"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/pkg/errors"
@@ -186,18 +180,17 @@ func createLink(ctx context.Context, app model.App, appInstall *model.AppInstall
 			}
 		case constant.AppRedis:
 			if password, ok := params["PANEL_REDIS_ROOT_PASSWORD"]; ok {
-				authParam := dto.RedisAuthParam{
-					RootPassword: "",
-				}
 				if password != "" {
-					authParam.RootPassword = password.(string)
-					database.Password = password.(string)
+					authParam := dto.RedisAuthParam{
+						RootPassword: password.(string),
+					}
+					authByte, err := json.Marshal(authParam)
+					if err != nil {
+						return err
+					}
+					appInstall.Param = string(authByte)
 				}
-				authByte, err := json.Marshal(authParam)
-				if err != nil {
-					return err
-				}
-				appInstall.Param = string(authByte)
+				database.Password = password.(string)
 			}
 		}
 		if err := databaseRepo.Create(ctx, database); err != nil {
@@ -442,65 +435,12 @@ func deleteLink(ctx context.Context, install *model.AppInstall, deleteDB bool, f
 	return appInstallResourceRepo.DeleteBy(ctx, appInstallResourceRepo.WithAppInstallId(install.ID))
 }
 
-func getUpgradeCompose(install model.AppInstall, detail model.AppDetail) (string, error) {
-	if detail.DockerCompose == "" {
-		return "", nil
-	}
-	composeMap := make(map[string]interface{})
-	if err := yaml.Unmarshal([]byte(detail.DockerCompose), &composeMap); err != nil {
-		return "", err
-	}
-	value, ok := composeMap["services"]
-	if !ok || value == nil {
-		return "", buserr.New(constant.ErrFileParse)
-	}
-	servicesMap := value.(map[string]interface{})
-	if len(servicesMap) == 1 {
-		index := 0
-		oldServiceName := ""
-		for k := range servicesMap {
-			oldServiceName = k
-			index++
-			if index > 0 {
-				break
-			}
-		}
-		servicesMap[install.ServiceName] = servicesMap[oldServiceName]
-		if install.ServiceName != oldServiceName {
-			delete(servicesMap, oldServiceName)
-		}
-	}
-	envs := make(map[string]interface{})
-	if err := json.Unmarshal([]byte(install.Env), &envs); err != nil {
-		return "", err
-	}
-	config := getAppCommonConfig(envs)
-	if config.ContainerName == "" {
-		config.ContainerName = install.ContainerName
-		envs[constant.ContainerName] = install.ContainerName
-	}
-	config.Advanced = true
-	if err := addDockerComposeCommonParam(composeMap, install.ServiceName, config, envs); err != nil {
-		return "", err
-	}
-	paramByte, err := json.Marshal(envs)
-	if err != nil {
-		return "", err
-	}
-	install.Env = string(paramByte)
-	composeByte, err := yaml.Marshal(composeMap)
-	if err != nil {
-		return "", err
-	}
-	return string(composeByte), nil
-}
-
-func upgradeInstall(req request.AppInstallUpgrade) error {
-	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(req.InstallID))
+func upgradeInstall(installID uint, detailID uint, backup, pullImage bool) error {
+	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(installID))
 	if err != nil {
 		return err
 	}
-	detail, err := appDetailRepo.GetFirst(commonRepo.WithByID(req.DetailID))
+	detail, err := appDetailRepo.GetFirst(commonRepo.WithByID(detailID))
 	if err != nil {
 		return err
 	}
@@ -510,81 +450,43 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 	install.Status = constant.Upgrading
 
 	go func() {
-		var (
-			upErr      error
-			backupFile string
-			preErr     error
-		)
-		global.LOG.Infof(i18n.GetMsgWithName("UpgradeAppStart", install.Name, nil))
-		if req.Backup {
-			iBackUpService := NewIBackupService()
-			fileName := fmt.Sprintf("upgrade_backup_%s_%s.tar.gz", install.Name, time.Now().Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
-			backupRecord, err := iBackUpService.AppBackup(dto.CommonBackup{Name: install.App.Key, DetailName: install.Name, FileName: fileName})
-			if err == nil {
-				backups, _ := iBackUpService.ListAppRecords(install.App.Key, install.Name, "upgrade_backup")
-				if len(backups) > 3 {
-					backupsToDelete := backups[:len(backups)-3]
-					var deleteIDs []uint
-					for _, backup := range backupsToDelete {
-						deleteIDs = append(deleteIDs, backup.ID)
-					}
-					_ = iBackUpService.BatchDeleteRecord(deleteIDs)
-				}
-				localDir, err := loadLocalDir()
-				if err == nil {
-					backupFile = path.Join(localDir, backupRecord.FileDir, backupRecord.FileName)
-				} else {
-					global.LOG.Errorf(i18n.GetMsgWithName("ErrAppBackup", install.Name, err))
-				}
-			} else {
-				global.LOG.Errorf(i18n.GetMsgWithName("ErrAppBackup", install.Name, err))
+		if backup {
+			if err = NewIBackupService().AppBackup(dto.CommonBackup{Name: install.App.Key, DetailName: install.Name}); err != nil {
+				global.LOG.Errorf(i18n.GetMsgWithMap("ErrAppBackup", map[string]interface{}{"name": install.Name, "err": err.Error()}))
 			}
 		}
+		var upErr error
 
 		defer func() {
 			if upErr != nil {
-				global.LOG.Infof(i18n.GetMsgWithName("ErrAppUpgrade", install.Name, upErr))
-				if req.Backup {
-					global.LOG.Infof(i18n.GetMsgWithName("AppRecover", install.Name, nil))
-					if err := NewIBackupService().AppRecover(dto.CommonRecover{Name: install.App.Key, DetailName: install.Name, Type: "app", Source: constant.ResourceLocal, File: backupFile}); err != nil {
+				if backup {
+					if err := NewIBackupService().AppRecover(dto.CommonRecover{Name: install.App.Key, DetailName: install.Name, Type: "app", Source: constant.ResourceLocal}); err != nil {
 						global.LOG.Errorf("recover app [%s] [%s] failed %v", install.App.Key, install.Name, err)
 					}
 				}
-				existInstall, _ := appInstallRepo.GetFirst(commonRepo.WithByID(req.InstallID))
-				if existInstall.ID > 0 {
-					existInstall.Status = constant.UpgradeErr
-					existInstall.Message = upErr.Error()
-					_ = appInstallRepo.Save(context.Background(), &existInstall)
-				}
-			}
-			if preErr != nil {
-				global.LOG.Infof(i18n.GetMsgWithName("ErrAppUpgrade", install.Name, preErr))
-				existInstall, _ := appInstallRepo.GetFirst(commonRepo.WithByID(req.InstallID))
-				if existInstall.ID > 0 {
-					existInstall.Status = constant.UpgradeErr
-					existInstall.Message = preErr.Error()
-					_ = appInstallRepo.Save(context.Background(), &existInstall)
-				}
+				install.Status = constant.UpgradeErr
+				install.Message = upErr.Error()
+				_ = appInstallRepo.Save(context.Background(), &install)
 			}
 		}()
 
 		fileOp := files.NewFileOp()
 		detailDir := path.Join(constant.ResourceDir, "apps", install.App.Resource, install.App.Key, detail.Version)
 		if install.App.Resource == constant.AppResourceRemote {
-			if preErr = downloadApp(install.App, detail, &install); preErr != nil {
+			if upErr = downloadApp(install.App, detail, &install); upErr != nil {
 				return
 			}
 			if detail.DockerCompose == "" {
 				composeDetail, err := fileOp.GetContent(path.Join(detailDir, "docker-compose.yml"))
 				if err != nil {
-					preErr = err
+					upErr = err
 					return
 				}
 				detail.DockerCompose = string(composeDetail)
 				_ = appDetailRepo.Update(context.Background(), detail)
 			}
 			go func() {
-				_, _, _ = httpUtil.HandleGet(detail.DownloadCallBackUrl, http.MethodGet, constant.TimeOut5s)
+				_, _ = http.Get(detail.DownloadCallBackUrl)
 			}()
 		}
 
@@ -592,32 +494,6 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 			detailDir = path.Join(constant.ResourceDir, "apps", "local", strings.TrimPrefix(install.App.Key, "local"), detail.Version)
 		}
 
-		content, err := fileOp.GetContent(install.GetEnvPath())
-		if err != nil {
-			preErr = err
-			return
-		}
-		if req.PullImage {
-			projectName := strings.ToLower(install.Name)
-			images, err := composeV2.GetDockerComposeImages(projectName, content, []byte(detail.DockerCompose))
-			if err != nil {
-				preErr = err
-				return
-			}
-			for _, image := range images {
-				global.LOG.Infof(i18n.GetMsgWithName("PullImageStart", image, nil))
-				if out, err := cmd.ExecWithTimeOut("docker pull "+image, 20*time.Minute); err != nil {
-					if out != "" {
-						err = errors.New(out)
-					}
-					preErr = buserr.WithNameAndErr("ErrDockerPullImage", "", err)
-					return
-				} else {
-					global.LOG.Infof(i18n.GetMsgByKey("PullImageSuccess"))
-				}
-			}
-		}
-
 		command := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -rn %s/* %s || true", detailDir, install.GetPath()))
 		stdout, _ := command.CombinedOutput()
 		if stdout != nil {
@@ -632,42 +508,100 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 			_, _ = scriptCmd.CombinedOutput()
 		}
 
-		var newCompose string
-		if req.DockerCompose == "" {
-			newCompose, upErr = getUpgradeCompose(install, detail)
-			if upErr != nil {
-				return
+		composeMap := make(map[string]interface{})
+		if upErr = yaml.Unmarshal([]byte(detail.DockerCompose), &composeMap); upErr != nil {
+			return
+		}
+		value, ok := composeMap["services"]
+		if !ok {
+			upErr = buserr.New(constant.ErrFileParse)
+			return
+		}
+		servicesMap := value.(map[string]interface{})
+		if len(servicesMap) == 1 {
+			index := 0
+			oldServiceName := ""
+			for k := range servicesMap {
+				oldServiceName = k
+				index++
+				if index > 0 {
+					break
+				}
 			}
-		} else {
-			newCompose = req.DockerCompose
+			servicesMap[install.ServiceName] = servicesMap[oldServiceName]
+			if install.ServiceName != oldServiceName {
+				delete(servicesMap, oldServiceName)
+			}
+		}
+		envs := make(map[string]interface{})
+		if upErr = json.Unmarshal([]byte(install.Env), &envs); upErr != nil {
+			return
+		}
+		config := getAppCommonConfig(envs)
+		if config.ContainerName == "" {
+			config.ContainerName = install.ContainerName
+			envs[constant.ContainerName] = install.ContainerName
+		}
+		config.Advanced = true
+		if upErr = addDockerComposeCommonParam(composeMap, install.ServiceName, config, envs); upErr != nil {
+			return
+		}
+		paramByte, upErr := json.Marshal(envs)
+		if upErr != nil {
+			return
+		}
+		install.Env = string(paramByte)
+		composeByte, upErr := yaml.Marshal(composeMap)
+		if upErr != nil {
+			return
 		}
 
-		install.DockerCompose = newCompose
+		install.DockerCompose = string(composeByte)
 		install.Version = detail.Version
-		install.AppDetailId = req.DetailID
+		install.AppDetailId = detailID
 
 		if out, err := compose.Down(install.GetComposePath()); err != nil {
 			if out != "" {
 				upErr = errors.New(out)
 				return
 			}
-			upErr = err
-			return
-		}
-		envs := make(map[string]interface{})
-		if upErr = json.Unmarshal([]byte(install.Env), &envs); upErr != nil {
 			return
 		}
 		envParams := make(map[string]string, len(envs))
 		handleMap(envs, envParams)
-		if upErr = env.Write(envParams, install.GetEnvPath()); upErr != nil {
+		if err = env.Write(envParams, install.GetEnvPath()); err != nil {
 			return
 		}
 
-		if upErr = runScript(&install, "upgrade"); upErr != nil {
+		if err = runScript(&install, "upgrade"); err != nil {
 			return
 		}
 
+		content, err := fileOp.GetContent(install.GetEnvPath())
+		if err != nil {
+			upErr = err
+			return
+		}
+
+		if pullImage {
+			images, err := composeV2.GetDockerComposeImages(install.Name, content, []byte(detail.DockerCompose))
+			if err != nil {
+				upErr = err
+				return
+			}
+			dockerCli, err := composeV2.NewClient()
+			if err != nil {
+				upErr = err
+				return
+			}
+			for _, image := range images {
+				if err = dockerCli.PullImage(image, true); err != nil {
+					upErr = buserr.WithNameAndErr("ErrDockerPullImage", "", err)
+					return
+				}
+			}
+		}
+
 		if upErr = fileOp.WriteFile(install.GetComposePath(), strings.NewReader(install.DockerCompose), 0775); upErr != nil {
 			return
 		}
@@ -681,7 +615,6 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		}
 		install.Status = constant.Running
 		_ = appInstallRepo.Save(context.Background(), &install)
-		global.LOG.Infof(i18n.GetMsgWithName("UpgradeAppSuccess", install.Name, nil))
 	}()
 
 	return appInstallRepo.Save(context.Background(), &install)
@@ -798,11 +731,11 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App
 		}
 	}()
 
-	if err = fileOp.DownloadFileWithProxy(appDetail.DownloadUrl, filePath); err != nil {
+	if err = fileOp.DownloadFile(appDetail.DownloadUrl, filePath); err != nil {
 		global.LOG.Errorf("download app[%s] error %v", app.Name, err)
 		return
 	}
-	if err = fileOp.Decompress(filePath, appResourceDir, files.SdkTarGz, ""); err != nil {
+	if err = fileOp.Decompress(filePath, appResourceDir, files.SdkTarGz); err != nil {
 		global.LOG.Errorf("decompress app[%s] error %v", app.Name, err)
 		return
 	}
@@ -822,7 +755,7 @@ func copyData(app model.App, appDetail model.AppDetail, appInstall *model.AppIns
 			return
 		}
 		go func() {
-			_, _, _ = httpUtil.HandleGet(appDetail.DownloadCallBackUrl, http.MethodGet, constant.TimeOut5s)
+			_, _ = http.Get(appDetail.DownloadCallBackUrl)
 		}()
 	}
 	appKey := app.Key
@@ -896,7 +829,6 @@ func checkContainerNameIsExist(containerName, appDir string) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	defer client.Close()
 	var options container.ListOptions
 	list, err := client.ContainerList(context.Background(), options)
 	if err != nil {
@@ -949,19 +881,12 @@ func upApp(appInstall *model.AppInstall, pullImages bool) {
 		return
 	}
 	if err := upProject(appInstall); err != nil {
-		appInstall.Status = constant.UpErr
+		appInstall.Status = constant.Error
 	} else {
 		appInstall.Status = constant.Running
 	}
 	exist, _ := appInstallRepo.GetFirst(commonRepo.WithByID(appInstall.ID))
 	if exist.ID > 0 {
-		containerNames, err := getContainerNames(*appInstall)
-		if err != nil {
-			return
-		}
-		if len(containerNames) > 0 {
-			appInstall.ContainerName = strings.Join(containerNames, ",")
-		}
 		_ = appInstallRepo.Save(context.Background(), appInstall)
 	}
 }
@@ -981,12 +906,6 @@ func rebuildApp(appInstall model.AppInstall) error {
 			_ = handleErr(appInstall, err, out)
 			return
 		}
-		containerNames, err := getContainerNames(appInstall)
-		if err != nil {
-			_ = handleErr(appInstall, err, out)
-			return
-		}
-		appInstall.ContainerName = strings.Join(containerNames, ",")
 
 		appInstall.Status = constant.Running
 		_ = appInstallRepo.Save(context.Background(), &appInstall)
@@ -1164,156 +1083,24 @@ func handleErr(install model.AppInstall, err error, out string) error {
 		install.Message = out
 		reErr = errors.New(out)
 	}
-	install.Status = constant.UpErr
+	install.Status = constant.Error
 	_ = appInstallRepo.Save(context.Background(), &install)
 	return reErr
 }
 
-func doNotNeedSync(installed model.AppInstall) bool {
-	return installed.Status == constant.Installing || installed.Status == constant.Rebuilding || installed.Status == constant.Upgrading ||
-		installed.Status == constant.Syncing
-}
-
-func synAppInstall(containers map[string]types.Container, appInstall *model.AppInstall, force bool) {
-	containerNames := strings.Split(appInstall.ContainerName, ",")
-	if len(containers) == 0 {
-		if appInstall.Status == constant.UpErr && !force {
-			return
-		}
-		appInstall.Status = constant.Error
-		appInstall.Message = buserr.WithName("ErrContainerNotFound", strings.Join(containerNames, ",")).Error()
-		_ = appInstallRepo.Save(context.Background(), appInstall)
-		return
-	}
-	notFoundNames := make([]string, 0)
-	exitNames := make([]string, 0)
-	exitedCount := 0
-	pausedCount := 0
-	runningCount := 0
-	total := len(containerNames)
-	for _, name := range containerNames {
-		if con, ok := containers["/"+name]; ok {
-			switch con.State {
-			case "exited":
-				exitedCount++
-				exitNames = append(exitNames, name)
-			case "running":
-				runningCount++
-			case "paused":
-				pausedCount++
-			}
-		} else {
-			notFoundNames = append(notFoundNames, name)
-		}
-	}
-	switch {
-	case exitedCount == total:
-		appInstall.Status = constant.Stopped
-	case runningCount == total:
-		appInstall.Status = constant.Running
-	case pausedCount == total:
-		appInstall.Status = constant.Paused
-	case len(notFoundNames) == total:
-		if appInstall.Status == constant.UpErr && !force {
-			return
-		}
-		appInstall.Status = constant.Error
-		appInstall.Message = buserr.WithName("ErrContainerNotFound", strings.Join(notFoundNames, ",")).Error()
-	default:
-		var msg string
-		if exitedCount > 0 {
-			msg = buserr.WithName("ErrContainerMsg", strings.Join(exitNames, ",")).Error()
-		}
-		if len(notFoundNames) > 0 {
-			msg += buserr.WithName("ErrContainerNotFound", strings.Join(notFoundNames, ",")).Error()
-		}
-		if msg == "" {
-			msg = buserr.New("ErrAppWarn").Error()
-		}
-		appInstall.Message = msg
-		appInstall.Status = constant.UnHealthy
-	}
-	_ = appInstallRepo.Save(context.Background(), appInstall)
-}
-
-func getMajorVersion(version string) string {
-	parts := strings.Split(version, ".")
-	if len(parts) >= 2 {
-		return parts[0] + "." + parts[1]
-	}
-	return version
-}
-
-func ignoreUpdate(installed model.AppInstall) bool {
-	if installed.App.Type == "php" || installed.Status == constant.Installing {
-		return true
-	}
-	if installed.App.Key == constant.AppMysql {
-		majorVersion := getMajorVersion(installed.Version)
-		appDetails, _ := appDetailRepo.GetBy(appDetailRepo.WithAppId(installed.App.ID))
-		for _, appDetail := range appDetails {
-			if strings.HasPrefix(appDetail.Version, majorVersion) && common.CompareVersion(appDetail.Version, installed.Version) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
-}
-
-func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool) ([]response.AppInstallDTO, error) {
-	var (
-		res           []response.AppInstallDTO
-		containersMap map[string]types.Container
-	)
-	if sync {
-		cli, err := docker.NewClient()
-		if err != nil {
-			return nil, err
-		}
-		defer cli.Close()
-		containers, err := cli.ListAllContainers()
-		if err != nil {
-			return nil, err
-		}
-		containersMap = make(map[string]types.Container, len(containers))
-		for _, contain := range containers {
-			containersMap[contain.Names[0]] = contain
-		}
-	}
-
+func handleInstalled(appInstallList []model.AppInstall, updated bool) ([]response.AppInstalledDTO, error) {
+	var res []response.AppInstalledDTO
 	for _, installed := range appInstallList {
-		if updated && ignoreUpdate(installed) {
+		if updated && (installed.App.Type == "php" || installed.Status == constant.Installing || (installed.App.Key == constant.AppMysql && installed.Version == "5.6.51")) {
 			continue
 		}
-		if sync && !doNotNeedSync(installed) {
-			synAppInstall(containersMap, &installed, false)
+		if err := syncAppInstallStatus(&installed); err != nil {
+			global.LOG.Error("sync app install status error : ", err)
 		}
 
-		installDTO := response.AppInstallDTO{
-			ID:          installed.ID,
-			Name:        installed.Name,
-			AppID:       installed.AppId,
-			AppDetailID: installed.AppDetailId,
-			Version:     installed.Version,
-			Status:      installed.Status,
-			Message:     installed.Message,
-			HttpPort:    installed.HttpPort,
-			HttpsPort:   installed.HttpsPort,
-			Icon:        installed.App.Icon,
-			AppName:     installed.App.Name,
-			AppKey:      installed.App.Key,
-			AppType:     installed.App.Type,
-			Path:        installed.GetPath(),
-			CreatedAt:   installed.CreatedAt,
-			App: response.AppDetail{
-				Github:   installed.App.Github,
-				Website:  installed.App.Website,
-				Document: installed.App.Document,
-			},
-		}
-		if updated {
-			installDTO.DockerCompose = installed.DockerCompose
+		installDTO := response.AppInstalledDTO{
+			AppInstall: installed,
+			Path:       installed.GetPath(),
 		}
 		app, err := appRepo.GetFirst(commonRepo.WithByID(installed.AppId))
 		if err != nil {

backend/app/service/backup.go

@@ -37,10 +37,8 @@ type IBackupService interface {
 	GetBuckets(backupDto dto.ForBuckets) ([]interface{}, error)
 	Update(ireq dto.BackupOperate) error
 	Delete(id uint) error
-	DeleteRecordByName(backupType, name, detailName string, withDeleteFile bool) error
 	BatchDeleteRecord(ids []uint) error
 	NewClient(backup *model.BackupAccount) (cloud_storage.CloudStorageClient, error)
-	ListAppRecords(name, detailName, fileName string) ([]model.BackupRecord, error)
 
 	ListFiles(req dto.BackupSearchFile) []string
 
@@ -51,13 +49,13 @@ type IBackupService interface {
 	MysqlRecoverByUpload(req dto.CommonRecover) error
 	PostgresqlRecoverByUpload(req dto.CommonRecover) error
 
-	RedisBackup(db dto.CommonBackup) error
+	RedisBackup() error
 	RedisRecover(db dto.CommonRecover) error
 
 	WebsiteBackup(db dto.CommonBackup) error
 	WebsiteRecover(req dto.CommonRecover) error
 
-	AppBackup(db dto.CommonBackup) (*model.BackupRecord, error)
+	AppBackup(db dto.CommonBackup) error
 	AppRecover(req dto.CommonRecover) error
 
 	Run()
@@ -101,20 +99,6 @@ func (u *BackupService) SearchRecordsWithPage(search dto.RecordSearch) (int64, [
 	return total, datas, err
 }
 
-func (u *BackupService) ListAppRecords(name, detailName, fileName string) ([]model.BackupRecord, error) {
-	records, err := backupRepo.ListRecord(
-		commonRepo.WithOrderBy("created_at asc"),
-		commonRepo.WithByName(name),
-		commonRepo.WithByType("app"),
-		backupRepo.WithFileNameStartWith(fileName),
-		backupRepo.WithByDetailName(detailName),
-	)
-	if err != nil {
-		return nil, err
-	}
-	return records, err
-}
-
 func (u *BackupService) SearchRecordsByCronjobWithPage(search dto.RecordSearchByCronjob) (int64, []dto.BackupRecords, error) {
 	total, records, err := backupRepo.PageRecord(
 		search.Page, search.PageSize,
@@ -276,35 +260,6 @@ func (u *BackupService) Delete(id uint) error {
 	return backupRepo.Delete(commonRepo.WithByID(id))
 }
 
-func (u *BackupService) DeleteRecordByName(backupType, name, detailName string, withDeleteFile bool) error {
-	if !withDeleteFile {
-		return backupRepo.DeleteRecord(context.Background(), commonRepo.WithByType(backupType), commonRepo.WithByName(name), backupRepo.WithByDetailName(detailName))
-	}
-
-	records, err := backupRepo.ListRecord(commonRepo.WithByType(backupType), commonRepo.WithByName(name), backupRepo.WithByDetailName(detailName))
-	if err != nil {
-		return err
-	}
-
-	for _, record := range records {
-		backupAccount, err := backupRepo.Get(commonRepo.WithByType(record.Source))
-		if err != nil {
-			global.LOG.Errorf("load backup account %s info from db failed, err: %v", record.Source, err)
-			continue
-		}
-		client, err := u.NewClient(&backupAccount)
-		if err != nil {
-			global.LOG.Errorf("new client for backup account %s failed, err: %v", record.Source, err)
-			continue
-		}
-		if _, err = client.Delete(path.Join(record.FileDir, record.FileName)); err != nil {
-			global.LOG.Errorf("remove file %s from %s failed, err: %v", path.Join(record.FileDir, record.FileName), record.Source, err)
-		}
-		_ = backupRepo.DeleteRecord(context.Background(), commonRepo.WithByID(record.ID))
-	}
-	return nil
-}
-
 func (u *BackupService) BatchDeleteRecord(ids []uint) error {
 	records, err := backupRepo.ListRecord(commonRepo.WithIdsIn(ids))
 	if err != nil {
@@ -379,7 +334,7 @@ func (u *BackupService) Update(req dto.BackupOperate) error {
 					dirStr = dirStr[:strings.LastIndex(dirStr, "/")]
 				}
 				if err := copyDir(oldDir, dirStr); err != nil {
-					_ = backupRepo.Update(req.ID, map[string]interface{}{"vars": oldVars})
+					_ = backupRepo.Update(req.ID, (map[string]interface{}{"vars": oldVars}))
 					return err
 				}
 				global.CONF.System.Backup = dirStr
@@ -429,6 +384,8 @@ func (u *BackupService) NewClient(backup *model.BackupAccount) (cloud_storage.Cl
 	case constant.OSS, constant.S3, constant.MinIo, constant.Cos, constant.Kodo:
 		varMap["accessKey"] = backup.AccessKey
 		varMap["secretKey"] = backup.Credential
+	case constant.OneDrive:
+		varMap["accessToken"] = backup.Credential
 	}
 
 	backClient, err := cloud_storage.NewCloudStorageClient(backup.Type, varMap)
@@ -466,13 +423,14 @@ func (u *BackupService) loadAccessToken(backup *model.BackupAccount) error {
 	if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
 		return fmt.Errorf("unmarshal backup vars failed, err: %v", err)
 	}
-	refreshToken, err := client.RefreshToken("authorization_code", "refreshToken", varMap)
+	token, refreshToken, err := client.RefreshToken("authorization_code", varMap)
 	if err != nil {
 		return err
 	}
 	delete(varMap, "code")
+	backup.Credential = token
 	varMap["refresh_status"] = constant.StatusSuccess
-	varMap["refresh_time"] = time.Now().Format(constant.DateTimeLayout)
+	varMap["refresh_time"] = time.Now().Format("2006-01-02 15:04:05")
 	varMap["refresh_token"] = refreshToken
 	itemVars, err := json.Marshal(varMap)
 	if err != nil {
@@ -599,10 +557,10 @@ func (u *BackupService) checkBackupConn(backup *model.BackupAccount) (bool, erro
 	}
 	defer file.Close()
 	write := bufio.NewWriter(file)
-	_, _ = write.WriteString("1Panel 备份账号测试文件。\n")
-	_, _ = write.WriteString("1Panel 備份賬號測試文件。\n")
-	_, _ = write.WriteString("1Panel Backs up account test files.\n")
-	_, _ = write.WriteString("1Panelアカウントのテストファイルをバックアップします。\n")
+	_, _ = write.WriteString(string("1Panel 备份账号测试文件。\n"))
+	_, _ = write.WriteString(string("1Panel 備份賬號測試文件。\n"))
+	_, _ = write.WriteString(string("1Panel Backs up account test files.\n"))
+	_, _ = write.WriteString(string("1Panelアカウントのテストファイルをバックアップします。\n"))
 	write.Flush()
 
 	targetPath := strings.TrimPrefix(path.Join(backup.BackupPath, "test/1panel"), "/")
@@ -611,7 +569,7 @@ func (u *BackupService) checkBackupConn(backup *model.BackupAccount) (bool, erro
 
 func StartRefreshOneDriveToken() {
 	service := NewIBackupService()
-	oneDriveCronID, err := global.Cron.AddJob("0 3 */31 * *", service)
+	oneDriveCronID, err := global.Cron.AddJob("0 * * * *", service)
 	if err != nil {
 		global.LOG.Errorf("can not add OneDrive corn job: %s", err.Error())
 		return
@@ -625,15 +583,19 @@ func (u *BackupService) Run() {
 	if backupItem.ID == 0 {
 		return
 	}
+	if len(backupItem.Credential) == 0 {
+		global.LOG.Error("OneDrive configuration lacks token information, please rebind.")
+		return
+	}
 	global.LOG.Info("start to refresh token of OneDrive ...")
 	varMap := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(backupItem.Vars), &varMap); err != nil {
 		global.LOG.Errorf("Failed to refresh OneDrive token, please retry, err: %v", err)
 		return
 	}
-	refreshToken, err := client.RefreshToken("refresh_token", "refreshToken", varMap)
+	token, refreshToken, err := client.RefreshToken("refresh_token", varMap)
 	varMap["refresh_status"] = constant.StatusSuccess
-	varMap["refresh_time"] = time.Now().Format(constant.DateTimeLayout)
+	varMap["refresh_time"] = time.Now().Format("2006-01-02 15:04:05")
 	if err != nil {
 		varMap["refresh_status"] = constant.StatusFailed
 		varMap["refresh_msg"] = err.Error()
@@ -646,7 +608,8 @@ func (u *BackupService) Run() {
 	_ = global.DB.Model(&model.BackupAccount{}).
 		Where("id = ?", backupItem.ID).
 		Updates(map[string]interface{}{
-			"vars": varsItem,
+			"credential": token,
+			"vars":       varsItem,
 		}).Error
 	global.LOG.Info("Successfully refreshed OneDrive token.")
 }

backend/app/service/backup_app.go

@@ -22,29 +22,26 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (u *BackupService) AppBackup(req dto.CommonBackup) (*model.BackupRecord, error) {
+func (u *BackupService) AppBackup(req dto.CommonBackup) error {
 	localDir, err := loadLocalDir()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	app, err := appRepo.GetFirst(appRepo.WithKey(req.Name))
 	if err != nil {
-		return nil, err
+		return err
 	}
 	install, err := appInstallRepo.GetFirst(commonRepo.WithByName(req.DetailName), appInstallRepo.WithAppId(app.ID))
 	if err != nil {
-		return nil, err
+		return err
 	}
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
+	timeNow := time.Now().Format("20060102150405")
 	itemDir := fmt.Sprintf("app/%s/%s", req.Name, req.DetailName)
 	backupDir := path.Join(localDir, itemDir)
 
-	fileName := req.FileName
-	if req.FileName == "" {
-		fileName = fmt.Sprintf("%s_%s.tar.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
-	}
-	if err := handleAppBackup(&install, backupDir, fileName, "", req.Secret); err != nil {
-		return nil, err
+	fileName := fmt.Sprintf("%s_%s.tar.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
+	if err := handleAppBackup(&install, backupDir, fileName); err != nil {
+		return err
 	}
 
 	record := &model.BackupRecord{
@@ -59,9 +56,9 @@ func (u *BackupService) AppBackup(req dto.CommonBackup) (*model.BackupRecord, er
 
 	if err := backupRepo.CreateRecord(record); err != nil {
 		global.LOG.Errorf("save backup record failed, err: %v", err)
-		return nil, err
+		return err
 	}
-	return record, nil
+	return nil
 }
 
 func (u *BackupService) AppRecover(req dto.CommonRecover) error {
@@ -81,13 +78,13 @@ func (u *BackupService) AppRecover(req dto.CommonRecover) error {
 	if _, err := compose.Down(install.GetComposePath()); err != nil {
 		return err
 	}
-	if err := handleAppRecover(&install, req.File, false, req.Secret); err != nil {
+	if err := handleAppRecover(&install, req.File, false); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleAppBackup(install *model.AppInstall, backupDir, fileName string, excludes string, secret string) error {
+func handleAppBackup(install *model.AppInstall, backupDir, fileName string) error {
 	fileOp := files.NewFileOp()
 	tmpDir := fmt.Sprintf("%s/%s", backupDir, strings.ReplaceAll(fileName, ".tar.gz", ""))
 	if !fileOp.Stat(tmpDir) {
@@ -106,7 +103,7 @@ func handleAppBackup(install *model.AppInstall, backupDir, fileName string, excl
 	}
 
 	appPath := install.GetPath()
-	if err := handleTar(appPath, tmpDir, "app.tar.gz", excludes, ""); err != nil {
+	if err := handleTar(appPath, tmpDir, "app.tar.gz", ""); err != nil {
 		return err
 	}
 
@@ -132,16 +129,16 @@ func handleAppBackup(install *model.AppInstall, backupDir, fileName string, excl
 		}
 	}
 
-	if err := handleTar(tmpDir, backupDir, fileName, "", secret); err != nil {
+	if err := handleTar(tmpDir, backupDir, fileName, ""); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleAppRecover(install *model.AppInstall, recoverFile string, isRollback bool, secret string) error {
+func handleAppRecover(install *model.AppInstall, recoverFile string, isRollback bool) error {
 	isOk := false
 	fileOp := files.NewFileOp()
-	if err := handleUnTar(recoverFile, path.Dir(recoverFile), secret); err != nil {
+	if err := handleUnTar(recoverFile, path.Dir(recoverFile)); err != nil {
 		return err
 	}
 	tmpPath := strings.ReplaceAll(recoverFile, ".tar.gz", "")
@@ -166,14 +163,14 @@ func handleAppRecover(install *model.AppInstall, recoverFile string, isRollback
 	}
 
 	if !isRollback {
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("app/%s_%s.tar.gz", install.Name, time.Now().Format(constant.DateTimeSlimLayout)))
-		if err := handleAppBackup(install, path.Dir(rollbackFile), path.Base(rollbackFile), "", ""); err != nil {
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("app/%s_%s.tar.gz", install.Name, time.Now().Format("20060102150405")))
+		if err := handleAppBackup(install, path.Dir(rollbackFile), path.Base(rollbackFile)); err != nil {
 			return fmt.Errorf("backup app %s for rollback before recover failed, err: %v", install.Name, err)
 		}
 		defer func() {
 			if !isOk {
 				global.LOG.Info("recover failed, start to rollback now")
-				if err := handleAppRecover(install, rollbackFile, true, secret); err != nil {
+				if err := handleAppRecover(install, rollbackFile, true); err != nil {
 					global.LOG.Errorf("rollback app %s from %s failed, err: %v", install.Name, rollbackFile, err)
 					return
 				}
@@ -254,7 +251,7 @@ func handleAppRecover(install *model.AppInstall, recoverFile string, isRollback
 	_ = fileOp.Rename(appDir, backPath)
 	_ = fileOp.CreateDir(appDir, 0755)
 
-	if err := handleUnTar(tmpPath+"/app.tar.gz", install.GetAppPath(), ""); err != nil {
+	if err := handleUnTar(tmpPath+"/app.tar.gz", install.GetAppPath()); err != nil {
 		global.LOG.Errorf("handle recover from app.tar.gz failed, err: %v", err)
 		_ = fileOp.DeleteDir(appDir)
 		_ = fileOp.Rename(backPath, appDir)

backend/app/service/backup_mysql.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/constant"
 	"os"
 	"path"
 	"path/filepath"
@@ -25,7 +24,7 @@ func (u *BackupService) MysqlBackup(req dto.CommonBackup) error {
 		return err
 	}
 
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
+	timeNow := time.Now().Format("20060102150405")
 	itemDir := fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName)
 	targetDir := path.Join(localDir, itemDir)
 	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
@@ -60,14 +59,14 @@ func (u *BackupService) MysqlRecoverByUpload(req dto.CommonRecover) error {
 	file := req.File
 	fileName := path.Base(req.File)
 	if strings.HasSuffix(fileName, ".tar.gz") {
-		fileNameItem := time.Now().Format(constant.DateTimeSlimLayout)
+		fileNameItem := time.Now().Format("20060102150405")
 		dstDir := fmt.Sprintf("%s/%s", path.Dir(req.File), fileNameItem)
 		if _, err := os.Stat(dstDir); err != nil && os.IsNotExist(err) {
 			if err = os.MkdirAll(dstDir, os.ModePerm); err != nil {
 				return fmt.Errorf("mkdir %s failed, err: %v", dstDir, err)
 			}
 		}
-		if err := handleUnTar(req.File, dstDir, ""); err != nil {
+		if err := handleUnTar(req.File, dstDir); err != nil {
 			_ = os.RemoveAll(dstDir)
 			return err
 		}
@@ -143,7 +142,7 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 	}
 
 	if !isRollback {
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format(constant.DateTimeSlimLayout)))
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format("20060102150405")))
 		if err := cli.Backup(client.BackupInfo{
 			Name:      req.DetailName,
 			Type:      req.Type,

backend/app/service/backup_postgresql.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/constant"
 	"os"
 	"path"
 	"path/filepath"
@@ -26,7 +25,7 @@ func (u *BackupService) PostgresqlBackup(req dto.CommonBackup) error {
 		return err
 	}
 
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
+	timeNow := time.Now().Format("20060102150405")
 	itemDir := fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName)
 	targetDir := path.Join(localDir, itemDir)
 	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
@@ -60,14 +59,14 @@ func (u *BackupService) PostgresqlRecoverByUpload(req dto.CommonRecover) error {
 	file := req.File
 	fileName := path.Base(req.File)
 	if strings.HasSuffix(fileName, ".tar.gz") {
-		fileNameItem := time.Now().Format(constant.DateTimeSlimLayout)
+		fileNameItem := time.Now().Format("20060102150405")
 		dstDir := fmt.Sprintf("%s/%s", path.Dir(req.File), fileNameItem)
 		if _, err := os.Stat(dstDir); err != nil && os.IsNotExist(err) {
 			if err = os.MkdirAll(dstDir, os.ModePerm); err != nil {
 				return fmt.Errorf("mkdir %s failed, err: %v", dstDir, err)
 			}
 		}
-		if err := handleUnTar(req.File, dstDir, ""); err != nil {
+		if err := handleUnTar(req.File, dstDir); err != nil {
 			_ = os.RemoveAll(dstDir)
 			return err
 		}
@@ -137,7 +136,7 @@ func handlePostgresqlRecover(req dto.CommonRecover, isRollback bool) error {
 	defer cli.Close()
 
 	if !isRollback {
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format(constant.DateTimeSlimLayout)))
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format("20060102150405")))
 		if err := cli.Backup(client.BackupInfo{
 			Name:      req.DetailName,
 			TargetDir: path.Dir(rollbackFile),

backend/app/service/backup_redis.go

@@ -20,12 +20,12 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (u *BackupService) RedisBackup(db dto.CommonBackup) error {
+func (u *BackupService) RedisBackup() error {
 	localDir, err := loadLocalDir()
 	if err != nil {
 		return err
 	}
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", db.Name)
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return err
 	}
@@ -35,7 +35,7 @@ func (u *BackupService) RedisBackup(db dto.CommonBackup) error {
 	}
 	global.LOG.Infof("appendonly in redis conf is %s", appendonly)
 
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout) + common.RandStrAndNum(5)
+	timeNow := time.Now().Format("20060102150405") + common.RandStrAndNum(5)
 	fileName := fmt.Sprintf("%s.rdb", timeNow)
 	if appendonly == "yes" {
 		if strings.HasPrefix(redisInfo.Version, "6.") {
@@ -46,12 +46,11 @@ func (u *BackupService) RedisBackup(db dto.CommonBackup) error {
 	}
 	itemDir := fmt.Sprintf("database/redis/%s", redisInfo.Name)
 	backupDir := path.Join(localDir, itemDir)
-	if err := handleRedisBackup(redisInfo, backupDir, fileName, db.Secret); err != nil {
+	if err := handleRedisBackup(redisInfo, backupDir, fileName); err != nil {
 		return err
 	}
 	record := &model.BackupRecord{
 		Type:       "redis",
-		Name:       db.Name,
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
 		FileDir:    itemDir,
@@ -65,18 +64,18 @@ func (u *BackupService) RedisBackup(db dto.CommonBackup) error {
 }
 
 func (u *BackupService) RedisRecover(req dto.CommonRecover) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return err
 	}
 	global.LOG.Infof("recover redis from backup file %s", req.File)
-	if err := handleRedisRecover(redisInfo, req.File, false, req.Secret); err != nil {
+	if err := handleRedisRecover(redisInfo, req.File, false); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleRedisBackup(redisInfo *repo.RootInfo, backupDir, fileName string, secret string) error {
+func handleRedisBackup(redisInfo *repo.RootInfo, backupDir, fileName string) error {
 	fileOp := files.NewFileOp()
 	if !fileOp.Stat(backupDir) {
 		if err := os.MkdirAll(backupDir, os.ModePerm); err != nil {
@@ -91,7 +90,7 @@ func handleRedisBackup(redisInfo *repo.RootInfo, backupDir, fileName string, sec
 
 	if strings.HasSuffix(fileName, ".tar.gz") {
 		redisDataDir := fmt.Sprintf("%s/%s/%s/data/appendonlydir", constant.AppInstallDir, "redis", redisInfo.Name)
-		if err := handleTar(redisDataDir, backupDir, fileName, "", secret); err != nil {
+		if err := handleTar(redisDataDir, backupDir, fileName, ""); err != nil {
 			return err
 		}
 		return nil
@@ -111,7 +110,7 @@ func handleRedisBackup(redisInfo *repo.RootInfo, backupDir, fileName string, sec
 	return nil
 }
 
-func handleRedisRecover(redisInfo *repo.RootInfo, recoverFile string, isRollback bool, secret string) error {
+func handleRedisRecover(redisInfo *repo.RootInfo, recoverFile string, isRollback bool) error {
 	fileOp := files.NewFileOp()
 	if !fileOp.Stat(recoverFile) {
 		return buserr.WithName("ErrFileNotFound", recoverFile)
@@ -146,14 +145,14 @@ func handleRedisRecover(redisInfo *repo.RootInfo, recoverFile string, isRollback
 				suffix = "tar.gz"
 			}
 		}
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/redis/%s_%s.%s", redisInfo.Name, time.Now().Format(constant.DateTimeSlimLayout), suffix))
-		if err := handleRedisBackup(redisInfo, path.Dir(rollbackFile), path.Base(rollbackFile), secret); err != nil {
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/redis/%s_%s.%s", redisInfo.Name, time.Now().Format("20060102150405"), suffix))
+		if err := handleRedisBackup(redisInfo, path.Dir(rollbackFile), path.Base(rollbackFile)); err != nil {
 			return fmt.Errorf("backup database %s for rollback before recover failed, err: %v", redisInfo.Name, err)
 		}
 		defer func() {
 			if !isOk {
 				global.LOG.Info("recover failed, start to rollback now")
-				if err := handleRedisRecover(redisInfo, rollbackFile, true, secret); err != nil {
+				if err := handleRedisRecover(redisInfo, rollbackFile, true); err != nil {
 					global.LOG.Errorf("rollback redis from %s failed, err: %v", rollbackFile, err)
 					return
 				}
@@ -170,7 +169,7 @@ func handleRedisRecover(redisInfo *repo.RootInfo, recoverFile string, isRollback
 	}
 	if appendonly == "yes" && strings.HasPrefix(redisInfo.Version, "7.") {
 		redisDataDir := fmt.Sprintf("%s/%s/%s/data", constant.AppInstallDir, "redis", redisInfo.Name)
-		if err := handleUnTar(recoverFile, redisDataDir, secret); err != nil {
+		if err := handleUnTar(recoverFile, redisDataDir); err != nil {
 			return err
 		}
 	} else {

backend/app/service/backup_runtime.go

@@ -4,19 +4,18 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"io/fs"
 	"os"
 	"path"
 	"strings"
 	"time"
-
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/global"
-	"github.com/1Panel-dev/1Panel/backend/utils/files"
 )
 
-func handleRuntimeBackup(runtime *model.Runtime, backupDir, fileName string, excludes string, secret string) error {
+func handleRuntimeBackup(runtime *model.Runtime, backupDir, fileName string) error {
 	fileOp := files.NewFileOp()
 	tmpDir := fmt.Sprintf("%s/%s", backupDir, strings.ReplaceAll(fileName, ".tar.gz", ""))
 	if !fileOp.Stat(tmpDir) {
@@ -35,19 +34,19 @@ func handleRuntimeBackup(runtime *model.Runtime, backupDir, fileName string, exc
 	}
 
 	appPath := runtime.GetPath()
-	if err := handleTar(appPath, tmpDir, "runtime.tar.gz", excludes, secret); err != nil {
+	if err := handleTar(appPath, tmpDir, "runtime.tar.gz", ""); err != nil {
 		return err
 	}
-	if err := handleTar(tmpDir, backupDir, fileName, "", secret); err != nil {
+	if err := handleTar(tmpDir, backupDir, fileName, ""); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleRuntimeRecover(runtime *model.Runtime, recoverFile string, isRollback bool, secret string) error {
+func handleRuntimeRecover(runtime *model.Runtime, recoverFile string, isRollback bool) error {
 	isOk := false
 	fileOp := files.NewFileOp()
-	if err := handleUnTar(recoverFile, path.Dir(recoverFile), secret); err != nil {
+	if err := handleUnTar(recoverFile, path.Dir(recoverFile)); err != nil {
 		return err
 	}
 	tmpPath := strings.ReplaceAll(recoverFile, ".tar.gz", "")
@@ -72,14 +71,14 @@ func handleRuntimeRecover(runtime *model.Runtime, recoverFile string, isRollback
 	}
 
 	if !isRollback {
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("runtime/%s_%s.tar.gz", runtime.Name, time.Now().Format(constant.DateTimeSlimLayout)))
-		if err := handleRuntimeBackup(runtime, path.Dir(rollbackFile), path.Base(rollbackFile), "", secret); err != nil {
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("runtime/%s_%s.tar.gz", runtime.Name, time.Now().Format("20060102150405")))
+		if err := handleRuntimeBackup(runtime, path.Dir(rollbackFile), path.Base(rollbackFile)); err != nil {
 			return fmt.Errorf("backup runtime %s for rollback before recover failed, err: %v", runtime.Name, err)
 		}
 		defer func() {
 			if !isOk {
 				global.LOG.Info("recover failed, start to rollback now")
-				if err := handleRuntimeRecover(runtime, rollbackFile, true, secret); err != nil {
+				if err := handleRuntimeRecover(runtime, rollbackFile, true); err != nil {
 					global.LOG.Errorf("rollback runtime %s from %s failed, err: %v", runtime.Name, rollbackFile, err)
 					return
 				}
@@ -100,7 +99,7 @@ func handleRuntimeRecover(runtime *model.Runtime, recoverFile string, isRollback
 	_ = fileOp.Rename(runtimeDir, backPath)
 	_ = fileOp.CreateDir(runtimeDir, 0755)
 
-	if err := handleUnTar(tmpPath+"/runtime.tar.gz", fmt.Sprintf("%s/%s", constant.RuntimeDir, runtime.Type), secret); err != nil {
+	if err := handleUnTar(tmpPath+"/runtime.tar.gz", fmt.Sprintf("%s/%s", constant.RuntimeDir, runtime.Type)); err != nil {
 		global.LOG.Errorf("handle recover from runtime.tar.gz failed, err: %v", err)
 		_ = fileOp.DeleteDir(runtimeDir)
 		_ = fileOp.Rename(backPath, runtimeDir)

backend/app/service/backup_website.go

@@ -31,11 +31,11 @@ func (u *BackupService) WebsiteBackup(req dto.CommonBackup) error {
 		return err
 	}
 
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
+	timeNow := time.Now().Format("20060102150405")
 	itemDir := fmt.Sprintf("website/%s", req.Name)
 	backupDir := path.Join(localDir, itemDir)
 	fileName := fmt.Sprintf("%s_%s.tar.gz", website.PrimaryDomain, timeNow+common.RandStrAndNum(5))
-	if err := handleWebsiteBackup(&website, backupDir, fileName, "", req.Secret); err != nil {
+	if err := handleWebsiteBackup(&website, backupDir, fileName); err != nil {
 		return err
 	}
 
@@ -65,16 +65,16 @@ func (u *BackupService) WebsiteRecover(req dto.CommonRecover) error {
 		return err
 	}
 	global.LOG.Infof("recover website %s from backup file %s", req.Name, req.File)
-	if err := handleWebsiteRecover(&website, req.File, false, req.Secret); err != nil {
+	if err := handleWebsiteRecover(&website, req.File, false); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback bool, secret string) error {
+func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback bool) error {
 	fileOp := files.NewFileOp()
 	tmpPath := strings.ReplaceAll(recoverFile, ".tar.gz", "")
-	if err := handleUnTar(recoverFile, path.Dir(recoverFile), secret); err != nil {
+	if err := handleUnTar(recoverFile, path.Dir(recoverFile)); err != nil {
 		return err
 	}
 	defer func() {
@@ -106,14 +106,14 @@ func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback
 
 	isOk := false
 	if !isRollback {
-		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("website/%s_%s.tar.gz", website.Alias, time.Now().Format(constant.DateTimeSlimLayout)))
-		if err := handleWebsiteBackup(website, path.Dir(rollbackFile), path.Base(rollbackFile), "", ""); err != nil {
+		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("website/%s_%s.tar.gz", website.Alias, time.Now().Format("20060102150405")))
+		if err := handleWebsiteBackup(website, path.Dir(rollbackFile), path.Base(rollbackFile)); err != nil {
 			return fmt.Errorf("backup website %s for rollback before recover failed, err: %v", website.Alias, err)
 		}
 		defer func() {
 			if !isOk {
 				global.LOG.Info("recover failed, start to rollback now")
-				if err := handleWebsiteRecover(website, rollbackFile, true, ""); err != nil {
+				if err := handleWebsiteRecover(website, rollbackFile, true); err != nil {
 					global.LOG.Errorf("rollback website %s from %s failed, err: %v", website.Alias, rollbackFile, err)
 					return
 				}
@@ -141,7 +141,7 @@ func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback
 		if err != nil {
 			return err
 		}
-		if err := handleAppRecover(&app, fmt.Sprintf("%s/%s.app.tar.gz", tmpPath, website.Alias), true, ""); err != nil {
+		if err := handleAppRecover(&app, fmt.Sprintf("%s/%s.app.tar.gz", tmpPath, website.Alias), true); err != nil {
 			global.LOG.Errorf("handle recover from app.tar.gz failed, err: %v", err)
 			return err
 		}
@@ -154,8 +154,8 @@ func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback
 		if err != nil {
 			return err
 		}
-		if runtime.Type == constant.RuntimeNode || runtime.Type == constant.RuntimeJava || runtime.Type == constant.RuntimeGo {
-			if err := handleRuntimeRecover(runtime, fmt.Sprintf("%s/%s.runtime.tar.gz", tmpPath, website.Alias), true, ""); err != nil {
+		if runtime.Type == constant.RuntimeNode {
+			if err := handleRuntimeRecover(runtime, fmt.Sprintf("%s/%s.runtime.tar.gz", tmpPath, website.Alias), true); err != nil {
 				return err
 			}
 			global.LOG.Info("put runtime.tar.gz into tmp dir successful")
@@ -163,7 +163,7 @@ func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback
 	}
 
 	siteDir := fmt.Sprintf("%s/openresty/%s/www/sites", constant.AppInstallDir, nginxInfo.Name)
-	if err := handleUnTar(fmt.Sprintf("%s/%s.web.tar.gz", tmpPath, website.Alias), siteDir, ""); err != nil {
+	if err := handleUnTar(fmt.Sprintf("%s/%s.web.tar.gz", tmpPath, website.Alias), siteDir); err != nil {
 		global.LOG.Errorf("handle recover from web.tar.gz failed, err: %v", err)
 		return err
 	}
@@ -182,7 +182,7 @@ func handleWebsiteRecover(website *model.Website, recoverFile string, isRollback
 	return nil
 }
 
-func handleWebsiteBackup(website *model.Website, backupDir, fileName string, excludes string, secret string) error {
+func handleWebsiteBackup(website *model.Website, backupDir, fileName string) error {
 	fileOp := files.NewFileOp()
 	tmpDir := fmt.Sprintf("%s/%s", backupDir, strings.ReplaceAll(fileName, ".tar.gz", ""))
 	if !fileOp.Stat(tmpDir) {
@@ -216,7 +216,7 @@ func handleWebsiteBackup(website *model.Website, backupDir, fileName string, exc
 		if err != nil {
 			return err
 		}
-		if err := handleAppBackup(&app, tmpDir, fmt.Sprintf("%s.app.tar.gz", website.Alias), excludes, ""); err != nil {
+		if err := handleAppBackup(&app, tmpDir, fmt.Sprintf("%s.app.tar.gz", website.Alias)); err != nil {
 			return err
 		}
 		global.LOG.Info("put app.tar.gz into tmp dir successful")
@@ -225,8 +225,8 @@ func handleWebsiteBackup(website *model.Website, backupDir, fileName string, exc
 		if err != nil {
 			return err
 		}
-		if runtime.Type == constant.RuntimeNode || runtime.Type == constant.RuntimeJava || runtime.Type == constant.RuntimeGo {
-			if err := handleRuntimeBackup(runtime, tmpDir, fmt.Sprintf("%s.runtime.tar.gz", website.Alias), excludes, ""); err != nil {
+		if runtime.Type == constant.RuntimeNode {
+			if err := handleRuntimeBackup(runtime, tmpDir, fmt.Sprintf("%s.runtime.tar.gz", website.Alias)); err != nil {
 				return err
 			}
 			global.LOG.Info("put runtime.tar.gz into tmp dir successful")
@@ -234,11 +234,11 @@ func handleWebsiteBackup(website *model.Website, backupDir, fileName string, exc
 	}
 
 	websiteDir := fmt.Sprintf("%s/openresty/%s/www/sites/%s", constant.AppInstallDir, nginxInfo.Name, website.Alias)
-	if err := handleTar(websiteDir, tmpDir, fmt.Sprintf("%s.web.tar.gz", website.Alias), excludes, ""); err != nil {
+	if err := handleTar(websiteDir, tmpDir, fmt.Sprintf("%s.web.tar.gz", website.Alias), ""); err != nil {
 		return err
 	}
 	global.LOG.Info("put web.tar.gz into tmp dir successful, now start to tar tmp dir")
-	if err := handleTar(tmpDir, backupDir, fileName, "", secret); err != nil {
+	if err := handleTar(tmpDir, backupDir, fileName, ""); err != nil {
 		return err
 	}
 
@@ -250,18 +250,18 @@ func checkValidOfWebsite(oldWebsite, website *model.Website) error {
 		return buserr.WithDetail(constant.ErrBackupMatch, fmt.Sprintf("oldName: %s, oldType: %v", oldWebsite.Alias, oldWebsite.Type), nil)
 	}
 	if oldWebsite.AppInstallID != 0 {
-		_, err := appInstallRepo.GetFirst(commonRepo.WithByID(oldWebsite.AppInstallID))
+		_, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
 		if err != nil {
 			return buserr.WithDetail(constant.ErrBackupMatch, "app", nil)
 		}
 	}
 	if oldWebsite.RuntimeID != 0 {
-		if _, err := runtimeRepo.GetFirst(commonRepo.WithByID(oldWebsite.RuntimeID)); err != nil {
+		if _, err := runtimeRepo.GetFirst(commonRepo.WithByID(website.RuntimeID)); err != nil {
 			return buserr.WithDetail(constant.ErrBackupMatch, "runtime", nil)
 		}
 	}
 	if oldWebsite.WebsiteSSLID != 0 {
-		if _, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(oldWebsite.WebsiteSSLID)); err != nil {
+		if _, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID)); err != nil {
 			return buserr.WithDetail(constant.ErrBackupMatch, "ssl", nil)
 		}
 	}

backend/app/service/clam.go

@@ -1,587 +0,0 @@
-package service
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/buserr"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/global"
-	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
-	"github.com/1Panel-dev/1Panel/backend/utils/common"
-	"github.com/1Panel-dev/1Panel/backend/utils/systemctl"
-	"github.com/1Panel-dev/1Panel/backend/utils/xpack"
-	"github.com/jinzhu/copier"
-	"github.com/robfig/cron/v3"
-
-	"github.com/pkg/errors"
-)
-
-const (
-	clamServiceNameCentOs = "clamd@scan.service"
-	clamServiceNameUbuntu = "clamav-daemon.service"
-	freshClamService      = "clamav-freshclam.service"
-	resultDir             = "clamav"
-)
-
-type ClamService struct {
-	serviceName string
-}
-
-type IClamService interface {
-	LoadBaseInfo() (dto.ClamBaseInfo, error)
-	Operate(operate string) error
-	SearchWithPage(search dto.SearchClamWithPage) (int64, interface{}, error)
-	Create(req dto.ClamCreate) error
-	Update(req dto.ClamUpdate) error
-	UpdateStatus(id uint, status string) error
-	Delete(req dto.ClamDelete) error
-	HandleOnce(req dto.OperateByID) error
-	LoadFile(req dto.ClamFileReq) (string, error)
-	UpdateFile(req dto.UpdateByNameAndFile) error
-	LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error)
-	CleanRecord(req dto.OperateByID) error
-
-	LoadRecordLog(req dto.ClamLogReq) (string, error)
-}
-
-func NewIClamService() IClamService {
-	return &ClamService{}
-}
-
-func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
-	var baseInfo dto.ClamBaseInfo
-	baseInfo.Version = "-"
-	baseInfo.FreshVersion = "-"
-	exist1, _ := systemctl.IsExist(clamServiceNameCentOs)
-	if exist1 {
-		c.serviceName = clamServiceNameCentOs
-		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameCentOs)
-	}
-	exist2, _ := systemctl.IsExist(clamServiceNameUbuntu)
-	if exist2 {
-		c.serviceName = clamServiceNameUbuntu
-		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameUbuntu)
-	}
-	freshExist, _ := systemctl.IsExist(freshClamService)
-	if freshExist {
-		baseInfo.FreshIsExist = true
-		baseInfo.FreshIsActive, _ = systemctl.IsActive(freshClamService)
-	}
-	if !cmd.Which("clamdscan") {
-		baseInfo.IsActive = false
-	}
-
-	if baseInfo.IsActive {
-		version, err := cmd.Exec("clamdscan --version")
-		if err == nil {
-			if strings.Contains(version, "/") {
-				baseInfo.Version = strings.TrimPrefix(strings.Split(version, "/")[0], "ClamAV ")
-			} else {
-				baseInfo.Version = strings.TrimPrefix(version, "ClamAV ")
-			}
-		}
-	} else {
-		_ = StopAllCronJob(false)
-	}
-	if baseInfo.FreshIsActive {
-		version, err := cmd.Exec("freshclam --version")
-		if err == nil {
-			if strings.Contains(version, "/") {
-				baseInfo.FreshVersion = strings.TrimPrefix(strings.Split(version, "/")[0], "ClamAV ")
-			} else {
-				baseInfo.FreshVersion = strings.TrimPrefix(version, "ClamAV ")
-			}
-		}
-	}
-	return baseInfo, nil
-}
-
-func (c *ClamService) Operate(operate string) error {
-	switch operate {
-	case "start", "restart", "stop":
-		stdout, err := cmd.Execf("systemctl %s %s", operate, c.serviceName)
-		if err != nil {
-			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, stdout)
-		}
-		return nil
-	case "fresh-start", "fresh-restart", "fresh-stop":
-		stdout, err := cmd.Execf("systemctl %s %s", strings.TrimPrefix(operate, "fresh-"), freshClamService)
-		if err != nil {
-			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, stdout)
-		}
-		return nil
-	default:
-		return fmt.Errorf("not support such operation: %v", operate)
-	}
-}
-
-func (c *ClamService) SearchWithPage(req dto.SearchClamWithPage) (int64, interface{}, error) {
-	total, commands, err := clamRepo.Page(req.Page, req.PageSize, commonRepo.WithLikeName(req.Info), commonRepo.WithOrderRuleBy(req.OrderBy, req.Order))
-	if err != nil {
-		return 0, nil, err
-	}
-	var datas []dto.ClamInfo
-	for _, command := range commands {
-		var item dto.ClamInfo
-		if err := copier.Copy(&item, &command); err != nil {
-			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		item.LastHandleDate = "-"
-		datas = append(datas, item)
-	}
-	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
-	for i := 0; i < len(datas); i++ {
-		logPaths := loadFileByName(datas[i].Name)
-		sort.Slice(logPaths, func(i, j int) bool {
-			return logPaths[i] > logPaths[j]
-		})
-		if len(logPaths) != 0 {
-			t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, logPaths[0], nyc)
-			if err != nil {
-				continue
-			}
-			datas[i].LastHandleDate = t1.Format(constant.DateTimeLayout)
-		}
-	}
-	return total, datas, err
-}
-
-func (c *ClamService) Create(req dto.ClamCreate) error {
-	clam, _ := clamRepo.Get(commonRepo.WithByName(req.Name))
-	if clam.ID != 0 {
-		return constant.ErrRecordExist
-	}
-	if err := copier.Copy(&clam, &req); err != nil {
-		return errors.WithMessage(constant.ErrStructTransform, err.Error())
-	}
-	if clam.InfectedStrategy == "none" || clam.InfectedStrategy == "remove" {
-		clam.InfectedDir = ""
-	}
-	if len(req.Spec) != 0 {
-		entryID, err := xpack.StartClam(clam, false)
-		if err != nil {
-			return err
-		}
-		clam.EntryID = entryID
-		clam.Status = constant.StatusEnable
-	}
-	if err := clamRepo.Create(&clam); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (c *ClamService) Update(req dto.ClamUpdate) error {
-	clam, _ := clamRepo.Get(commonRepo.WithByName(req.Name))
-	if clam.ID == 0 {
-		return constant.ErrRecordNotFound
-	}
-	if req.InfectedStrategy == "none" || req.InfectedStrategy == "remove" {
-		req.InfectedDir = ""
-	}
-	var clamItem model.Clam
-	if err := copier.Copy(&clamItem, &req); err != nil {
-		return errors.WithMessage(constant.ErrStructTransform, err.Error())
-	}
-	clamItem.EntryID = clam.EntryID
-	upMap := map[string]interface{}{}
-	if len(clam.Spec) != 0 && clam.EntryID != 0 {
-		global.Cron.Remove(cron.EntryID(clamItem.EntryID))
-		upMap["entry_id"] = 0
-	}
-	if len(req.Spec) == 0 {
-		upMap["status"] = ""
-		upMap["entry_id"] = 0
-	}
-	if len(req.Spec) != 0 && clam.Status != constant.StatusDisable {
-		newEntryID, err := xpack.StartClam(clamItem, true)
-		if err != nil {
-			return err
-		}
-		upMap["entry_id"] = newEntryID
-	}
-	if len(clam.Spec) == 0 && len(req.Spec) != 0 {
-		upMap["status"] = constant.StatusEnable
-	}
-
-	upMap["name"] = req.Name
-	upMap["path"] = req.Path
-	upMap["infected_dir"] = req.InfectedDir
-	upMap["infected_strategy"] = req.InfectedStrategy
-	upMap["spec"] = req.Spec
-	upMap["description"] = req.Description
-	if err := clamRepo.Update(req.ID, upMap); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (c *ClamService) UpdateStatus(id uint, status string) error {
-	clam, _ := clamRepo.Get(commonRepo.WithByID(id))
-	if clam.ID == 0 {
-		return constant.ErrRecordNotFound
-	}
-	var (
-		entryID int
-		err     error
-	)
-	if status == constant.StatusEnable {
-		entryID, err = xpack.StartClam(clam, true)
-		if err != nil {
-			return err
-		}
-	} else {
-		global.Cron.Remove(cron.EntryID(clam.EntryID))
-		global.LOG.Infof("stop cronjob entryID: %v", clam.EntryID)
-	}
-
-	return clamRepo.Update(clam.ID, map[string]interface{}{"status": status, "entry_id": entryID})
-}
-
-func (c *ClamService) Delete(req dto.ClamDelete) error {
-	for _, id := range req.Ids {
-		clam, _ := clamRepo.Get(commonRepo.WithByID(id))
-		if clam.ID == 0 {
-			continue
-		}
-		if req.RemoveRecord {
-			_ = os.RemoveAll(path.Join(global.CONF.System.DataDir, resultDir, clam.Name))
-		}
-		if req.RemoveInfected {
-			_ = os.RemoveAll(path.Join(clam.InfectedDir, "1panel-infected", clam.Name))
-		}
-		if err := clamRepo.Delete(commonRepo.WithByID(id)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *ClamService) HandleOnce(req dto.OperateByID) error {
-	if cleaned := StopAllCronJob(true); cleaned {
-		return buserr.New("ErrClamdscanNotFound")
-	}
-	clam, _ := clamRepo.Get(commonRepo.WithByID(req.ID))
-	if clam.ID == 0 {
-		return constant.ErrRecordNotFound
-	}
-	if cmd.CheckIllegal(clam.Path) {
-		return buserr.New(constant.ErrCmdIllegal)
-	}
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
-	logFile := path.Join(global.CONF.System.DataDir, resultDir, clam.Name, timeNow)
-	if _, err := os.Stat(path.Dir(logFile)); err != nil {
-		_ = os.MkdirAll(path.Dir(logFile), os.ModePerm)
-	}
-	go func() {
-		strategy := ""
-		switch clam.InfectedStrategy {
-		case "remove":
-			strategy = "--remove"
-		case "move":
-			dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
-			strategy = "--move=" + dir
-			if _, err := os.Stat(dir); err != nil {
-				_ = os.MkdirAll(dir, os.ModePerm)
-			}
-		case "copy":
-			dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
-			strategy = "--copy=" + dir
-			if _, err := os.Stat(dir); err != nil {
-				_ = os.MkdirAll(dir, os.ModePerm)
-			}
-		}
-		global.LOG.Debugf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
-		stdout, err := cmd.Execf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
-		if err != nil {
-			global.LOG.Errorf("clamdscan failed, stdout: %v, err: %v", stdout, err)
-		}
-	}()
-	return nil
-}
-
-func (c *ClamService) LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error) {
-	clam, _ := clamRepo.Get(commonRepo.WithByID(req.ClamID))
-	if clam.ID == 0 {
-		return 0, nil, constant.ErrRecordNotFound
-	}
-	logPaths := loadFileByName(clam.Name)
-	if len(logPaths) == 0 {
-		return 0, nil, nil
-	}
-
-	var filterFiles []string
-	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
-	for _, item := range logPaths {
-		t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, item, nyc)
-		if err != nil {
-			continue
-		}
-		if t1.After(req.StartTime) && t1.Before(req.EndTime) {
-			filterFiles = append(filterFiles, item)
-		}
-	}
-	if len(filterFiles) == 0 {
-		return 0, nil, nil
-	}
-
-	sort.Slice(filterFiles, func(i, j int) bool {
-		return filterFiles[i] > filterFiles[j]
-	})
-
-	var records []string
-	total, start, end := len(filterFiles), (req.Page-1)*req.PageSize, req.Page*req.PageSize
-	if start > total {
-		records = make([]string, 0)
-	} else {
-		if end >= total {
-			end = total
-		}
-		records = filterFiles[start:end]
-	}
-
-	var datas []dto.ClamLog
-	for i := 0; i < len(records); i++ {
-		item := loadResultFromLog(path.Join(global.CONF.System.DataDir, resultDir, clam.Name, records[i]))
-		datas = append(datas, item)
-	}
-	return int64(total), datas, nil
-}
-func (c *ClamService) LoadRecordLog(req dto.ClamLogReq) (string, error) {
-	logPath := path.Join(global.CONF.System.DataDir, resultDir, req.ClamName, req.RecordName)
-	var tail string
-	if req.Tail != "0" {
-		tail = req.Tail
-	} else {
-		tail = "+1"
-	}
-	cmd := exec.Command("tail", "-n", tail, logPath)
-	stdout, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("tail -n %v failed, err: %v", req.Tail, err)
-	}
-	return string(stdout), nil
-}
-
-func (c *ClamService) CleanRecord(req dto.OperateByID) error {
-	clam, _ := clamRepo.Get(commonRepo.WithByID(req.ID))
-	if clam.ID == 0 {
-		return constant.ErrRecordNotFound
-	}
-	pathItem := path.Join(global.CONF.System.DataDir, resultDir, clam.Name)
-	_ = os.RemoveAll(pathItem)
-	return nil
-}
-
-func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
-	filePath := ""
-	switch req.Name {
-	case "clamd":
-		if c.serviceName == clamServiceNameUbuntu {
-			filePath = "/etc/clamav/clamd.conf"
-		} else {
-			filePath = "/etc/clamd.d/scan.conf"
-		}
-	case "clamd-log":
-		filePath = c.loadLogPath("clamd-log")
-		if len(filePath) != 0 {
-			break
-		}
-		if c.serviceName == clamServiceNameUbuntu {
-			filePath = "/var/log/clamav/clamav.log"
-		} else {
-			filePath = "/var/log/clamd.scan"
-		}
-	case "freshclam":
-		if c.serviceName == clamServiceNameUbuntu {
-			filePath = "/etc/clamav/freshclam.conf"
-		} else {
-			filePath = "/etc/freshclam.conf"
-		}
-	case "freshclam-log":
-		filePath = c.loadLogPath("freshclam-log")
-		if len(filePath) != 0 {
-			break
-		}
-		if c.serviceName == clamServiceNameUbuntu {
-			filePath = "/var/log/clamav/freshclam.log"
-		} else {
-			filePath = "/var/log/freshclam.log"
-		}
-	default:
-		return "", fmt.Errorf("not support such type")
-	}
-	if _, err := os.Stat(filePath); err != nil {
-		return "", buserr.New("ErrHttpReqNotFound")
-	}
-	var tail string
-	if req.Tail != "0" {
-		tail = req.Tail
-	} else {
-		tail = "+1"
-	}
-	cmd := exec.Command("tail", "-n", tail, filePath)
-	stdout, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("tail -n %v failed, err: %v", req.Tail, err)
-	}
-	return string(stdout), nil
-}
-
-func (c *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
-	filePath := ""
-	service := ""
-	switch req.Name {
-	case "clamd":
-		if c.serviceName == clamServiceNameUbuntu {
-			service = clamServiceNameUbuntu
-			filePath = "/etc/clamav/clamd.conf"
-		} else {
-			service = clamServiceNameCentOs
-			filePath = "/etc/clamd.d/scan.conf"
-		}
-	case "freshclam":
-		if c.serviceName == clamServiceNameUbuntu {
-			filePath = "/etc/clamav/freshclam.conf"
-		} else {
-			filePath = "/etc/freshclam.conf"
-		}
-		service = "clamav-freshclam.service"
-	default:
-		return fmt.Errorf("not support such type")
-	}
-	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0640)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-	write := bufio.NewWriter(file)
-	_, _ = write.WriteString(req.File)
-	write.Flush()
-
-	_ = systemctl.Restart(service)
-	return nil
-}
-
-func StopAllCronJob(withCheck bool) bool {
-	if withCheck {
-		isActive := false
-		exist1, _ := systemctl.IsExist(clamServiceNameCentOs)
-		if exist1 {
-			isActive, _ = systemctl.IsActive(clamServiceNameCentOs)
-		}
-		exist2, _ := systemctl.IsExist(clamServiceNameUbuntu)
-		if exist2 {
-			isActive, _ = systemctl.IsActive(clamServiceNameUbuntu)
-		}
-		if isActive {
-			return false
-		}
-	}
-	clams, _ := clamRepo.List(commonRepo.WithByStatus(constant.StatusEnable))
-	for i := 0; i < len(clams); i++ {
-		global.Cron.Remove(cron.EntryID(clams[i].EntryID))
-		_ = clamRepo.Update(clams[i].ID, map[string]interface{}{"status": constant.StatusDisable, "entry_id": 0})
-	}
-	return true
-}
-
-func loadFileByName(name string) []string {
-	var logPaths []string
-	pathItem := path.Join(global.CONF.System.DataDir, resultDir, name)
-	_ = filepath.Walk(pathItem, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
-		if info.IsDir() || info.Name() == name {
-			return nil
-		}
-		logPaths = append(logPaths, info.Name())
-		return nil
-	})
-	return logPaths
-}
-func loadResultFromLog(pathItem string) dto.ClamLog {
-	var data dto.ClamLog
-	data.Name = path.Base(pathItem)
-	data.Status = constant.StatusWaiting
-	file, err := os.ReadFile(pathItem)
-	if err != nil {
-		return data
-	}
-	lines := strings.Split(string(file), "\n")
-	for _, line := range lines {
-		if strings.Contains(line, "- SCAN SUMMARY -") {
-			data.Status = constant.StatusDone
-		}
-		if data.Status != constant.StatusDone {
-			continue
-		}
-		switch {
-		case strings.HasPrefix(line, "Infected files:"):
-			data.InfectedFiles = strings.TrimPrefix(line, "Infected files:")
-		case strings.HasPrefix(line, "Total errors:"):
-			data.TotalError = strings.TrimPrefix(line, "Total errors:")
-		case strings.HasPrefix(line, "Time:"):
-			if strings.Contains(line, "(") {
-				data.ScanTime = strings.ReplaceAll(strings.Split(line, "(")[1], ")", "")
-				continue
-			}
-			data.ScanTime = strings.TrimPrefix(line, "Time:")
-		case strings.HasPrefix(line, "Start Date:"):
-			data.ScanDate = strings.TrimPrefix(line, "Start Date:")
-		}
-	}
-	return data
-}
-func (c *ClamService) loadLogPath(name string) string {
-	confPath := ""
-	if name == "clamd-log" {
-		if c.serviceName == clamServiceNameUbuntu {
-			confPath = "/etc/clamav/clamd.conf"
-		} else {
-			confPath = "/etc/clamd.d/scan.conf"
-		}
-	} else {
-		if c.serviceName == clamServiceNameUbuntu {
-			confPath = "/etc/clamav/freshclam.conf"
-		} else {
-			confPath = "/etc/freshclam.conf"
-		}
-	}
-	if _, err := os.Stat(confPath); err != nil {
-		return ""
-	}
-	content, err := os.ReadFile(confPath)
-	if err != nil {
-		return ""
-	}
-	lines := strings.Split(string(content), "\n")
-	if name == "clamd-log" {
-		for _, line := range lines {
-			if strings.HasPrefix(line, "LogFile ") {
-				return strings.Trim(strings.ReplaceAll(line, "LogFile ", ""), " ")
-			}
-		}
-	} else {
-		for _, line := range lines {
-			if strings.HasPrefix(line, "UpdateLogFile ") {
-				return strings.Trim(strings.ReplaceAll(line, "UpdateLogFile ", ""), " ")
-			}
-		}
-	}
-
-	return ""
-}

backend/app/service/command.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
-	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/jinzhu/copier"
 	"github.com/pkg/errors"
@@ -17,11 +16,6 @@ type ICommandService interface {
 	Create(commandDto dto.CommandOperate) error
 	Update(id uint, upMap map[string]interface{}) error
 	Delete(ids []uint) error
-
-	SearchRedisCommandWithPage(search dto.SearchWithPage) (int64, interface{}, error)
-	ListRedisCommand() ([]dto.RedisCommand, error)
-	SaveRedisCommand(commandDto dto.RedisCommand) error
-	DeleteRedisCommand(ids []uint) error
 }
 
 func NewICommandService() ICommandService {
@@ -121,63 +115,3 @@ func (u *CommandService) Delete(ids []uint) error {
 func (u *CommandService) Update(id uint, upMap map[string]interface{}) error {
 	return commandRepo.Update(id, upMap)
 }
-
-func (u *CommandService) SearchRedisCommandWithPage(search dto.SearchWithPage) (int64, interface{}, error) {
-	total, commands, err := commandRepo.PageRedis(search.Page, search.PageSize, commandRepo.WithLikeName(search.Info))
-	if err != nil {
-		return 0, nil, err
-	}
-	var dtoCommands []dto.RedisCommand
-	for _, command := range commands {
-		var item dto.RedisCommand
-		if err := copier.Copy(&item, &command); err != nil {
-			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		dtoCommands = append(dtoCommands, item)
-	}
-	return total, dtoCommands, err
-}
-
-func (u *CommandService) ListRedisCommand() ([]dto.RedisCommand, error) {
-	commands, err := commandRepo.GetRedisList()
-	if err != nil {
-		return nil, constant.ErrRecordNotFound
-	}
-	var dtoCommands []dto.RedisCommand
-	for _, command := range commands {
-		var item dto.RedisCommand
-		if err := copier.Copy(&item, &command); err != nil {
-			return nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		dtoCommands = append(dtoCommands, item)
-	}
-	return dtoCommands, err
-}
-
-func (u *CommandService) SaveRedisCommand(req dto.RedisCommand) error {
-	if req.ID == 0 {
-		command, _ := commandRepo.GetRedis(commonRepo.WithByName(req.Name))
-		if command.ID != 0 {
-			return constant.ErrRecordExist
-		}
-	}
-	var command model.RedisCommand
-	if err := copier.Copy(&command, &req); err != nil {
-		return errors.WithMessage(constant.ErrStructTransform, err.Error())
-	}
-	if err := commandRepo.SaveRedis(&command); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (u *CommandService) DeleteRedisCommand(ids []uint) error {
-	if len(ids) == 1 {
-		command, _ := commandRepo.GetRedis(commonRepo.WithByID(ids[0]))
-		if command.ID == 0 {
-			return constant.ErrRecordNotFound
-		}
-		return commandRepo.DeleteRedis(commonRepo.WithByID(ids[0]))
-	}
-	return commandRepo.DeleteRedis(commonRepo.WithIdsIn(ids))
-}

backend/app/service/container.go

@@ -1,14 +1,11 @@
 package service
 
 import (
-	"bufio"
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
-	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -20,8 +17,6 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/gin-gonic/gin"
-
 	"github.com/pkg/errors"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -34,7 +29,6 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/api/types/registry"
@@ -65,11 +59,9 @@ type IContainerService interface {
 	ContainerListStats() ([]dto.ContainerListStats, error)
 	LoadResourceLimit() (*dto.ResourceLimit, error)
 	ContainerRename(req dto.ContainerRename) error
-	ContainerCommit(req dto.ContainerCommit) error
 	ContainerLogClean(req dto.OperationWithName) error
 	ContainerOperation(req dto.ContainerOperation) error
 	ContainerLogs(wsConn *websocket.Conn, containerType, container, since, tail string, follow bool) error
-	DownloadContainerLogs(containerType, container, since, tail string, c *gin.Context) error
 	ContainerStats(id string) (*dto.ContainerStats, error)
 	Inspect(req dto.InspectReq) (string, error)
 	DeleteNetwork(req dto.BatchDelete) error
@@ -96,7 +88,6 @@ func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, erro
 	if err != nil {
 		return 0, nil, err
 	}
-	defer client.Close()
 	options := container.ListOptions{
 		All: true,
 	}
@@ -187,16 +178,16 @@ func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, erro
 			IsFromApp = true
 		}
 
-		exposePorts := transPortToStr(records[i].Ports)
+		ports := loadContainerPort(item.Ports)
 		info := dto.ContainerInfo{
 			ContainerID:   item.ID,
-			CreateTime:    time.Unix(item.Created, 0).Format(constant.DateTimeLayout),
+			CreateTime:    time.Unix(item.Created, 0).Format("2006-01-02 15:04:05"),
 			Name:          item.Names[0][1:],
 			ImageId:       strings.Split(item.ImageID, ":")[1],
 			ImageName:     item.Image,
 			State:         item.State,
 			RunTime:       item.Status,
-			Ports:         exposePorts,
+			Ports:         ports,
 			IsFromApp:     IsFromApp,
 			IsFromCompose: IsFromCompose,
 		}
@@ -228,7 +219,6 @@ func (u *ContainerService) List() ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	containers, err := client.ContainerList(context.Background(), container.ListOptions{All: true})
 	if err != nil {
 		return nil, err
@@ -250,7 +240,6 @@ func (u *ContainerService) ContainerListStats() ([]dto.ContainerListStats, error
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	list, err := client.ContainerList(context.Background(), container.ListOptions{All: true})
 	if err != nil {
 		return nil, err
@@ -273,7 +262,6 @@ func (u *ContainerService) Inspect(req dto.InspectReq) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	defer client.Close()
 	var inspectInfo interface{}
 	switch req.Type {
 	case "container":
@@ -301,7 +289,6 @@ func (u *ContainerService) Prune(req dto.ContainerPrune) (dto.ContainerPruneRepo
 	if err != nil {
 		return report, err
 	}
-	defer client.Close()
 	pruneFilters := filters.NewArgs()
 	if req.WithTagAll {
 		pruneFilters.Add("dangling", "false")
@@ -331,28 +318,12 @@ func (u *ContainerService) Prune(req dto.ContainerPrune) (dto.ContainerPruneRepo
 		}
 		report.DeletedNumber = len(rep.NetworksDeleted)
 	case "volume":
-		versions, err := client.ServerVersion(context.Background())
-		if err != nil {
-			return report, err
-		}
-		if common.ComparePanelVersion(versions.APIVersion, "1.42") {
-			pruneFilters.Add("all", "true")
-		}
 		rep, err := client.VolumesPrune(context.Background(), pruneFilters)
 		if err != nil {
 			return report, err
 		}
 		report.DeletedNumber = len(rep.VolumesDeleted)
 		report.SpaceReclaimed = int(rep.SpaceReclaimed)
-	case "buildcache":
-		opts := types.BuildCachePruneOptions{}
-		opts.All = true
-		rep, err := client.BuildCachePrune(context.Background(), opts)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.CachesDeleted)
-		report.SpaceReclaimed = int(rep.SpaceReclaimed)
 	}
 	return report, nil
 }
@@ -379,7 +350,6 @@ func (u *ContainerService) ContainerCreate(req dto.ContainerOperate) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	ctx := context.Background()
 	newContainer, _ := client.ContainerInspect(ctx, req.Name)
 	if newContainer.ContainerJSONBase != nil {
@@ -427,7 +397,6 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	ctx := context.Background()
 	oldContainer, err := client.ContainerInspect(ctx, req.Name)
 	if err != nil {
@@ -445,8 +414,6 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 		}
 	}
 
-	exposePorts, _ := loadPortByInspect(oldContainer.ID, client)
-	data.ExposedPorts = loadContainerPortForInfo(exposePorts)
 	networkSettings := oldContainer.NetworkSettings
 	bridgeNetworkSettings := networkSettings.Networks[data.Network]
 	if bridgeNetworkSettings.IPAMConfig != nil {
@@ -467,7 +434,19 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 	for key, val := range oldContainer.Config.Labels {
 		data.Labels = append(data.Labels, fmt.Sprintf("%s=%s", key, val))
 	}
-
+	for key, val := range oldContainer.HostConfig.PortBindings {
+		var itemPort dto.PortHelper
+		if !strings.Contains(string(key), "/") {
+			continue
+		}
+		itemPort.ContainerPort = strings.Split(string(key), "/")[0]
+		itemPort.Protocol = strings.Split(string(key), "/")[1]
+		for _, binds := range val {
+			itemPort.HostIP = binds.HostIP
+			itemPort.HostPort = binds.HostPort
+			data.ExposedPorts = append(data.ExposedPorts, itemPort)
+		}
+	}
 	data.AutoRemove = oldContainer.HostConfig.AutoRemove
 	data.Privileged = oldContainer.HostConfig.Privileged
 	data.PublishAllPorts = oldContainer.HostConfig.PublishAllPorts
@@ -488,7 +467,6 @@ func (u *ContainerService) ContainerUpdate(req dto.ContainerOperate) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	ctx := context.Background()
 	newContainer, _ := client.ContainerInspect(ctx, req.Name)
 	if newContainer.ContainerJSONBase != nil && newContainer.ID != req.ContainerID {
@@ -537,7 +515,6 @@ func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	ctx := context.Background()
 	oldContainer, err := client.ContainerInspect(ctx, req.Name)
 	if err != nil {
@@ -585,7 +562,6 @@ func (u *ContainerService) ContainerRename(req dto.ContainerRename) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 
 	newContainer, _ := client.ContainerInspect(ctx, req.NewName)
 	if newContainer.ContainerJSONBase != nil {
@@ -594,28 +570,6 @@ func (u *ContainerService) ContainerRename(req dto.ContainerRename) error {
 	return client.ContainerRename(ctx, req.Name, req.NewName)
 }
 
-func (u *ContainerService) ContainerCommit(req dto.ContainerCommit) error {
-	ctx := context.Background()
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		return err
-	}
-	defer client.Close()
-	options := container.CommitOptions{
-		Reference: req.NewImageName,
-		Comment:   req.Comment,
-		Author:    req.Author,
-		Changes:   nil,
-		Pause:     req.Pause,
-		Config:    nil,
-	}
-	_, err = client.ContainerCommit(ctx, req.ContainerId, options)
-	if err != nil {
-		return fmt.Errorf("failed to commit container, err: %v", err)
-	}
-	return nil
-}
-
 func (u *ContainerService) ContainerOperation(req dto.ContainerOperation) error {
 	var err error
 	ctx := context.Background()
@@ -623,7 +577,6 @@ func (u *ContainerService) ContainerOperation(req dto.ContainerOperation) error
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	for _, item := range req.Names {
 		global.LOG.Infof("start container %s operation %s", item, req.Operation)
 		switch req.Operation {
@@ -651,7 +604,6 @@ func (u *ContainerService) ContainerLogClean(req dto.OperationWithName) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	ctx := context.Background()
 	containerItem, err := client.ContainerInspect(ctx, req.Name)
 	if err != nil {
@@ -765,85 +717,11 @@ func (u *ContainerService) ContainerLogs(wsConn *websocket.Conn, containerType,
 	return nil
 }
 
-func (u *ContainerService) DownloadContainerLogs(containerType, container, since, tail string, c *gin.Context) error {
-	if cmd.CheckIllegal(container, since, tail) {
-		return buserr.New(constant.ErrCmdIllegal)
-	}
-	commandName := "docker"
-	commandArg := []string{"logs", container}
-	if containerType == "compose" {
-		commandName = "docker-compose"
-		commandArg = []string{"-f", container, "logs"}
-	}
-	if tail != "0" {
-		commandArg = append(commandArg, "--tail")
-		commandArg = append(commandArg, tail)
-	}
-	if since != "all" {
-		commandArg = append(commandArg, "--since")
-		commandArg = append(commandArg, since)
-	}
-
-	cmd := exec.Command(commandName, commandArg...)
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		_ = cmd.Process.Signal(syscall.SIGTERM)
-		return err
-	}
-	cmd.Stderr = cmd.Stdout
-	if err := cmd.Start(); err != nil {
-		_ = cmd.Process.Signal(syscall.SIGTERM)
-		return err
-	}
-
-	tempFile, err := os.CreateTemp("", "cmd_output_*.txt")
-	if err != nil {
-		return err
-	}
-	defer tempFile.Close()
-	defer func() {
-		if err := os.Remove(tempFile.Name()); err != nil {
-			global.LOG.Errorf("os.Remove() failed: %v", err)
-		}
-	}()
-	errCh := make(chan error)
-	go func() {
-		scanner := bufio.NewScanner(stdout)
-		for scanner.Scan() {
-			line := scanner.Text()
-			if _, err := tempFile.WriteString(line + "\n"); err != nil {
-				errCh <- err
-				return
-			}
-		}
-		if err := scanner.Err(); err != nil {
-			errCh <- err
-			return
-		}
-		errCh <- nil
-	}()
-	select {
-	case err := <-errCh:
-		if err != nil {
-			global.LOG.Errorf("Error: %v", err)
-		}
-	case <-time.After(3 * time.Second):
-		global.LOG.Errorf("Timeout reached")
-	}
-	info, _ := tempFile.Stat()
-
-	c.Header("Content-Length", strconv.FormatInt(info.Size(), 10))
-	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(info.Name()))
-	http.ServeContent(c.Writer, c.Request, info.Name(), info.ModTime(), tempFile)
-	return nil
-}
-
 func (u *ContainerService) ContainerStats(id string) (*dto.ContainerStats, error) {
 	client, err := docker.NewDockerClient()
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	res, err := client.ContainerStats(context.TODO(), id, false)
 	if err != nil {
 		return nil, err
@@ -879,7 +757,6 @@ func (u *ContainerService) LoadContainerLogs(req dto.OperationWithNameAndType) s
 		if err != nil {
 			return ""
 		}
-		defer cli.Close()
 		options := container.ListOptions{All: true}
 		options.Filters = filters.NewArgs()
 		options.Filters.Add("label", fmt.Sprintf("%s=%s", composeProjectLabel, req.Name))
@@ -898,10 +775,6 @@ func (u *ContainerService) LoadContainerLogs(req dto.OperationWithNameAndType) s
 				break
 			}
 		}
-		if len(containers) == 0 {
-			composeItem, _ := composeRepo.GetRecord(commonRepo.WithByName(req.Name))
-			filePath = composeItem.Path
-		}
 	}
 	if _, err := os.Stat(filePath); err != nil {
 		return ""
@@ -967,15 +840,16 @@ func calculateNetwork(network map[string]types.NetworkStats) (float64, float64)
 	return rx, tx
 }
 
-func checkImageExist(client *client.Client, imageItem string) bool {
-	images, err := client.ImageList(context.Background(), image.ListOptions{})
+func checkImageExist(client *client.Client, image string) bool {
+	images, err := client.ImageList(context.Background(), types.ImageListOptions{})
 	if err != nil {
+		fmt.Println(err)
 		return false
 	}
 
 	for _, img := range images {
 		for _, tag := range img.RepoTags {
-			if tag == imageItem || tag == imageItem+":latest" {
+			if tag == image || tag == image+":latest" {
 				return true
 			}
 		}
@@ -983,12 +857,12 @@ func checkImageExist(client *client.Client, imageItem string) bool {
 	return false
 }
 
-func pullImages(ctx context.Context, client *client.Client, imageName string) error {
-	options := image.PullOptions{}
+func pullImages(ctx context.Context, client *client.Client, image string) error {
+	options := types.ImagePullOptions{}
 	repos, _ := imageRepoRepo.List()
 	if len(repos) != 0 {
 		for _, repo := range repos {
-			if strings.HasPrefix(imageName, repo.DownloadUrl) && repo.Auth {
+			if strings.HasPrefix(image, repo.DownloadUrl) && repo.Auth {
 				authConfig := registry.AuthConfig{
 					Username: repo.Username,
 					Password: repo.Password,
@@ -1001,13 +875,8 @@ func pullImages(ctx context.Context, client *client.Client, imageName string) er
 				options.RegistryAuth = authStr
 			}
 		}
-	} else {
-		hasAuth, authStr := loadAuthInfo(imageName)
-		if hasAuth {
-			options.RegistryAuth = authStr
-		}
 	}
-	out, err := client.ImagePull(ctx, imageName, options)
+	out, err := client.ImagePull(ctx, image, options)
 	if err != nil {
 		return err
 	}
@@ -1028,11 +897,12 @@ func loadCpuAndMem(client *client.Client, container string) dto.ContainerListSta
 		return data
 	}
 
-	defer res.Body.Close()
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
+		res.Body.Close()
 		return data
 	}
+	res.Body.Close()
 	var stats *types.StatsJSON
 	if err := json.Unmarshal(body, &stats); err != nil {
 		return data
@@ -1141,7 +1011,7 @@ func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *types
 		}
 	} else {
 		if req.Ipv4 != "" || req.Ipv6 != "" {
-			return nil, nil, nil, fmt.Errorf("please set up the network")
+			return nil, nil, nil, fmt.Errorf("Please set up the network")
 		}
 		networkConf = network.NetworkingConfig{}
 	}
@@ -1195,7 +1065,7 @@ func reCreateAfterUpdate(name string, client *client.Client, config *container.C
 	if err := client.ContainerStart(ctx, oldContainer.ID, container.StartOptions{}); err != nil {
 		global.LOG.Errorf("restart after container update failed, err: %v", err)
 	}
-	global.LOG.Info("recreate after container update successful")
+	global.LOG.Errorf("recreate after container update successful")
 }
 
 func loadVolumeBinds(binds []types.MountPoint) []dto.VolumeHelper {
@@ -1218,65 +1088,7 @@ func loadVolumeBinds(binds []types.MountPoint) []dto.VolumeHelper {
 	return datas
 }
 
-func loadPortByInspect(id string, client *client.Client) ([]types.Port, error) {
-	container, err := client.ContainerInspect(context.Background(), id)
-	if err != nil {
-		return nil, err
-	}
-	var itemPorts []types.Port
-	for key, val := range container.ContainerJSONBase.HostConfig.PortBindings {
-		if !strings.Contains(string(key), "/") {
-			continue
-		}
-		item := strings.Split(string(key), "/")
-		itemPort, _ := strconv.ParseUint(item[0], 10, 16)
-
-		for _, itemVal := range val {
-			publicPort, _ := strconv.ParseUint(itemVal.HostPort, 10, 16)
-			itemPorts = append(itemPorts, types.Port{PrivatePort: uint16(itemPort), Type: item[1], PublicPort: uint16(publicPort), IP: itemVal.HostIP})
-		}
-	}
-	return itemPorts, nil
-}
-
-func loadContainerPortForInfo(itemPorts []types.Port) []dto.PortHelper {
-	var exposedPorts []dto.PortHelper
-	samePortMap := make(map[string]dto.PortHelper)
-	ports := transPortToStr(itemPorts)
-	var itemPort dto.PortHelper
-	for _, item := range ports {
-		itemStr := strings.Split(item, "->")
-		if len(itemStr) < 2 {
-			continue
-		}
-		lastIndex := strings.LastIndex(itemStr[0], ":")
-		if lastIndex == -1 {
-			itemPort.HostPort = itemStr[0]
-		} else {
-			itemPort.HostIP = itemStr[0][0:lastIndex]
-			itemPort.HostPort = itemStr[0][lastIndex+1:]
-		}
-		itemContainer := strings.Split(itemStr[1], "/")
-		if len(itemContainer) != 2 {
-			continue
-		}
-		itemPort.ContainerPort = itemContainer[0]
-		itemPort.Protocol = itemContainer[1]
-		keyItem := fmt.Sprintf("%s->%s/%s", itemPort.HostPort, itemPort.ContainerPort, itemPort.Protocol)
-		if val, ok := samePortMap[keyItem]; ok {
-			val.HostIP = ""
-			samePortMap[keyItem] = val
-		} else {
-			samePortMap[keyItem] = itemPort
-		}
-	}
-	for _, val := range samePortMap {
-		exposedPorts = append(exposedPorts, val)
-	}
-	return exposedPorts
-}
-
-func transPortToStr(ports []types.Port) []string {
+func loadContainerPort(ports []types.Port) []string {
 	var (
 		ipv4Ports []types.Port
 		ipv6Ports []types.Port

backend/app/service/container_compose.go

@@ -4,9 +4,8 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
-	"gopkg.in/yaml.v3"
+	"github.com/docker/docker/api/types/container"
 	"io"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
@@ -14,8 +13,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/docker/docker/api/types/container"
-
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
@@ -33,12 +30,6 @@ const composeConfigLabel = "com.docker.compose.project.config_files"
 const composeWorkdirLabel = "com.docker.compose.project.working_dir"
 const composeCreatedBy = "createdBy"
 
-type DockerCompose struct {
-	Version  string                            `yaml:"version"`
-	Services map[string]map[string]interface{} `yaml:"services"`
-	Networks map[string]interface{}            `yaml:"networks"`
-}
-
 func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface{}, error) {
 	var (
 		records   []dto.ComposeInfo
@@ -48,7 +39,6 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 	if err != nil {
 		return 0, nil, err
 	}
-	defer client.Close()
 
 	options := container.ListOptions{All: true}
 	options.Filters = filters.NewArgs()
@@ -60,20 +50,6 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 	}
 
 	composeCreatedByLocal, _ := composeRepo.ListRecord()
-
-	composeLocalMap := make(map[string]dto.ComposeInfo)
-	for _, localItem := range composeCreatedByLocal {
-		composeItemLocal := dto.ComposeInfo{
-			ContainerNumber: 0,
-			CreatedAt:       localItem.CreatedAt.Format(constant.DateTimeLayout),
-			ConfigFile:      localItem.Path,
-			Workdir:         strings.TrimSuffix(localItem.Path, "/docker-compose.yml"),
-		}
-		composeItemLocal.CreatedBy = "1Panel"
-		composeItemLocal.Path = localItem.Path
-		composeLocalMap[localItem.Name] = composeItemLocal
-	}
-
 	composeMap := make(map[string]dto.ComposeInfo)
 	for _, container := range list {
 		if name, ok := container.Labels[composeProjectLabel]; ok {
@@ -81,7 +57,7 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 				ContainerID: container.ID,
 				Name:        container.Names[0][1:],
 				State:       container.State,
-				CreateTime:  time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
+				CreateTime:  time.Unix(container.Created, 0).Format("2006-01-02 15:04:05"),
 			}
 			if compose, has := composeMap[name]; has {
 				compose.ContainerNumber++
@@ -92,7 +68,7 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 				workdir := container.Labels[composeWorkdirLabel]
 				composeItem := dto.ComposeInfo{
 					ContainerNumber: 1,
-					CreatedAt:       time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
+					CreatedAt:       time.Unix(container.Created, 0).Format("2006-01-02 15:04:05"),
 					ConfigFile:      config,
 					Workdir:         workdir,
 					Containers:      []dto.ComposeContainer{containerItem},
@@ -117,24 +93,12 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 			}
 		}
 	}
-
-	mergedMap := make(map[string]dto.ComposeInfo)
-	for key, localItem := range composeLocalMap {
-		mergedMap[key] = localItem
-	}
-	for key, item := range composeMap {
-		if existingItem, exists := mergedMap[key]; exists {
-			if item.ContainerNumber > 0 {
-				if existingItem.ContainerNumber <= 0 {
-					mergedMap[key] = item
-				}
-			}
-		} else {
-			mergedMap[key] = item
+	for _, item := range composeCreatedByLocal {
+		if err := composeRepo.DeleteRecord(commonRepo.WithByID(item.ID)); err != nil {
+			global.LOG.Error(err)
 		}
 	}
-
-	for key, value := range mergedMap {
+	for key, value := range composeMap {
 		value.Name = key
 		records = append(records, value)
 	}
@@ -183,59 +147,6 @@ func (u *ContainerService) TestCompose(req dto.ComposeCreate) (bool, error) {
 	return true, nil
 }
 
-func formatYAML(data []byte) []byte {
-	return []byte(strings.ReplaceAll(string(data), "\t", "  "))
-}
-
-func updateDockerComposeWithEnv(req dto.ComposeCreate) error {
-	data, err := ioutil.ReadFile(req.Path)
-	if err != nil {
-		return fmt.Errorf("failed to read docker-compose.yml: %v", err)
-	}
-	var composeItem DockerCompose
-	if err := yaml.Unmarshal(data, &composeItem); err != nil {
-		return fmt.Errorf("failed to parse docker-compose.yml: %v", err)
-	}
-	for serviceName, service := range composeItem.Services {
-		envMap := make(map[string]string)
-		if existingEnv, exists := service["environment"].([]interface{}); exists {
-			for _, env := range existingEnv {
-				envStr := env.(string)
-				parts := strings.SplitN(envStr, "=", 2)
-				if len(parts) == 2 {
-					envMap[parts[0]] = parts[1]
-				}
-			}
-		}
-		for _, env := range req.Env {
-			parts := strings.SplitN(env, "=", 2)
-			if len(parts) == 2 {
-				envMap[parts[0]] = parts[1]
-			}
-		}
-		envVars := []string{}
-		for key, value := range envMap {
-			envVars = append(envVars, key+"="+value)
-		}
-		service["environment"] = envVars
-		composeItem.Services[serviceName] = service
-	}
-	if composeItem.Networks != nil {
-		for key := range composeItem.Networks {
-			composeItem.Networks[key] = map[string]interface{}{}
-		}
-	}
-	newData, err := yaml.Marshal(&composeItem)
-	if err != nil {
-		return fmt.Errorf("failed to marshal docker-compose.yml: %v", err)
-	}
-	formattedData := formatYAML(newData)
-	if err := ioutil.WriteFile(req.Path, formattedData, 0644); err != nil {
-		return fmt.Errorf("failed to write docker-compose.yml: %v", err)
-	}
-	return nil
-}
-
 func (u *ContainerService) CreateCompose(req dto.ComposeCreate) (string, error) {
 	if cmd.CheckIllegal(req.Name, req.Path) {
 		return "", buserr.New(constant.ErrCmdIllegal)
@@ -255,17 +166,11 @@ func (u *ContainerService) CreateCompose(req dto.ComposeCreate) (string, error)
 			return "", err
 		}
 	}
-	logItem := fmt.Sprintf("%s/compose_create_%s_%s.log", dockerLogDir, req.Name, time.Now().Format(constant.DateTimeSlimLayout))
+	logItem := fmt.Sprintf("%s/compose_create_%s_%s.log", dockerLogDir, req.Name, time.Now().Format("20060102150405"))
 	file, err := os.OpenFile(logItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
 	if err != nil {
 		return "", err
 	}
-	if len(req.Env) > 0 {
-		if err := updateDockerComposeWithEnv(req); err != nil {
-			fmt.Printf("failed to update docker-compose.yml with env: %v\n", err)
-			return "", err
-		}
-	}
 	go func() {
 		defer file.Close()
 		cmd := exec.Command("docker-compose", "-f", req.Path, "up", "-d")
@@ -279,7 +184,7 @@ func (u *ContainerService) CreateCompose(req dto.ComposeCreate) (string, error)
 			return
 		}
 		global.LOG.Infof("docker-compose up %s successful!", req.Name)
-		_ = composeRepo.CreateRecord(&model.Compose{Name: req.Name, Path: req.Path})
+		_ = composeRepo.CreateRecord(&model.Compose{Name: req.Name})
 		_, _ = file.WriteString("docker-compose up successful!")
 	}()
 
@@ -293,87 +198,20 @@ func (u *ContainerService) ComposeOperation(req dto.ComposeOperation) error {
 	if _, err := os.Stat(req.Path); err != nil {
 		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
 	}
-	if req.Operation == "up" {
-		if stdout, err := compose.Up(req.Path); err != nil {
-			return errors.New(string(stdout))
-		}
-	} else {
-		if stdout, err := compose.Operate(req.Path, req.Operation); err != nil {
-			return errors.New(string(stdout))
-		}
+	if stdout, err := compose.Operate(req.Path, req.Operation); err != nil {
+		return errors.New(string(stdout))
 	}
 	global.LOG.Infof("docker-compose %s %s successful", req.Operation, req.Name)
 	if req.Operation == "down" {
+		_ = composeRepo.DeleteRecord(commonRepo.WithByName(req.Name))
 		if req.WithFile {
-			_ = composeRepo.DeleteRecord(commonRepo.WithByName(req.Name))
 			_ = os.RemoveAll(path.Dir(req.Path))
-		} else {
-			composeItem, _ := composeRepo.GetRecord(commonRepo.WithByName(req.Name))
-			if composeItem.Path == "" {
-				upMap := make(map[string]interface{})
-				upMap["path"] = req.Path
-				_ = composeRepo.UpdateRecord(req.Name, upMap)
-			}
 		}
 	}
 
 	return nil
 }
 
-func updateComposeWithEnv(req dto.ComposeUpdate) error {
-	var composeItem DockerCompose
-	if err := yaml.Unmarshal([]byte(req.Content), &composeItem); err != nil {
-		return fmt.Errorf("failed to parse docker-compose content: %v", err)
-	}
-	for serviceName, service := range composeItem.Services {
-		envMap := make(map[string]string)
-		for _, env := range req.Env {
-			parts := strings.SplitN(env, "=", 2)
-			if len(parts) == 2 {
-				envMap[parts[0]] = parts[1]
-			}
-		}
-		newEnvVars := []string{}
-		if existingEnv, exists := service["environment"].([]interface{}); exists {
-			for _, env := range existingEnv {
-				envStr := env.(string)
-				parts := strings.SplitN(envStr, "=", 2)
-				if len(parts) == 2 {
-					key := parts[0]
-					if value, found := envMap[key]; found {
-						newEnvVars = append(newEnvVars, key+"="+value)
-						delete(envMap, key)
-					} else {
-						newEnvVars = append(newEnvVars, envStr)
-					}
-				}
-			}
-		}
-		for key, value := range envMap {
-			newEnvVars = append(newEnvVars, key+"="+value)
-		}
-		if len(newEnvVars) > 0 {
-			service["environment"] = newEnvVars
-		} else {
-			delete(service, "environment")
-		}
-		composeItem.Services[serviceName] = service
-	}
-	if composeItem.Networks != nil {
-		for key := range composeItem.Networks {
-			composeItem.Networks[key] = map[string]interface{}{}
-		}
-	}
-	newData, err := yaml.Marshal(&composeItem)
-	if err != nil {
-		return fmt.Errorf("failed to marshal docker-compose.yml: %v", err)
-	}
-	if err := ioutil.WriteFile(req.Path, newData, 0644); err != nil {
-		return fmt.Errorf("failed to write docker-compose.yml to path: %v", err)
-	}
-	return nil
-}
-
 func (u *ContainerService) ComposeUpdate(req dto.ComposeUpdate) error {
 	if cmd.CheckIllegal(req.Name, req.Path) {
 		return buserr.New(constant.ErrCmdIllegal)
@@ -382,20 +220,21 @@ func (u *ContainerService) ComposeUpdate(req dto.ComposeUpdate) error {
 	if err != nil {
 		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
 	}
-	if len(req.Env) > 0 {
-		if err := updateComposeWithEnv(req); err != nil {
-			return fmt.Errorf("failed to update docker-compose with env: %v", err)
+	file, err := os.OpenFile(req.Path, os.O_WRONLY|os.O_TRUNC, 0640)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	write := bufio.NewWriter(file)
+	_, _ = write.WriteString(req.Content)
+	write.Flush()
+
+	global.LOG.Infof("docker-compose.yml %s has been replaced, now start to docker-compose restart", req.Path)
+	if stdout, err := compose.Down(req.Path); err != nil {
+		if err := recreateCompose(string(oldFile), req.Path); err != nil {
+			return fmt.Errorf("update failed when handle compose down, err: %s, recreate failed: %v", string(stdout), err)
 		}
-	} else {
-		file, err := os.OpenFile(req.Path, os.O_WRONLY|os.O_TRUNC, 0640)
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		write := bufio.NewWriter(file)
-		_, _ = write.WriteString(req.Content)
-		write.Flush()
-		global.LOG.Infof("docker-compose.yml %s has been replaced", req.Path)
+		return fmt.Errorf("update failed when handle compose down, err: %s", string(stdout))
 	}
 	if stdout, err := compose.Up(req.Path); err != nil {
 		if err := recreateCompose(string(oldFile), req.Path); err != nil {

backend/app/service/container_network.go

@@ -19,7 +19,6 @@ func (u *ContainerService) PageNetwork(req dto.SearchWithPage) (int64, interface
 	if err != nil {
 		return 0, nil, err
 	}
-	defer client.Close()
 	list, err := client.NetworkList(context.TODO(), types.NetworkListOptions{})
 	if err != nil {
 		return 0, nil, err
@@ -82,7 +81,6 @@ func (u *ContainerService) ListNetwork() ([]dto.Options, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	list, err := client.NetworkList(context.TODO(), types.NetworkListOptions{})
 	if err != nil {
 		return nil, err
@@ -102,7 +100,6 @@ func (u *ContainerService) DeleteNetwork(req dto.BatchDelete) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	for _, id := range req.Names {
 		if err := client.NetworkRemove(context.TODO(), id); err != nil {
 			if strings.Contains(err.Error(), "has active endpoints") {
@@ -118,7 +115,6 @@ func (u *ContainerService) CreateNetwork(req dto.NetworkCreate) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	var (
 		ipams    []network.IPAMConfig
 		enableV6 bool

backend/app/service/container_volume.go

@@ -52,7 +52,7 @@ func (u *ContainerService) PageVolume(req dto.SearchWithPage) (int64, interface{
 		records = list.Volumes[start:end]
 	}
 
-	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
+	nyc, _ := time.LoadLocation(common.LoadTimeZone())
 	for _, item := range records {
 		tag := make([]string, 0)
 		for _, val := range item.Labels {
@@ -82,7 +82,6 @@ func (u *ContainerService) ListVolume() ([]dto.Options, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer client.Close()
 	list, err := client.VolumeList(context.TODO(), volume.ListOptions{})
 	if err != nil {
 		return nil, err
@@ -103,7 +102,6 @@ func (u *ContainerService) DeleteVolume(req dto.BatchDelete) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	for _, id := range req.Names {
 		if err := client.VolumeRemove(context.TODO(), id, true); err != nil {
 			if strings.Contains(err.Error(), "volume is in use") {
@@ -119,7 +117,6 @@ func (u *ContainerService) CreateVolume(req dto.VolumeCreate) error {
 	if err != nil {
 		return err
 	}
-	defer client.Close()
 	arg := filters.NewArgs()
 	arg.Add("name", req.Name)
 	vos, _ := client.VolumeList(context.TODO(), volume.ListOptions{Filters: arg})

backend/app/service/cornjob.go

@@ -21,7 +21,7 @@ import (
 type CronjobService struct{}
 
 type ICronjobService interface {
-	SearchWithPage(search dto.PageCronjob) (int64, interface{}, error)
+	SearchWithPage(search dto.SearchWithPage) (int64, interface{}, error)
 	SearchRecords(search dto.SearchRecord) (int64, interface{}, error)
 	Create(cronjobDto dto.CronjobCreate) error
 	HandleOnce(id uint) error
@@ -29,7 +29,7 @@ type ICronjobService interface {
 	UpdateStatus(id uint, status string) error
 	Delete(req dto.CronjobBatchDelete) error
 	Download(down dto.CronjobDownload) (string, error)
-	StartJob(cronjob *model.Cronjob, isUpdate bool) (string, error)
+	StartJob(cronjob *model.Cronjob) (string, error)
 	CleanRecord(req dto.CronjobClean) error
 
 	LoadRecordLog(req dto.OperateByID) string
@@ -39,7 +39,7 @@ func NewICronjobService() ICronjobService {
 	return &CronjobService{}
 }
 
-func (u *CronjobService) SearchWithPage(search dto.PageCronjob) (int64, interface{}, error) {
+func (u *CronjobService) SearchWithPage(search dto.SearchWithPage) (int64, interface{}, error) {
 	total, cronjobs, err := cronjobRepo.Page(search.Page, search.PageSize, commonRepo.WithLikeName(search.Info), commonRepo.WithOrderRuleBy(search.OrderBy, search.Order))
 	var dtoCronjobs []dto.CronjobInfo
 	for _, cronjob := range cronjobs {
@@ -49,7 +49,7 @@ func (u *CronjobService) SearchWithPage(search dto.PageCronjob) (int64, interfac
 		}
 		record, _ := cronjobRepo.RecordFirst(cronjob.ID)
 		if record.ID != 0 {
-			item.LastRecordTime = record.StartTime.Format(constant.DateTimeLayout)
+			item.LastRecordTime = record.StartTime.Format("2006-01-02 15:04:05")
 		} else {
 			item.LastRecordTime = "-"
 		}
@@ -71,7 +71,6 @@ func (u *CronjobService) SearchRecords(search dto.SearchRecord) (int64, interfac
 		if err := copier.Copy(&item, &record); err != nil {
 			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
 		}
-		item.StartTime = record.StartTime.Format(constant.DateTimeLayout)
 		dtoCronjobs = append(dtoCronjobs, item)
 	}
 	return total, dtoCronjobs, err
@@ -173,7 +172,6 @@ func (u *CronjobService) Create(cronjobDto dto.CronjobCreate) error {
 	if cronjob.ID != 0 {
 		return constant.ErrRecordExist
 	}
-	cronjob.Secret = cronjobDto.Secret
 	if err := copier.Copy(&cronjob, &cronjobDto); err != nil {
 		return errors.WithMessage(constant.ErrStructTransform, err.Error())
 	}
@@ -181,7 +179,7 @@ func (u *CronjobService) Create(cronjobDto dto.CronjobCreate) error {
 
 	global.LOG.Infof("create cronjob %s successful, spec: %s", cronjob.Name, cronjob.Spec)
 	spec := cronjob.Spec
-	entryIDs, err := u.StartJob(&cronjob, false)
+	entryIDs, err := u.StartJob(&cronjob)
 	if err != nil {
 		return err
 	}
@@ -193,8 +191,8 @@ func (u *CronjobService) Create(cronjobDto dto.CronjobCreate) error {
 	return nil
 }
 
-func (u *CronjobService) StartJob(cronjob *model.Cronjob, isUpdate bool) (string, error) {
-	if len(cronjob.EntryIDs) != 0 && isUpdate {
+func (u *CronjobService) StartJob(cronjob *model.Cronjob) (string, error) {
+	if len(cronjob.EntryIDs) != 0 {
 		ids := strings.Split(cronjob.EntryIDs, ",")
 		for _, id := range ids {
 			idItem, _ := strconv.Atoi(id)
@@ -251,7 +249,7 @@ func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
 	cronjob.Type = cronModel.Type
 	spec := cronjob.Spec
 	if cronModel.Status == constant.StatusEnable {
-		newEntryIDs, err := u.StartJob(&cronjob, true)
+		newEntryIDs, err := u.StartJob(&cronjob)
 		if err != nil {
 			return err
 		}
@@ -280,7 +278,6 @@ func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
 	upMap["backup_accounts"] = req.BackupAccounts
 	upMap["default_download"] = req.DefaultDownload
 	upMap["retain_copies"] = req.RetainCopies
-	upMap["secret"] = req.Secret
 	return cronjobRepo.Update(id, upMap)
 }
 
@@ -294,7 +291,7 @@ func (u *CronjobService) UpdateStatus(id uint, status string) error {
 		err      error
 	)
 	if status == constant.StatusEnable {
-		entryIDs, err = u.StartJob(&cronjob, false)
+		entryIDs, err = u.StartJob(&cronjob)
 		if err != nil {
 			return err
 		}
@@ -330,7 +327,7 @@ func mkdirAndWriteFile(cronjob *model.Cronjob, startTime time.Time, msg []byte)
 		}
 	}
 
-	path := fmt.Sprintf("%s/%s.log", dir, startTime.Format(constant.DateTimeSlimLayout))
+	path := fmt.Sprintf("%s/%s.log", dir, startTime.Format("20060102150405"))
 	global.LOG.Infof("cronjob %s has generated some logs %s", cronjob.Name, path)
 	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
 	if err != nil {

backend/app/service/cronjob_backup.go

@@ -17,20 +17,15 @@ import (
 
 func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time) error {
 	var apps []model.AppInstall
-	if strings.Contains(cronjob.AppID, "all") {
+	if cronjob.AppID == "all" {
 		apps, _ = appInstallRepo.ListBy()
 	} else {
-		appIds := strings.Split(cronjob.AppID, ",")
-		var idItems []uint
-		for i := 0; i < len(appIds); i++ {
-			itemID, _ := strconv.Atoi(appIds[i])
-			idItems = append(idItems, uint(itemID))
-		}
-		appItems, err := appInstallRepo.ListBy(commonRepo.WithIdsIn(idItems))
+		itemID, _ := (strconv.Atoi(cronjob.AppID))
+		app, err := appInstallRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
 		if err != nil {
 			return err
 		}
-		apps = appItems
+		apps = append(apps, app)
 	}
 	accountMap, err := loadClientMap(cronjob.BackupAccounts)
 	if err != nil {
@@ -45,8 +40,8 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time) e
 		record.DetailName = app.Name
 		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
 		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("app/%s/%s", app.App.Key, app.Name))
-		record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
-		if err := handleAppBackup(&app, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
+		record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+		if err := handleAppBackup(&app, backupDir, record.FileName); err != nil {
 			return err
 		}
 		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
@@ -78,8 +73,8 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 		record.DetailName = web.Alias
 		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
 		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("website/%s", web.PrimaryDomain))
-		record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", web.PrimaryDomain, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
-		if err := handleWebsiteBackup(&web, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
+		record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", web.PrimaryDomain, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+		if err := handleWebsiteBackup(&web, backupDir, record.FileName); err != nil {
 			return err
 		}
 		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
@@ -112,7 +107,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
 
 		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
-		record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
+		record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format("20060102150405")+common.RandStrAndNum(5))
 		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
 			if err := handleMysqlBackup(dbInfo.Database, dbInfo.DBType, dbInfo.Name, backupDir, record.FileName); err != nil {
 				return err
@@ -141,9 +136,9 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 	if err != nil {
 		return err
 	}
-	fileName := fmt.Sprintf("directory%s_%s.tar.gz", strings.ReplaceAll(cronjob.SourceDir, "/", "_"), startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
+	fileName := fmt.Sprintf("directory%s_%s.tar.gz", strings.ReplaceAll(cronjob.SourceDir, "/", "_"), startTime.Format("20060102150405")+common.RandStrAndNum(5))
 	backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("%s/%s", cronjob.Type, cronjob.Name))
-	if err := handleTar(cronjob.SourceDir, backupDir, fileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
+	if err := handleTar(cronjob.SourceDir, backupDir, fileName, cronjob.ExclusionRules); err != nil {
 		return err
 	}
 	var record model.BackupRecord
@@ -171,10 +166,10 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 	if err != nil {
 		return err
 	}
-	nameItem := startTime.Format(constant.DateTimeSlimLayout) + common.RandStrAndNum(5)
+	nameItem := startTime.Format("20060102150405") + common.RandStrAndNum(5)
 	fileName := fmt.Sprintf("system_log_%s.tar.gz", nameItem)
 	backupDir := path.Join(global.CONF.System.TmpDir, "log", nameItem)
-	if err := handleBackupLogs(backupDir, fileName, cronjob.Secret); err != nil {
+	if err := handleBackupLogs(backupDir, fileName); err != nil {
 		return err
 	}
 	var record model.BackupRecord
@@ -215,7 +210,7 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, startTime time.Ti
 		From:            record.BackupType,
 		DefaultDownload: cronjob.DefaultDownload,
 	}
-	name, err := NewISnapshotService().HandleSnapshot(true, logPath, req, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5), cronjob.Secret)
+	name, err := NewISnapshotService().HandleSnapshot(true, logPath, req, startTime.Format("20060102150405")+common.RandStrAndNum(5))
 	if err != nil {
 		return err
 	}
@@ -237,7 +232,7 @@ type databaseHelper struct {
 
 func loadDbsForJob(cronjob model.Cronjob) []databaseHelper {
 	var dbs []databaseHelper
-	if strings.Contains(cronjob.DBName, "all") {
+	if cronjob.DBName == "all" {
 		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
 			mysqlItems, _ := mysqlRepo.List()
 			for _, mysql := range mysqlItems {
@@ -259,42 +254,36 @@ func loadDbsForJob(cronjob model.Cronjob) []databaseHelper {
 		}
 		return dbs
 	}
-
-	dbNames := strings.Split(cronjob.DBName, ",")
-	for _, name := range dbNames {
-		itemID, _ := strconv.Atoi(name)
-		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
-			mysqlItem, _ := mysqlRepo.Get(commonRepo.WithByID(uint(itemID)))
-			dbs = append(dbs, databaseHelper{
-				DBType:   cronjob.DBType,
-				Database: mysqlItem.MysqlName,
-				Name:     mysqlItem.Name,
-			})
-		} else {
-			pgItem, _ := postgresqlRepo.Get(commonRepo.WithByID(uint(itemID)))
-			dbs = append(dbs, databaseHelper{
-				DBType:   cronjob.DBType,
-				Database: pgItem.PostgresqlName,
-				Name:     pgItem.Name,
-			})
-		}
+	itemID, _ := (strconv.Atoi(cronjob.DBName))
+	if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+		mysqlItem, _ := mysqlRepo.Get(commonRepo.WithByID(uint(itemID)))
+		dbs = append(dbs, databaseHelper{
+			DBType:   cronjob.DBType,
+			Database: mysqlItem.MysqlName,
+			Name:     mysqlItem.Name,
+		})
+	} else {
+		pgItem, _ := postgresqlRepo.Get(commonRepo.WithByID(uint(itemID)))
+		dbs = append(dbs, databaseHelper{
+			DBType:   cronjob.DBType,
+			Database: pgItem.PostgresqlName,
+			Name:     pgItem.Name,
+		})
 	}
 	return dbs
 }
 
 func loadWebsForJob(cronjob model.Cronjob) []model.Website {
 	var weblist []model.Website
-	if strings.Contains(cronjob.Website, "all") {
+	if cronjob.Website == "all" {
 		weblist, _ = websiteRepo.List()
 		return weblist
 	}
-	websites := strings.Split(cronjob.Website, ",")
-	var idItems []uint
-	for i := 0; i < len(websites); i++ {
-		itemID, _ := strconv.Atoi(websites[i])
-		idItems = append(idItems, uint(itemID))
+	itemID, _ := (strconv.Atoi(cronjob.Website))
+	webItem, _ := websiteRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
+	if webItem.ID != 0 {
+		weblist = append(weblist, webItem)
 	}
-	weblist, _ = websiteRepo.List(commonRepo.WithIdsIn(idItems))
 	return weblist
 }
 
@@ -314,7 +303,7 @@ func loadRecordPath(cronjob model.Cronjob, accountMap map[string]cronjobUploadHe
 	return source, backupType
 }
 
-func handleBackupLogs(targetDir, fileName string, secret string) error {
+func handleBackupLogs(targetDir, fileName string) error {
 	websites, err := websiteRepo.List()
 	if err != nil {
 		return err
@@ -387,7 +376,7 @@ func handleBackupLogs(targetDir, fileName string, secret string) error {
 	}
 	global.LOG.Debug("backup ssh log successful!")
 
-	if err := handleTar(targetDir, path.Dir(targetDir), fileName, "", secret); err != nil {
+	if err := handleTar(targetDir, path.Dir(targetDir), fileName, ""); err != nil {
 		return err
 	}
 	defer func() {

backend/app/service/cronjob_helper.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	pathUtils "path"
 	"strings"
 	"time"
 
@@ -125,13 +124,13 @@ func (u *CronjobService) handleNtpSync() error {
 	if err != nil {
 		return err
 	}
-	if err := ntp.UpdateSystemTime(ntime.Format(constant.DateTimeLayout)); err != nil {
+	if err := ntp.UpdateSystemTime(ntime.Format("2006-01-02 15:04:05")); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleTar(sourceDir, targetDir, name, exclusionRules string, secret string) error {
+func handleTar(sourceDir, targetDir, name, exclusionRules string) error {
 	if _, err := os.Stat(targetDir); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(targetDir, os.ModePerm); err != nil {
 			return err
@@ -140,6 +139,7 @@ func handleTar(sourceDir, targetDir, name, exclusionRules string, secret string)
 
 	excludes := strings.Split(exclusionRules, ",")
 	excludeRules := ""
+	excludes = append(excludes, "*.sock")
 	for _, exclude := range excludes {
 		if len(exclude) == 0 {
 			continue
@@ -158,20 +158,8 @@ func handleTar(sourceDir, targetDir, name, exclusionRules string, secret string)
 		path = sourceDir
 	}
 
-	commands := ""
-
-	if len(secret) != 0 {
-		extraCmd := "| openssl enc -aes-256-cbc -salt -k '" + secret + "' -out"
-		commands = fmt.Sprintf("tar --warning=no-file-changed --ignore-failed-read --exclude-from=<(find %s -type s -print) -zcf %s %s %s %s", sourceDir, " -"+excludeRules, path, extraCmd, targetDir+"/"+name)
-		global.LOG.Debug(strings.ReplaceAll(commands, fmt.Sprintf(" %s ", secret), "******"))
-	} else {
-		itemPrefix := pathUtils.Base(sourceDir)
-		if itemPrefix == "/" {
-			itemPrefix = ""
-		}
-		commands = fmt.Sprintf("tar --warning=no-file-changed --ignore-failed-read --exclude-from=<(find %s -type s -printf '%s' | sed 's|^|%s/|') -zcf %s %s %s", sourceDir, "%P\n", itemPrefix, targetDir+"/"+name, excludeRules, path)
-		global.LOG.Debug(commands)
-	}
+	commands := fmt.Sprintf("tar --warning=no-file-changed --ignore-failed-read -zcf %s %s %s", targetDir+"/"+name, excludeRules, path)
+	global.LOG.Debug(commands)
 	stdout, err := cmd.ExecWithTimeOut(commands, 24*time.Hour)
 	if err != nil {
 		if len(stdout) != 0 {
@@ -182,22 +170,15 @@ func handleTar(sourceDir, targetDir, name, exclusionRules string, secret string)
 	return nil
 }
 
-func handleUnTar(sourceFile, targetDir string, secret string) error {
+func handleUnTar(sourceFile, targetDir string) error {
 	if _, err := os.Stat(targetDir); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(targetDir, os.ModePerm); err != nil {
 			return err
 		}
 	}
-	commands := ""
-	if len(secret) != 0 {
-		extraCmd := "openssl enc -d -aes-256-cbc -k '" + secret + "' -in " + sourceFile + " | "
-		commands = fmt.Sprintf("%s tar -zxvf - -C %s", extraCmd, targetDir+" > /dev/null 2>&1")
-		global.LOG.Debug(strings.ReplaceAll(commands, fmt.Sprintf(" %s ", secret), "******"))
-	} else {
-		commands = fmt.Sprintf("tar zxvfC %s %s", sourceFile, targetDir)
-		global.LOG.Debug(commands)
-	}
 
+	commands := fmt.Sprintf("tar zxvfC %s %s", sourceFile, targetDir)
+	global.LOG.Debug(commands)
 	stdout, err := cmd.ExecWithTimeOut(commands, 24*time.Hour)
 	if err != nil {
 		global.LOG.Errorf("do handle untar failed, stdout: %s, err: %v", stdout, err)
@@ -228,7 +209,7 @@ func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime t
 			_ = os.MkdirAll(dstLogDir, 0755)
 		}
 
-		dstName := fmt.Sprintf("%s_log_%s.gz", website.PrimaryDomain, startTime.Format(constant.DateTimeSlimLayout))
+		dstName := fmt.Sprintf("%s_log_%s.gz", website.PrimaryDomain, startTime.Format("20060102150405"))
 		dstFilePath := path.Join(dstLogDir, dstName)
 		filePaths = append(filePaths, dstFilePath)
 
@@ -243,6 +224,7 @@ func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime t
 			_ = fileOp.WriteFile(srcErrorLogPath, strings.NewReader(""), 0755)
 		}
 		msg := i18n.GetMsgWithMap("CutWebsiteLogSuccess", map[string]interface{}{"name": website.PrimaryDomain, "path": dstFilePath})
+		global.LOG.Infof(msg)
 		msgs = append(msgs, msg)
 	}
 	u.removeExpiredLog(*cronjob)
@@ -329,6 +311,7 @@ func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, accountMap
 }
 
 func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap map[string]cronjobUploadHelper, record model.BackupRecord) {
+	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
 	var opts []repo.DBOption
 	opts = append(opts, commonRepo.WithByFrom("cronjob"))
 	opts = append(opts, backupRepo.WithByCronID(cronjob.ID))
@@ -363,6 +346,7 @@ func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap m
 }
 
 func (u *CronjobService) removeExpiredLog(cronjob model.Cronjob) {
+	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
 	records, _ := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(cronjob.ID)), commonRepo.WithOrderBy("created_at desc"))
 	if len(records) <= int(cronjob.RetainCopies) {
 		return
@@ -385,7 +369,7 @@ func (u *CronjobService) generateLogsPath(cronjob model.Cronjob, startTime time.
 		_ = os.MkdirAll(dir, os.ModePerm)
 	}
 
-	path := fmt.Sprintf("%s/%s.log", dir, startTime.Format(constant.DateTimeSlimLayout))
+	path := fmt.Sprintf("%s/%s.log", dir, startTime.Format("20060102150405"))
 	return path
 }
 

backend/app/service/dashboard.go

@@ -3,12 +3,6 @@ package service
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/shirou/gopsutil/v3/load"
-	"github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/net"
-	network "net"
-	"os"
 	"sort"
 	"strings"
 	"sync"
@@ -22,6 +16,9 @@ import (
 	"github.com/shirou/gopsutil/v3/cpu"
 	"github.com/shirou/gopsutil/v3/disk"
 	"github.com/shirou/gopsutil/v3/host"
+	"github.com/shirou/gopsutil/v3/load"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
 )
 
 type DashboardService struct{}
@@ -29,7 +26,7 @@ type DashboardService struct{}
 type IDashboardService interface {
 	LoadOsInfo() (*dto.OsInfo, error)
 	LoadBaseInfo(ioOption string, netOption string) (*dto.DashboardBase, error)
-	LoadCurrentInfo(req dto.DashboardReq) *dto.DashboardCurrent
+	LoadCurrentInfo(ioOption string, netOption string) *dto.DashboardCurrent
 
 	Restart(operation string) error
 }
@@ -67,11 +64,6 @@ func (u *DashboardService) LoadOsInfo() (*dto.OsInfo, error) {
 	baseInfo.KernelArch = hostInfo.KernelArch
 	baseInfo.KernelVersion = hostInfo.KernelVersion
 
-	diskInfo, err := disk.Usage(global.CONF.System.BaseDir)
-	if err == nil {
-		baseInfo.DiskSize = int64(diskInfo.Free)
-	}
-
 	if baseInfo.KernelArch == "armv7l" {
 		baseInfo.KernelArch = "armv7"
 	}
@@ -96,30 +88,17 @@ func (u *DashboardService) LoadBaseInfo(ioOption string, netOption string) (*dto
 	baseInfo.KernelVersion = hostInfo.KernelVersion
 	ss, _ := json.Marshal(hostInfo)
 	baseInfo.VirtualizationSystem = string(ss)
-	baseInfo.IpV4Addr = GetOutboundIP()
-	httpProxy := os.Getenv("http_proxy")
-	if httpProxy == "" {
-		httpProxy = os.Getenv("HTTP_PROXY")
-	}
-	if httpProxy != "" {
-		baseInfo.SystemProxy = httpProxy
-	}
-	baseInfo.SystemProxy = "noProxy"
+
 	appInstall, err := appInstallRepo.ListBy()
 	if err != nil {
 		return nil, err
 	}
-
 	baseInfo.AppInstalledNumber = len(appInstall)
-	postgresqlDbs, err := postgresqlRepo.List()
+	dbs, err := mysqlRepo.List()
 	if err != nil {
 		return nil, err
 	}
-	mysqlDbs, err := mysqlRepo.List()
-	if err != nil {
-		return nil, err
-	}
-	baseInfo.DatabaseNumber = len(mysqlDbs) + len(postgresqlDbs)
+	baseInfo.DatabaseNumber = len(dbs)
 	website, err := websiteRepo.GetBy()
 	if err != nil {
 		return nil, err
@@ -139,88 +118,78 @@ func (u *DashboardService) LoadBaseInfo(ioOption string, netOption string) (*dto
 	baseInfo.CPUCores, _ = cpu.Counts(false)
 	baseInfo.CPULogicalCores, _ = cpu.Counts(true)
 
-	baseInfo.CurrentInfo = *u.LoadCurrentInfo(dto.DashboardReq{
-		Scope:     "ioNet",
-		IoOption:  ioOption,
-		NetOption: netOption,
-	})
+	baseInfo.CurrentInfo = *u.LoadCurrentInfo(ioOption, netOption)
 	return &baseInfo, nil
 }
 
-func (u *DashboardService) LoadCurrentInfo(req dto.DashboardReq) *dto.DashboardCurrent {
+func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *dto.DashboardCurrent {
 	var currentInfo dto.DashboardCurrent
-	if req.Scope == "gpu" {
-		currentInfo.GPUData = loadGPUInfo()
-		currentInfo.XPUData = loadXpuInfo()
-	}
-
 	hostInfo, _ := host.Info()
 	currentInfo.Uptime = hostInfo.Uptime
-	if req.Scope == "basic" {
-		currentInfo.TimeSinceUptime = time.Now().Add(-time.Duration(hostInfo.Uptime) * time.Second).Format(constant.DateTimeLayout)
-		currentInfo.Procs = hostInfo.Procs
-		currentInfo.CPUTotal, _ = cpu.Counts(true)
-		totalPercent, _ := cpu.Percent(100*time.Millisecond, false)
-		if len(totalPercent) == 1 {
-			currentInfo.CPUUsedPercent = totalPercent[0]
-			currentInfo.CPUUsed = currentInfo.CPUUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	currentInfo.TimeSinceUptime = time.Now().Add(-time.Duration(hostInfo.Uptime) * time.Second).Format("2006-01-02 15:04:05")
+	currentInfo.Procs = hostInfo.Procs
+
+	currentInfo.CPUTotal, _ = cpu.Counts(true)
+	totalPercent, _ := cpu.Percent(0, false)
+	if len(totalPercent) == 1 {
+		currentInfo.CPUUsedPercent = totalPercent[0]
+		currentInfo.CPUUsed = currentInfo.CPUUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	}
+	currentInfo.CPUPercent, _ = cpu.Percent(0, true)
+
+	loadInfo, _ := load.Avg()
+	currentInfo.Load1 = loadInfo.Load1
+	currentInfo.Load5 = loadInfo.Load5
+	currentInfo.Load15 = loadInfo.Load15
+	currentInfo.LoadUsagePercent = loadInfo.Load1 / (float64(currentInfo.CPUTotal*2) * 0.75) * 100
+
+	memoryInfo, _ := mem.VirtualMemory()
+	currentInfo.MemoryTotal = memoryInfo.Total
+	currentInfo.MemoryAvailable = memoryInfo.Available
+	currentInfo.MemoryUsed = memoryInfo.Used
+	currentInfo.MemoryUsedPercent = memoryInfo.UsedPercent
+
+	swapInfo, _ := mem.SwapMemory()
+	currentInfo.SwapMemoryTotal = swapInfo.Total
+	currentInfo.SwapMemoryAvailable = swapInfo.Free
+	currentInfo.SwapMemoryUsed = swapInfo.Used
+	currentInfo.SwapMemoryUsedPercent = swapInfo.UsedPercent
+
+	currentInfo.DiskData = loadDiskInfo()
+	currentInfo.GPUData = loadGPUInfo()
+
+	if ioOption == "all" {
+		diskInfo, _ := disk.IOCounters()
+		for _, state := range diskInfo {
+			currentInfo.IOReadBytes += state.ReadBytes
+			currentInfo.IOWriteBytes += state.WriteBytes
+			currentInfo.IOCount += (state.ReadCount + state.WriteCount)
+			currentInfo.IOReadTime += state.ReadTime
+			currentInfo.IOWriteTime += state.WriteTime
+		}
+	} else {
+		diskInfo, _ := disk.IOCounters(ioOption)
+		for _, state := range diskInfo {
+			currentInfo.IOReadBytes += state.ReadBytes
+			currentInfo.IOWriteBytes += state.WriteBytes
+			currentInfo.IOCount += (state.ReadCount + state.WriteCount)
+			currentInfo.IOReadTime += state.ReadTime
+			currentInfo.IOWriteTime += state.WriteTime
 		}
-		currentInfo.CPUPercent, _ = cpu.Percent(100*time.Millisecond, true)
-
-		loadInfo, _ := load.Avg()
-		currentInfo.Load1 = loadInfo.Load1
-		currentInfo.Load5 = loadInfo.Load5
-		currentInfo.Load15 = loadInfo.Load15
-		currentInfo.LoadUsagePercent = loadInfo.Load1 / (float64(currentInfo.CPUTotal*2) * 0.75) * 100
-
-		memoryInfo, _ := mem.VirtualMemory()
-		currentInfo.MemoryTotal = memoryInfo.Total
-		currentInfo.MemoryAvailable = memoryInfo.Available
-		currentInfo.MemoryUsed = memoryInfo.Used
-		currentInfo.MemoryUsedPercent = memoryInfo.UsedPercent
-
-		swapInfo, _ := mem.SwapMemory()
-		currentInfo.SwapMemoryTotal = swapInfo.Total
-		currentInfo.SwapMemoryAvailable = swapInfo.Free
-		currentInfo.SwapMemoryUsed = swapInfo.Used
-		currentInfo.SwapMemoryUsedPercent = swapInfo.UsedPercent
-		currentInfo.DiskData = loadDiskInfo()
 	}
 
-	if req.Scope == "ioNet" {
-		if req.IoOption == "all" {
-			diskInfo, _ := disk.IOCounters()
-			for _, state := range diskInfo {
-				currentInfo.IOReadBytes += state.ReadBytes
-				currentInfo.IOWriteBytes += state.WriteBytes
-				currentInfo.IOCount += (state.ReadCount + state.WriteCount)
-				currentInfo.IOReadTime += state.ReadTime
-				currentInfo.IOWriteTime += state.WriteTime
-			}
-		} else {
-			diskInfo, _ := disk.IOCounters(req.IoOption)
-			for _, state := range diskInfo {
-				currentInfo.IOReadBytes += state.ReadBytes
-				currentInfo.IOWriteBytes += state.WriteBytes
-				currentInfo.IOCount += (state.ReadCount + state.WriteCount)
-				currentInfo.IOReadTime += state.ReadTime
-				currentInfo.IOWriteTime += state.WriteTime
-			}
+	if netOption == "all" {
+		netInfo, _ := net.IOCounters(false)
+		if len(netInfo) != 0 {
+			currentInfo.NetBytesSent = netInfo[0].BytesSent
+			currentInfo.NetBytesRecv = netInfo[0].BytesRecv
 		}
-
-		if req.NetOption == "all" {
-			netInfo, _ := net.IOCounters(false)
-			if len(netInfo) != 0 {
-				currentInfo.NetBytesSent = netInfo[0].BytesSent
-				currentInfo.NetBytesRecv = netInfo[0].BytesRecv
-			}
-		} else {
-			netInfo, _ := net.IOCounters(true)
-			for _, state := range netInfo {
-				if state.Name == req.NetOption {
-					currentInfo.NetBytesSent = state.BytesSent
-					currentInfo.NetBytesRecv = state.BytesRecv
-				}
+	} else {
+		netInfo, _ := net.IOCounters(true)
+		for _, state := range netInfo {
+			if state.Name == netOption {
+				currentInfo.NetBytesSent = state.BytesSent
+				currentInfo.NetBytesRecv = state.BytesRecv
 			}
 		}
 	}
@@ -229,18 +198,6 @@ func (u *DashboardService) LoadCurrentInfo(req dto.DashboardReq) *dto.DashboardC
 	return &currentInfo
 }
 
-func GetOutboundIP() string {
-	conn, err := network.Dial("udp", "8.8.8.8:80")
-
-	if err != nil {
-		return "IPNotFound"
-	}
-	defer conn.Close()
-
-	localAddr := conn.LocalAddr().(*network.UDPAddr)
-	return localAddr.IP.String()
-}
-
 type diskInfo struct {
 	Type   string
 	Mount  string
@@ -265,13 +222,10 @@ func loadDiskInfo() []dto.DiskInfo {
 		if len(fields) < 7 {
 			continue
 		}
-		if strings.HasPrefix(fields[6], "/snap") || len(strings.Split(fields[6], "/")) > 10 {
+		if fields[1] == "tmpfs" {
 			continue
 		}
-		if strings.TrimSpace(fields[1]) == "tmpfs" {
-			continue
-		}
-		if strings.Contains(fields[2], "K") {
+		if strings.Contains(fields[2], "M") || strings.Contains(fields[2], "K") {
 			continue
 		}
 		if strings.Contains(fields[6], "docker") {
@@ -286,7 +240,7 @@ func loadDiskInfo() []dto.DiskInfo {
 		if isExclude {
 			continue
 		}
-		mounts = append(mounts, diskInfo{Type: fields[1], Device: fields[0], Mount: strings.Join(fields[6:], " ")})
+		mounts = append(mounts, diskInfo{Type: fields[1], Device: fields[0], Mount: fields[6]})
 	}
 
 	var (
@@ -356,19 +310,3 @@ func loadGPUInfo() []dto.GPUInfo {
 	}
 	return data
 }
-
-func loadXpuInfo() []dto.XPUInfo {
-	list := xpack.LoadXpuInfo()
-	if len(list) == 0 {
-		return nil
-	}
-	var data []dto.XPUInfo
-	for _, gpu := range list {
-		var dataItem dto.XPUInfo
-		if err := copier.Copy(&dataItem, &gpu); err != nil {
-			continue
-		}
-		data = append(data, dataItem)
-	}
-	return data
-}

backend/app/service/database.go

@@ -7,8 +7,7 @@ import (
 	"path"
 
 	"github.com/1Panel-dev/1Panel/backend/utils/postgresql"
-	pgclient "github.com/1Panel-dev/1Panel/backend/utils/postgresql/client"
-	redisclient "github.com/1Panel-dev/1Panel/backend/utils/redis"
+	client2 "github.com/1Panel-dev/1Panel/backend/utils/postgresql/client"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
@@ -43,7 +42,6 @@ func (u *DatabaseService) SearchWithPage(search dto.DatabaseSearch) (int64, inte
 	total, dbs, err := databaseRepo.Page(search.Page, search.PageSize,
 		databaseRepo.WithTypeList(search.Type),
 		commonRepo.WithLikeName(search.Info),
-		commonRepo.WithOrderRuleBy(search.OrderBy, search.Order),
 		databaseRepo.WithoutByFrom("local"),
 	)
 	var datas []dto.DatabaseInfo
@@ -71,9 +69,6 @@ func (u *DatabaseService) Get(name string) (dto.DatabaseInfo, error) {
 
 func (u *DatabaseService) List(dbType string) ([]dto.DatabaseOption, error) {
 	dbs, err := databaseRepo.GetList(databaseRepo.WithTypeList(dbType))
-	if err != nil {
-		return nil, err
-	}
 	var datas []dto.DatabaseOption
 	for _, db := range dbs {
 		var item dto.DatabaseOption
@@ -118,7 +113,7 @@ func (u *DatabaseService) LoadItems(dbType string) ([]dto.DatabaseItem, error) {
 func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
 	switch req.Type {
 	case constant.AppPostgresql:
-		_, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
+		_, err := postgresql.NewPostgresqlClient(client2.DBInfo{
 			From:     "remote",
 			Address:  req.Address,
 			Port:     req.Port,
@@ -127,13 +122,6 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
 			Timeout:  6,
 		})
 		return err == nil
-	case constant.AppRedis:
-		_, err := redisclient.NewRedisClient(redisclient.DBInfo{
-			Address:  req.Address,
-			Port:     req.Port,
-			Password: req.Password,
-		})
-		return err == nil
 	case "mysql", "mariadb":
 		_, err := mysql.NewMysqlClient(client.DBInfo{
 			From:     "remote",
@@ -165,7 +153,7 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
 	}
 	switch req.Type {
 	case constant.AppPostgresql:
-		if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
+		if _, err := postgresql.NewPostgresqlClient(client2.DBInfo{
 			From:     "remote",
 			Address:  req.Address,
 			Port:     req.Port,
@@ -175,14 +163,6 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
 		}); err != nil {
 			return err
 		}
-	case constant.AppRedis:
-		if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
-			Address:  req.Address,
-			Port:     req.Port,
-			Password: req.Password,
-		}); err != nil {
-			return err
-		}
 	case "mysql", "mariadb":
 		if _, err := mysql.NewMysqlClient(client.DBInfo{
 			From:     "remote",
@@ -269,7 +249,7 @@ func (u *DatabaseService) Delete(req dto.DatabaseDelete) error {
 func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
 	switch req.Type {
 	case constant.AppPostgresql:
-		if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
+		if _, err := postgresql.NewPostgresqlClient(client2.DBInfo{
 			From:     "remote",
 			Address:  req.Address,
 			Port:     req.Port,
@@ -279,14 +259,6 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
 		}); err != nil {
 			return err
 		}
-	case constant.AppRedis:
-		if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
-			Address:  req.Address,
-			Port:     req.Port,
-			Password: req.Password,
-		}); err != nil {
-			return err
-		}
 	case "mysql", "mariadb":
 		if _, err := mysql.NewMysqlClient(client.DBInfo{
 			From:     "remote",

backend/app/service/database_mysql.go

@@ -141,10 +141,6 @@ func (u *MysqlService) Create(ctx context.Context, req dto.MysqlDBCreate) (*mode
 }
 
 func (u *MysqlService) BindUser(req dto.BindUser) error {
-	if cmd.CheckIllegal(req.Username, req.Password, req.Permission) {
-		return buserr.New(constant.ErrCmdIllegal)
-	}
-
 	dbItem, err := mysqlRepo.Get(mysqlRepo.WithByMysqlName(req.Database), commonRepo.WithByName(req.DB))
 	if err != nil {
 		return err
@@ -200,9 +196,6 @@ func (u *MysqlService) LoadFromRemote(req dto.MysqlLoadDB) error {
 		for i := 0; i < len(databases); i++ {
 			if strings.EqualFold(databases[i].Name, data.Name) && strings.EqualFold(databases[i].MysqlName, data.MysqlName) {
 				hasOld = true
-				if databases[i].IsDelete {
-					_ = mysqlRepo.Update(databases[i].ID, map[string]interface{}{"is_delete": false})
-				}
 				deleteList = append(deleteList[:i], deleteList[i+1:]...)
 				break
 			}
@@ -247,7 +240,7 @@ func (u *MysqlService) DeleteCheck(req dto.MysqlDBDeleteCheck) ([]string, error)
 			}
 		}
 	} else {
-		apps, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(db.ID), appRepo.WithKey(req.Type))
+		apps, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(db.ID))
 		for _, app := range apps {
 			appInstall, _ := appInstallRepo.GetFirst(commonRepo.WithByID(app.AppInstallId))
 			if appInstall.ID != 0 {
@@ -370,17 +363,6 @@ func (u *MysqlService) ChangePassword(req dto.ChangeDBInfo) error {
 	if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
 		return err
 	}
-	if req.From == "local" {
-		remote, err := databaseRepo.Get(commonRepo.WithByName(req.Database))
-		if err != nil {
-			return err
-		}
-		pass, err := encrypt.StringEncrypt(req.Value)
-		if err != nil {
-			return fmt.Errorf("decrypt database password failed, err: %v", err)
-		}
-		_ = databaseRepo.Update(remote.ID, map[string]interface{}{"password": pass})
-	}
 	return nil
 }
 
@@ -474,7 +456,7 @@ func (u *MysqlService) LoadRemoteAccess(req dto.OperationWithNameAndType) (bool,
 	if err != nil {
 		return false, err
 	}
-	hosts, err := executeSqlForRows(app.ContainerName, app.Key, app.Password, "select host from mysql.user where user='root';")
+	hosts, err := executeSqlForRows(app.ContainerName, app.Password, "select host from mysql.user where user='root';")
 	if err != nil {
 		return false, err
 	}
@@ -492,7 +474,7 @@ func (u *MysqlService) LoadVariables(req dto.OperationWithNameAndType) (*dto.Mys
 	if err != nil {
 		return nil, err
 	}
-	variableMap, err := executeSqlForMaps(app.ContainerName, app.Key, app.Password, "show global variables;")
+	variableMap, err := executeSqlForMaps(app.ContainerName, app.Password, "show global variables;")
 	if err != nil {
 		return nil, err
 	}
@@ -511,7 +493,7 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 		return nil, err
 	}
 
-	statusMap, err := executeSqlForMaps(app.ContainerName, app.Key, app.Password, "show global status;")
+	statusMap, err := executeSqlForMaps(app.ContainerName, app.Password, "show global status;")
 	if err != nil {
 		return nil, err
 	}
@@ -525,22 +507,19 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 
 	if value, ok := statusMap["Run"]; ok {
 		uptime, _ := strconv.Atoi(value)
-		info.Run = time.Unix(time.Now().Unix()-int64(uptime), 0).Format(constant.DateTimeLayout)
+		info.Run = time.Unix(time.Now().Unix()-int64(uptime), 0).Format("2006-01-02 15:04:05")
 	} else {
 		if value, ok := statusMap["Uptime"]; ok {
 			uptime, _ := strconv.Atoi(value)
-			info.Run = time.Unix(time.Now().Unix()-int64(uptime), 0).Format(constant.DateTimeLayout)
+			info.Run = time.Unix(time.Now().Unix()-int64(uptime), 0).Format("2006-01-02 15:04:05")
 		}
 	}
 
 	info.File = "OFF"
 	info.Position = "OFF"
-	rows, err := executeSqlForRows(app.ContainerName, app.Key, app.Password, "show master status;")
+	rows, err := executeSqlForRows(app.ContainerName, app.Password, "show master status;")
 	if err != nil {
-		rows, err = executeSqlForRows(app.ContainerName, app.Key, app.Password, "SHOW BINARY LOG STATUS;")
-		if err != nil {
-			return nil, err
-		}
+		return nil, err
 	}
 	if len(rows) > 2 {
 		itemValue := strings.Split(rows[1], "\t")
@@ -553,8 +532,8 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 	return &info, nil
 }
 
-func executeSqlForMaps(containerName, dbType, password, command string) (map[string]string, error) {
-	cmd := exec.Command("docker", "exec", containerName, dbType, "-uroot", "-p"+password, "-e", command)
+func executeSqlForMaps(containerName, password, command string) (map[string]string, error) {
+	cmd := exec.Command("docker", "exec", containerName, "mysql", "-uroot", "-p"+password, "-e", command)
 	stdout, err := cmd.CombinedOutput()
 	stdStr := strings.ReplaceAll(string(stdout), "mysql: [Warning] Using a password on the command line interface can be insecure.\n", "")
 	if err != nil || strings.HasPrefix(string(stdStr), "ERROR ") {
@@ -572,8 +551,8 @@ func executeSqlForMaps(containerName, dbType, password, command string) (map[str
 	return rowMap, nil
 }
 
-func executeSqlForRows(containerName, dbType, password, command string) ([]string, error) {
-	cmd := exec.Command("docker", "exec", containerName, dbType, "-uroot", "-p"+password, "-e", command)
+func executeSqlForRows(containerName, password, command string) ([]string, error) {
+	cmd := exec.Command("docker", "exec", containerName, "mysql", "-uroot", "-p"+password, "-e", command)
 	stdout, err := cmd.CombinedOutput()
 	stdStr := strings.ReplaceAll(string(stdout), "mysql: [Warning] Using a password on the command line interface can be insecure.\n", "")
 	if err != nil || strings.HasPrefix(string(stdStr), "ERROR ") {
@@ -635,7 +614,6 @@ func LoadMysqlClientByFrom(database string) (mysql.MysqlClient, string, error) {
 	if err != nil {
 		return nil, "", err
 	}
-	dbInfo.Type = databaseItem.Type
 	dbInfo.From = databaseItem.From
 	dbInfo.Database = database
 	if dbInfo.From != "local" {

backend/app/service/database_postgresql.go

@@ -222,9 +222,6 @@ func (u *PostgresqlService) LoadFromRemote(database string) error {
 		for i := 0; i < len(databases); i++ {
 			if strings.EqualFold(databases[i].Name, data.Name) && strings.EqualFold(databases[i].PostgresqlName, data.PostgresqlName) {
 				hasOld = true
-				if databases[i].IsDelete {
-					_ = postgresqlRepo.Update(databases[i].ID, map[string]interface{}{"is_delete": false})
-				}
 				deleteList = append(deleteList[:i], deleteList[i+1:]...)
 				break
 			}
@@ -269,7 +266,7 @@ func (u *PostgresqlService) DeleteCheck(req dto.PostgresqlDBDeleteCheck) ([]stri
 			}
 		}
 	} else {
-		apps, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(db.ID), appRepo.WithKey(req.Type))
+		apps, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(db.ID))
 		for _, app := range apps {
 			appInstall, _ := appInstallRepo.GetFirst(commonRepo.WithByID(app.AppInstallId))
 			if appInstall.ID != 0 {
@@ -417,16 +414,5 @@ func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
 	if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
 		return err
 	}
-	if req.From == "local" {
-		remote, err := databaseRepo.Get(commonRepo.WithByName(req.Database))
-		if err != nil {
-			return err
-		}
-		pass, err := encrypt.StringEncrypt(req.Value)
-		if err != nil {
-			return fmt.Errorf("decrypt database password failed, err: %v", err)
-		}
-		_ = databaseRepo.Update(remote.ID, map[string]interface{}{"password": pass})
-	}
 	return nil
 }

backend/app/service/database_redis.go

@@ -1,20 +1,18 @@
 package service
 
 import (
-	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
+	"path"
+	"path/filepath"
 	"strings"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
-	"github.com/1Panel-dev/1Panel/backend/utils/docker"
-	"github.com/1Panel-dev/1Panel/backend/utils/encrypt"
-	"github.com/docker/docker/api/types/container"
 	_ "github.com/go-sql-driver/mysql"
 )
 
@@ -25,12 +23,11 @@ type IRedisService interface {
 	UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate) error
 	ChangePassword(info dto.ChangeRedisPass) error
 
-	LoadStatus(req dto.OperationWithName) (*dto.RedisStatus, error)
-	LoadConf(req dto.OperationWithName) (*dto.RedisConf, error)
-	LoadPersistenceConf(req dto.OperationWithName) (*dto.RedisPersistence, error)
+	LoadStatus() (*dto.RedisStatus, error)
+	LoadConf() (*dto.RedisConf, error)
+	LoadPersistenceConf() (*dto.RedisPersistence, error)
 
-	CheckHasCli() bool
-	InstallCli() error
+	SearchBackupListWithPage(req dto.PageInfo) (int64, interface{}, error)
 }
 
 func NewIRedisService() IRedisService {
@@ -38,7 +35,7 @@ func NewIRedisService() IRedisService {
 }
 
 func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Database)
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return err
 	}
@@ -57,54 +54,19 @@ func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
 	return nil
 }
 
-func (u *RedisService) CheckHasCli() bool {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		return false
-	}
-	defer client.Close()
-	containerLists, err := client.ContainerList(context.Background(), container.ListOptions{})
-	if err != nil {
-		return false
-	}
-	for _, item := range containerLists {
-		if strings.ReplaceAll(item.Names[0], "/", "") == "1Panel-redis-cli-tools" {
-			return true
-		}
-	}
-	return false
-}
-
-func (u *RedisService) InstallCli() error {
-	item := dto.ContainerOperate{
-		Name:    "1Panel-redis-cli-tools",
-		Image:   "redis:7.2.4",
-		Network: "1panel-network",
-	}
-	return NewIContainerService().ContainerCreate(item)
-}
-
 func (u *RedisService) ChangePassword(req dto.ChangeRedisPass) error {
-	if err := updateInstallInfoInDB("redis", req.Database, "password", req.Value); err != nil {
+	if err := updateInstallInfoInDB("redis", "", "password", req.Value); err != nil {
 		return err
 	}
-	remote, err := databaseRepo.Get(commonRepo.WithByName(req.Database))
-	if err != nil {
+	if err := updateInstallInfoInDB("redis-commander", "", "password", req.Value); err != nil {
 		return err
 	}
-	if remote.From == "local" {
-		pass, err := encrypt.StringEncrypt(req.Value)
-		if err != nil {
-			return fmt.Errorf("decrypt database password failed, err: %v", err)
-		}
-		_ = databaseRepo.Update(remote.ID, map[string]interface{}{"password": pass})
-	}
 
 	return nil
 }
 
 func (u *RedisService) UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Database)
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return err
 	}
@@ -126,8 +88,8 @@ func (u *RedisService) UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate)
 	return nil
 }
 
-func (u *RedisService) LoadStatus(req dto.OperationWithName) (*dto.RedisStatus, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadStatus() (*dto.RedisStatus, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return nil, err
 	}
@@ -154,8 +116,8 @@ func (u *RedisService) LoadStatus(req dto.OperationWithName) (*dto.RedisStatus,
 	return &info, nil
 }
 
-func (u *RedisService) LoadConf(req dto.OperationWithName) (*dto.RedisConf, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadConf() (*dto.RedisConf, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return nil, err
 	}
@@ -171,8 +133,8 @@ func (u *RedisService) LoadConf(req dto.OperationWithName) (*dto.RedisConf, erro
 	return &item, nil
 }
 
-func (u *RedisService) LoadPersistenceConf(req dto.OperationWithName) (*dto.RedisPersistence, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadPersistenceConf() (*dto.RedisPersistence, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
 	if err != nil {
 		return nil, err
 	}
@@ -189,6 +151,46 @@ func (u *RedisService) LoadPersistenceConf(req dto.OperationWithName) (*dto.Redi
 	return &item, nil
 }
 
+func (u *RedisService) SearchBackupListWithPage(req dto.PageInfo) (int64, interface{}, error) {
+	var (
+		list      []dto.DatabaseFileRecords
+		backDatas []dto.DatabaseFileRecords
+	)
+	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", "")
+	if err != nil {
+		return 0, nil, err
+	}
+	localDir, err := loadLocalDir()
+	if err != nil {
+		return 0, nil, err
+	}
+	backupDir := path.Join(localDir, fmt.Sprintf("database/redis/%s", redisInfo.Name))
+	_ = filepath.Walk(backupDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !info.IsDir() {
+			list = append(list, dto.DatabaseFileRecords{
+				CreatedAt: info.ModTime().Format("2006-01-02 15:04:05"),
+				Size:      int(info.Size()),
+				FileDir:   backupDir,
+				FileName:  info.Name(),
+			})
+		}
+		return nil
+	})
+	total, start, end := len(list), (req.Page-1)*req.PageSize, req.Page*req.PageSize
+	if start > total {
+		backDatas = make([]dto.DatabaseFileRecords, 0)
+	} else {
+		if end >= total {
+			end = total
+		}
+		backDatas = list[start:end]
+	}
+	return int64(total), backDatas, nil
+}
+
 func configGetStr(containerName, password, param string) (string, error) {
 	commands := append(redisExec(containerName, password), []string{"config", "get", param}...)
 	cmd := exec.Command("docker", commands...)

backend/app/service/device.go

@@ -158,7 +158,7 @@ func (u *DeviceService) Update(key, value string) error {
 		if err != nil {
 			return err
 		}
-		ts := ntime.Format(constant.DateTimeLayout)
+		ts := ntime.Format("2006-01-02 15:04:05")
 		if err := ntp.UpdateSystemTime(ts); err != nil {
 			return err
 		}

backend/app/service/device_clean.go

@@ -1,7 +1,6 @@
 package service
 
 import (
-	"context"
 	"fmt"
 	"os"
 	"path"
@@ -9,11 +8,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/utils/docker"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
@@ -73,7 +67,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 	snapTree := loadSnapshotTree(fileOp)
 	snapSize := uint64(0)
 	for _, snap := range snapTree {
-		snapSize += snap.Size
+		snapSize += uint64(snap.Size)
 	}
 	treeData = append(treeData, dto.CleanTree{
 		ID:          uuid.NewString(),
@@ -88,7 +82,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 	rollBackTree := loadRollBackTree(fileOp)
 	rollbackSize := uint64(0)
 	for _, rollback := range rollBackTree {
-		rollbackSize += rollback.Size
+		rollbackSize += uint64(rollback.Size)
 	}
 	treeData = append(treeData, dto.CleanTree{
 		ID:          uuid.NewString(),
@@ -114,7 +108,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 	unusedTree := loadUnusedFile(fileOp)
 	unusedSize := uint64(0)
 	for _, unused := range unusedTree {
-		unusedSize += unused.Size
+		unusedSize += uint64(unused.Size)
 	}
 	treeData = append(treeData, dto.CleanTree{
 		ID:          uuid.NewString(),
@@ -136,9 +130,6 @@ func (u *DeviceService) Scan() dto.CleanData {
 	logTree := loadLogTree(fileOp)
 	SystemClean.SystemLogClean = append(SystemClean.SystemLogClean, logTree...)
 
-	containerTree := loadContainerTree()
-	SystemClean.ContainerClean = append(SystemClean.ContainerClean, containerTree...)
-
 	return SystemClean
 }
 
@@ -268,18 +259,10 @@ func (u *DeviceService) Clean(req []dto.Clean) {
 			} else {
 				_ = cronjobRepo.DeleteRecord(cronjobRepo.WithByRecordFile(pathItem))
 			}
-		case "images":
-			dropImages()
-		case "containers":
-			dropContainers()
-		case "volumes":
-			dropVolumes()
-		case "build_cache":
-			dropBuildCache()
 		}
 	}
 
-	_ = settingRepo.Update("LastCleanTime", time.Now().Format(constant.DateTimeLayout))
+	_ = settingRepo.Update("LastCleanTime", time.Now().Format("2006-01-02 15:04:05"))
 	_ = settingRepo.Update("LastCleanSize", fmt.Sprintf("%v", size))
 	_ = settingRepo.Update("LastCleanData", fmt.Sprintf("%v", len(req)))
 
@@ -343,7 +326,7 @@ func (u *DeviceService) CleanForCronjob() (string, error) {
 			}
 		}
 	}
-	timeNow := time.Now().Format(constant.DateTimeLayout)
+	timeNow := time.Now().Format("2006-01-02 15:04:05")
 	dropFileOrDirWithLog(path.Join(global.CONF.System.BaseDir, dockerLogPath), &logs, &size, &fileCount)
 	logs += fmt.Sprintf("\n%s: total clean: %s, total count: %d", timeNow, common.LoadSizeUnit2F(float64(size)), fileCount)
 
@@ -513,50 +496,6 @@ func loadLogTree(fileOp fileUtils.FileOp) []dto.CleanTree {
 	return treeData
 }
 
-func loadContainerTree() []dto.CleanTree {
-	var treeData []dto.CleanTree
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		return treeData
-	}
-	diskUsage, err := client.DiskUsage(context.Background(), types.DiskUsageOptions{})
-	if err != nil {
-		return treeData
-	}
-	imageSize := uint64(0)
-	for _, file := range diskUsage.Images {
-		if file.Containers == 0 {
-			imageSize += uint64(file.Size)
-		}
-	}
-	treeData = append(treeData, dto.CleanTree{ID: uuid.NewString(), Label: "container_images", Size: imageSize, Children: nil, Type: "images", IsRecommend: true})
-
-	containerSize := uint64(0)
-	for _, file := range diskUsage.Containers {
-		if file.State != "running" {
-			containerSize += uint64(file.SizeRw)
-		}
-	}
-	treeData = append(treeData, dto.CleanTree{ID: uuid.NewString(), Label: "container_containers", Size: containerSize, Children: nil, Type: "containers", IsRecommend: true})
-
-	volumeSize := uint64(0)
-	for _, file := range diskUsage.Volumes {
-		if file.UsageData.RefCount <= 0 {
-			volumeSize += uint64(file.UsageData.Size)
-		}
-	}
-	treeData = append(treeData, dto.CleanTree{ID: uuid.NewString(), Label: "container_volumes", Size: volumeSize, Children: nil, Type: "volumes", IsRecommend: true})
-
-	var buildCacheTotalSize int64
-	for _, cache := range diskUsage.BuildCache {
-		if cache.Type == "source.local" {
-			buildCacheTotalSize += cache.Size
-		}
-	}
-	treeData = append(treeData, dto.CleanTree{ID: uuid.NewString(), Label: "build_cache", Size: uint64(buildCacheTotalSize), Type: "build_cache", IsRecommend: true})
-	return treeData
-}
-
 func loadTreeWithDir(isCheck bool, treeType, pathItem string, fileOp fileUtils.FileOp) []dto.CleanTree {
 	var lists []dto.CleanTree
 	files, err := os.ReadDir(pathItem)
@@ -647,63 +586,6 @@ func dropFileOrDir(itemPath string) {
 	}
 }
 
-func dropBuildCache() {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		global.LOG.Errorf("do not get docker client")
-	}
-	opts := types.BuildCachePruneOptions{}
-	opts.All = true
-	_, err = client.BuildCachePrune(context.Background(), opts)
-	if err != nil {
-		global.LOG.Errorf("drop build cache failed, err %v", err)
-	}
-}
-
-func dropImages() {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		global.LOG.Errorf("do not get docker client")
-	}
-	pruneFilters := filters.NewArgs()
-	pruneFilters.Add("dangling", "false")
-	_, err = client.ImagesPrune(context.Background(), pruneFilters)
-	if err != nil {
-		global.LOG.Errorf("drop images failed, err %v", err)
-	}
-}
-
-func dropContainers() {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		global.LOG.Errorf("do not get docker client")
-	}
-	pruneFilters := filters.NewArgs()
-	_, err = client.ContainersPrune(context.Background(), pruneFilters)
-	if err != nil {
-		global.LOG.Errorf("drop containers failed, err %v", err)
-	}
-}
-
-func dropVolumes() {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		global.LOG.Errorf("do not get docker client")
-	}
-	pruneFilters := filters.NewArgs()
-	versions, err := client.ServerVersion(context.Background())
-	if err != nil {
-		global.LOG.Errorf("do not get docker api versions")
-	}
-	if common.ComparePanelVersion(versions.APIVersion, "1.42") {
-		pruneFilters.Add("all", "true")
-	}
-	_, err = client.VolumesPrune(context.Background(), pruneFilters)
-	if err != nil {
-		global.LOG.Errorf("drop volumes failed, err %v", err)
-	}
-}
-
 func dropFileOrDirWithLog(itemPath string, log *string, size *int64, count *int) {
 	itemSize := int64(0)
 	itemCount := 0

backend/app/service/docker.go

@@ -4,16 +4,15 @@ import (
 	"bufio"
 	"context"
 	"encoding/json"
+	"fmt"
 	"os"
 	"path"
 	"strings"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/1Panel-dev/1Panel/backend/utils/docker"
-	"github.com/1Panel-dev/1Panel/backend/utils/systemctl"
 	"github.com/pkg/errors"
 )
 
@@ -56,7 +55,6 @@ func (u *DockerService) LoadDockerStatus() string {
 	if err != nil {
 		return constant.Stopped
 	}
-	defer client.Close()
 	if _, err := client.Ping(context.Background()); err != nil {
 		return constant.Stopped
 	}
@@ -74,7 +72,6 @@ func (u *DockerService) LoadDockerConf() *dto.DaemonJsonConf {
 	if err != nil {
 		data.Status = constant.Stopped
 	} else {
-		defer client.Close()
 		if _, err := client.Ping(ctx); err != nil {
 			data.Status = constant.Stopped
 		}
@@ -105,6 +102,7 @@ func (u *DockerService) LoadDockerConf() *dto.DaemonJsonConf {
 		return &data
 	}
 	if err := json.Unmarshal(arr, &conf); err != nil {
+		fmt.Println(err)
 		return &data
 	}
 	if _, ok := daemonMap["iptables"]; !ok {
@@ -131,10 +129,13 @@ func (u *DockerService) LoadDockerConf() *dto.DaemonJsonConf {
 }
 
 func (u *DockerService) UpdateConf(req dto.SettingUpdate) error {
-	err := createIfNotExistDaemonJsonFile()
-	if err != nil {
-		return err
+	if _, err := os.Stat(constant.DaemonJsonPath); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(constant.DaemonJsonPath), os.ModePerm); err != nil {
+			return err
+		}
+		_, _ = os.Create(constant.DaemonJsonPath)
 	}
+
 	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		return err
@@ -200,10 +201,6 @@ func (u *DockerService) UpdateConf(req dto.SettingUpdate) error {
 	}
 	if len(daemonMap) == 0 {
 		_ = os.Remove(constant.DaemonJsonPath)
-		stdout, err := cmd.Exec("systemctl restart docker")
-		if err != nil {
-			return errors.New(string(stdout))
-		}
 		return nil
 	}
 	newJson, err := json.MarshalIndent(daemonMap, "", "\t")
@@ -220,26 +217,15 @@ func (u *DockerService) UpdateConf(req dto.SettingUpdate) error {
 	}
 	return nil
 }
-func createIfNotExistDaemonJsonFile() error {
+
+func (u *DockerService) UpdateLogOption(req dto.LogOption) error {
 	if _, err := os.Stat(constant.DaemonJsonPath); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(path.Dir(constant.DaemonJsonPath), os.ModePerm); err != nil {
 			return err
 		}
-		var daemonFile *os.File
-		daemonFile, err = os.Create(constant.DaemonJsonPath)
-		if err != nil {
-			return err
-		}
-		defer daemonFile.Close()
+		_, _ = os.Create(constant.DaemonJsonPath)
 	}
-	return nil
-}
 
-func (u *DockerService) UpdateLogOption(req dto.LogOption) error {
-	err := createIfNotExistDaemonJsonFile()
-	if err != nil {
-		return err
-	}
 	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		return err
@@ -268,9 +254,11 @@ func (u *DockerService) UpdateLogOption(req dto.LogOption) error {
 }
 
 func (u *DockerService) UpdateIpv6Option(req dto.Ipv6Option) error {
-	err := createIfNotExistDaemonJsonFile()
-	if err != nil {
-		return err
+	if _, err := os.Stat(constant.DaemonJsonPath); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(constant.DaemonJsonPath), os.ModePerm); err != nil {
+			return err
+		}
+		_, _ = os.Create(constant.DaemonJsonPath)
 	}
 
 	file, err := os.ReadFile(constant.DaemonJsonPath)
@@ -310,15 +298,13 @@ func (u *DockerService) UpdateIpv6Option(req dto.Ipv6Option) error {
 func (u *DockerService) UpdateConfByFile(req dto.DaemonJsonUpdateByFile) error {
 	if len(req.File) == 0 {
 		_ = os.Remove(constant.DaemonJsonPath)
-		stdout, err := cmd.Exec("systemctl restart docker")
-		if err != nil {
-			return errors.New(string(stdout))
-		}
 		return nil
 	}
-	err := createIfNotExistDaemonJsonFile()
-	if err != nil {
-		return err
+	if _, err := os.Stat(constant.DaemonJsonPath); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(constant.DaemonJsonPath), os.ModePerm); err != nil {
+			return err
+		}
+		_, _ = os.Create(constant.DaemonJsonPath)
 	}
 	file, err := os.OpenFile(constant.DaemonJsonPath, os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
@@ -338,15 +324,8 @@ func (u *DockerService) UpdateConfByFile(req dto.DaemonJsonUpdateByFile) error {
 
 func (u *DockerService) OperateDocker(req dto.DockerOperation) error {
 	service := "docker"
-	sudo := cmd.SudoHandleCmd()
 	if req.Operation == "stop" {
-		isSocketActive, _ := systemctl.IsActive("docker.socket")
-		if isSocketActive {
-			std, err := cmd.Execf("%s systemctl stop docker.socket", sudo)
-			if err != nil {
-				global.LOG.Errorf("handle systemctl stop docker.socket failed, err: %v", std)
-			}
-		}
+		service = "docker.socket"
 	}
 	stdout, err := cmd.Execf("systemctl %s %s ", req.Operation, service)
 	if err != nil {

backend/app/service/entry.go

@@ -24,8 +24,6 @@ var (
 	hostRepo    = repo.NewIHostRepo()
 	groupRepo   = repo.NewIGroupRepo()
 	commandRepo = repo.NewICommandRepo()
-	ftpRepo     = repo.NewIFtpRepo()
-	clamRepo    = repo.NewIClamRepo()
 
 	settingRepo = repo.NewISettingRepo()
 	backupRepo  = repo.NewIBackupRepo()

backend/app/service/file.go

@@ -2,24 +2,17 @@ package service
 
 import (
 	"fmt"
-	"io"
 	"io/fs"
 	"os"
-	"os/exec"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
-	"unicode/utf8"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
-	"golang.org/x/net/html/charset"
-	"golang.org/x/sys/unix"
-	"golang.org/x/text/encoding/simplifiedchinese"
-	"golang.org/x/text/transform"
 
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/common"
@@ -52,23 +45,15 @@ type IFileService interface {
 	ReadLogByLine(req request.FileReadByLineReq) (*response.FileLineContent, error)
 }
 
-var filteredPaths = []string{
-	"/.1panel_clash",
-}
-
 func NewIFileService() IFileService {
 	return &FileService{}
 }
 
 func (f *FileService) GetFileList(op request.FileOption) (response.FileInfo, error) {
 	var fileInfo response.FileInfo
-	data, err := os.Stat(op.Path)
-	if err != nil && os.IsNotExist(err) {
+	if _, err := os.Stat(op.Path); err != nil && os.IsNotExist(err) {
 		return fileInfo, nil
 	}
-	if !data.IsDir() {
-		op.FileOption.Path = filepath.Dir(op.FileOption.Path)
-	}
 	info, err := files.NewFileInfo(op.FileOption)
 	if err != nil {
 		return fileInfo, err
@@ -88,7 +73,7 @@ func (f *FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (in
 		}
 		if !info.IsDir() {
 			files = append(files, response.UploadInfo{
-				CreatedAt: info.ModTime().Format(constant.DateTimeLayout),
+				CreatedAt: info.ModTime().Format("2006-01-02 15:04:05"),
 				Size:      int(info.Size()),
 				Name:      info.Name(),
 			})
@@ -109,85 +94,34 @@ func (f *FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (in
 
 func (f *FileService) GetFileTree(op request.FileOption) ([]response.FileTree, error) {
 	var treeArray []response.FileTree
-	if _, err := os.Stat(op.Path); err != nil && os.IsNotExist(err) {
-		return treeArray, nil
-	}
 	info, err := files.NewFileInfo(op.FileOption)
 	if err != nil {
 		return nil, err
 	}
 	node := response.FileTree{
-		ID:        common.GetUuid(),
-		Name:      info.Name,
-		Path:      info.Path,
-		IsDir:     info.IsDir,
-		Extension: info.Extension,
+		ID:   common.GetUuid(),
+		Name: info.Name,
+		Path: info.Path,
 	}
-	err = f.buildFileTree(&node, info.Items, op, 2)
-	if err != nil {
-		return nil, err
+	for _, v := range info.Items {
+		if v.IsDir {
+			node.Children = append(node.Children, response.FileTree{
+				ID:   common.GetUuid(),
+				Name: v.Name,
+				Path: v.Path,
+			})
+		}
 	}
 	return append(treeArray, node), nil
 }
 
-func shouldFilterPath(path string) bool {
-	cleanedPath := filepath.Clean(path)
-	for _, filteredPath := range filteredPaths {
-		cleanedFilteredPath := filepath.Clean(filteredPath)
-		if cleanedFilteredPath == cleanedPath || strings.HasPrefix(cleanedPath, cleanedFilteredPath+"/") {
-			return true
-		}
-	}
-	return false
-}
-
-// 递归构建文件树(只取当前目录以及当前目录下的第一层子节点)
-func (f *FileService) buildFileTree(node *response.FileTree, items []*files.FileInfo, op request.FileOption, level int) error {
-	for _, v := range items {
-		if shouldFilterPath(v.Path) {
-			global.LOG.Infof("File Tree: Skipping %s due to filter\n", v.Path)
-			continue
-		}
-		childNode := response.FileTree{
-			ID:        common.GetUuid(),
-			Name:      v.Name,
-			Path:      v.Path,
-			IsDir:     v.IsDir,
-			Extension: v.Extension,
-		}
-		if level > 1 && v.IsDir {
-			if err := f.buildChildNode(&childNode, v, op, level); err != nil {
-				return err
-			}
-		}
-
-		node.Children = append(node.Children, childNode)
-	}
-	return nil
-}
-
-func (f *FileService) buildChildNode(childNode *response.FileTree, fileInfo *files.FileInfo, op request.FileOption, level int) error {
-	op.Path = fileInfo.Path
-	subInfo, err := files.NewFileInfo(op.FileOption)
-	if err != nil {
-		if os.IsPermission(err) || errors.Is(err, unix.EACCES) {
-			global.LOG.Infof("File Tree: Skipping %s due to permission denied\n", fileInfo.Path)
-			return nil
-		}
-		global.LOG.Errorf("File Tree: Skipping %s due to error: %s\n", fileInfo.Path, err.Error())
-		return nil
-	}
-
-	return f.buildFileTree(childNode, subInfo.Items, op, level-1)
-}
-
 func (f *FileService) Create(op request.FileCreate) error {
 	if files.IsInvalidChar(op.Path) {
 		return buserr.New("ErrInvalidChar")
 	}
 	fo := files.NewFileOp()
 	if fo.Stat(op.Path) {
-		return buserr.New(constant.ErrFileIsExist)
+		return buserr.New(constant.ErrFileIsExit)
 	}
 	mode := op.Mode
 	if mode == 0 {
@@ -277,45 +211,24 @@ func (f *FileService) ChangeOwner(req request.FileRoleUpdate) error {
 func (f *FileService) Compress(c request.FileCompress) error {
 	fo := files.NewFileOp()
 	if !c.Replace && fo.Stat(filepath.Join(c.Dst, c.Name)) {
-		return buserr.New(constant.ErrFileIsExist)
+		return buserr.New(constant.ErrFileIsExit)
 	}
-	return fo.Compress(c.Files, c.Dst, c.Name, files.CompressType(c.Type), c.Secret)
+	return fo.Compress(c.Files, c.Dst, c.Name, files.CompressType(c.Type))
 }
 
 func (f *FileService) DeCompress(c request.FileDeCompress) error {
 	fo := files.NewFileOp()
-	if c.Type == "tar" && len(c.Secret) != 0 {
-		c.Type = "tar.gz"
-	}
-	return fo.Decompress(c.Path, c.Dst, files.CompressType(c.Type), c.Secret)
+	return fo.Decompress(c.Path, c.Dst, files.CompressType(c.Type))
 }
 
 func (f *FileService) GetContent(op request.FileContentReq) (response.FileInfo, error) {
 	info, err := files.NewFileInfo(files.FileOption{
-		Path:     op.Path,
-		Expand:   true,
-		IsDetail: op.IsDetail,
+		Path:   op.Path,
+		Expand: true,
 	})
 	if err != nil {
 		return response.FileInfo{}, err
 	}
-
-	content := []byte(info.Content)
-	if len(content) > 1024 {
-		content = content[:1024]
-	}
-	if !utf8.Valid(content) {
-		_, decodeName, _ := charset.DetermineEncoding(content, "")
-		if decodeName == "windows-1252" {
-			reader := strings.NewReader(info.Content)
-			item := transform.NewReader(reader, simplifiedchinese.GBK.NewDecoder())
-			contents, err := io.ReadAll(item)
-			if err != nil {
-				return response.FileInfo{}, err
-			}
-			info.Content = string(contents)
-		}
-	}
 	return response.FileInfo{FileInfo: *info}, nil
 }
 
@@ -390,7 +303,7 @@ func (f *FileService) FileDownload(d request.FileDownload) (string, error) {
 			return "", err
 		}
 		fo := files.NewFileOp()
-		if err := fo.Compress(d.Paths, tempPath, d.Name, files.CompressType(d.Type), ""); err != nil {
+		if err := fo.Compress(d.Paths, tempPath, d.Name, files.CompressType(d.Type)); err != nil {
 			return "", err
 		}
 		filePath = filepath.Join(tempPath, d.Name)
@@ -399,32 +312,12 @@ func (f *FileService) FileDownload(d request.FileDownload) (string, error) {
 }
 
 func (f *FileService) DirSize(req request.DirSizeReq) (response.DirSizeRes, error) {
-	var (
-		res response.DirSizeRes
-	)
-	if req.Path == "/proc" {
-		return res, nil
-	}
-	cmd := exec.Command("du", "-s", req.Path)
-	output, err := cmd.Output()
-	if err == nil {
-		fields := strings.Fields(string(output))
-		if len(fields) == 2 {
-			var cmdSize int64
-			_, err = fmt.Sscanf(fields[0], "%d", &cmdSize)
-			if err == nil {
-				res.Size = float64(cmdSize * 1024)
-				return res, nil
-			}
-		}
-	}
 	fo := files.NewFileOp()
 	size, err := fo.GetDirSize(req.Path)
 	if err != nil {
-		return res, err
+		return response.DirSizeRes{}, err
 	}
-	res.Size = size
-	return res, nil
+	return response.DirSizeRes{Size: size}, nil
 }
 
 func (f *FileService) ReadLogByLine(req request.FileReadByLineReq) (*response.FileLineContent, error) {
@@ -474,24 +367,14 @@ func (f *FileService) ReadLogByLine(req request.FileReadByLineReq) (*response.Fi
 		logFilePath = path.Join(global.CONF.System.TmpDir, fmt.Sprintf("docker_logs/%s", req.Name))
 	}
 
-	lines, isEndOfFile, total, err := files.ReadFileByLine(logFilePath, req.Page, req.PageSize, req.Latest)
+	lines, isEndOfFile, err := files.ReadFileByLine(logFilePath, req.Page, req.PageSize)
 	if err != nil {
 		return nil, err
 	}
-	if req.Latest && req.Page == 1 && len(lines) < 1000 && total > 1 {
-		preLines, _, _, err := files.ReadFileByLine(logFilePath, total-1, req.PageSize, false)
-		if err != nil {
-			return nil, err
-		}
-		lines = append(preLines, lines...)
-	}
-
 	res := &response.FileLineContent{
 		Content: strings.Join(lines, "\n"),
 		End:     isEndOfFile,
 		Path:    logFilePath,
-		Total:   total,
-		Lines:   lines,
 	}
 	return res, nil
 }

backend/app/service/firewall.go

@@ -3,7 +3,6 @@ package service
 import (
 	"fmt"
 	"os"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -29,7 +28,6 @@ type IFirewallService interface {
 	SearchWithPage(search dto.RuleSearch) (int64, interface{}, error)
 	OperateFirewall(operation string) error
 	OperatePortRule(req dto.PortRuleOperate, reload bool) error
-	OperateForwardRule(req dto.ForwardRuleOperate) error
 	OperateAddressRule(req dto.AddrRuleOperate, reload bool) error
 	UpdatePortRule(req dto.PortRuleUpdate) error
 	UpdateAddrRule(req dto.AddrRuleUpdate) error
@@ -80,39 +78,42 @@ func (u *FirewallService) SearchWithPage(req dto.RuleSearch) (int64, interface{}
 	if err != nil {
 		return 0, nil, err
 	}
-
-	var rules []fireClient.FireInfo
-	switch req.Type {
-	case "port":
-		rules, err = client.ListPort()
-	case "forward":
-		rules, err = client.ListForward()
-	case "address":
-		rules, err = client.ListAddress()
-	}
-	if err != nil {
-		return 0, nil, err
-	}
-
-	if len(req.Info) != 0 {
-		for _, addr := range rules {
-			if strings.Contains(addr.Address, req.Info) ||
-				strings.Contains(addr.Port, req.Info) ||
-				strings.Contains(addr.TargetPort, req.Info) ||
-				strings.Contains(addr.TargetIP, req.Info) {
-				datas = append(datas, addr)
+	if req.Type == "port" {
+		ports, err := client.ListPort()
+		if err != nil {
+			return 0, nil, err
+		}
+		if len(req.Info) != 0 {
+			for _, port := range ports {
+				if strings.Contains(port.Port, req.Info) {
+					datas = append(datas, port)
+				}
 			}
+		} else {
+			datas = ports
 		}
 	} else {
-		datas = rules
+		addrs, err := client.ListAddress()
+		if err != nil {
+			return 0, nil, err
+		}
+		if len(req.Info) != 0 {
+			for _, addr := range addrs {
+				if strings.Contains(addr.Address, req.Info) {
+					datas = append(datas, addr)
+				}
+			}
+		} else {
+			datas = addrs
+		}
 	}
+
 	if req.Type == "port" {
 		apps := u.loadPortByApp()
 		for i := 0; i < len(datas); i++ {
 			datas[i].UsedStatus = checkPortUsed(datas[i].Port, datas[i].Protocol, apps)
 		}
 	}
-
 	var datasFilterStatus []fireClient.FireInfo
 	if len(req.Status) != 0 {
 		for _, data := range datas {
@@ -126,7 +127,6 @@ func (u *FirewallService) SearchWithPage(req dto.RuleSearch) (int64, interface{}
 	} else {
 		datasFilterStatus = datas
 	}
-
 	var datasFilterStrategy []fireClient.FireInfo
 	if len(req.Strategy) != 0 {
 		for _, data := range datasFilterStatus {
@@ -300,52 +300,6 @@ func (u *FirewallService) OperatePortRule(req dto.PortRuleOperate, reload bool)
 	return nil
 }
 
-func (u *FirewallService) OperateForwardRule(req dto.ForwardRuleOperate) error {
-	client, err := firewall.NewFirewallClient()
-	if err != nil {
-		return err
-	}
-
-	rules, _ := client.ListForward()
-	for _, rule := range rules {
-		for _, reqRule := range req.Rules {
-			if reqRule.Operation == "remove" {
-				continue
-			}
-			if reqRule.TargetIP == "" {
-				reqRule.TargetIP = "127.0.0.1"
-			}
-			if reqRule.Port == rule.Port && reqRule.TargetPort == rule.TargetPort && reqRule.TargetIP == rule.TargetIP {
-				return constant.ErrRecordExist
-			}
-		}
-	}
-
-	sort.SliceStable(req.Rules, func(i, j int) bool {
-		n1, _ := strconv.Atoi(req.Rules[i].Num)
-		n2, _ := strconv.Atoi(req.Rules[j].Num)
-		return n1 > n2
-	})
-
-	for _, r := range req.Rules {
-		for _, p := range strings.Split(r.Protocol, "/") {
-			if r.TargetIP == "" {
-				r.TargetIP = "127.0.0.1"
-			}
-			if err = client.PortForward(fireClient.Forward{
-				Num:        r.Num,
-				Protocol:   p,
-				Port:       r.Port,
-				TargetIP:   r.TargetIP,
-				TargetPort: r.TargetPort,
-			}, r.Operation); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 func (u *FirewallService) OperateAddressRule(req dto.AddrRuleOperate, reload bool) error {
 	client, err := firewall.NewFirewallClient()
 	if err != nil {
@@ -588,6 +542,14 @@ func (u *FirewallService) addPortsBeforeStart(client firewall.FirewallClient) er
 	if err := client.Port(fireClient.FireInfo{Port: "443", Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
 		return err
 	}
+	apps := u.loadPortByApp()
+	for _, app := range apps {
+		if len(app.HttpPort) != 0 && app.HttpPort != "0" {
+			if err := client.Port(fireClient.FireInfo{Port: app.HttpPort, Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+				return err
+			}
+		}
+	}
 
 	return client.Reload()
 }

backend/app/service/ftp.go

@@ -1,245 +0,0 @@
-package service
-
-import (
-	"os"
-	"sort"
-
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/utils/encrypt"
-	"github.com/1Panel-dev/1Panel/backend/utils/toolbox"
-	"github.com/jinzhu/copier"
-	"github.com/pkg/errors"
-)
-
-type FtpService struct{}
-
-type IFtpService interface {
-	LoadBaseInfo() (dto.FtpBaseInfo, error)
-	SearchWithPage(search dto.SearchWithPage) (int64, interface{}, error)
-	Operate(operation string) error
-	Create(req dto.FtpCreate) (uint, error)
-	Delete(req dto.BatchDeleteReq) error
-	Update(req dto.FtpUpdate) error
-	Sync() error
-	LoadLog(req dto.FtpLogSearch) (int64, interface{}, error)
-}
-
-func NewIFtpService() IFtpService {
-	return &FtpService{}
-}
-
-func (f *FtpService) LoadBaseInfo() (dto.FtpBaseInfo, error) {
-	var baseInfo dto.FtpBaseInfo
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return baseInfo, err
-	}
-	baseInfo.IsActive, baseInfo.IsExist = client.Status()
-	return baseInfo, nil
-}
-
-func (f *FtpService) LoadLog(req dto.FtpLogSearch) (int64, interface{}, error) {
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return 0, nil, err
-	}
-	logItem, err := client.LoadLogs(req.User, req.Operation)
-	if err != nil {
-		return 0, nil, err
-	}
-	sort.Slice(logItem, func(i, j int) bool {
-		return logItem[i].Time > logItem[j].Time
-	})
-	var logs []toolbox.FtpLog
-	total, start, end := len(logItem), (req.Page-1)*req.PageSize, req.Page*req.PageSize
-	if start > total {
-		logs = make([]toolbox.FtpLog, 0)
-	} else {
-		if end >= total {
-			end = total
-		}
-		logs = logItem[start:end]
-	}
-	return int64(total), logs, nil
-}
-
-func (u *FtpService) Operate(operation string) error {
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return err
-	}
-	return client.Operate(operation)
-}
-
-func (f *FtpService) SearchWithPage(req dto.SearchWithPage) (int64, interface{}, error) {
-	total, lists, err := ftpRepo.Page(req.Page, req.PageSize, ftpRepo.WithByUser(req.Info), commonRepo.WithOrderBy("created_at desc"))
-	if err != nil {
-		return 0, nil, err
-	}
-	var users []dto.FtpInfo
-	for _, user := range lists {
-		var item dto.FtpInfo
-		if err := copier.Copy(&item, &user); err != nil {
-			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		item.Password, _ = encrypt.StringDecrypt(item.Password)
-		users = append(users, item)
-	}
-	return total, users, err
-}
-
-func (f *FtpService) Sync() error {
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return err
-	}
-	lists, err := client.LoadList()
-	if err != nil {
-		return nil
-	}
-	listsInDB, err := ftpRepo.GetList()
-	if err != nil {
-		return err
-	}
-	sameData := make(map[string]struct{})
-	for _, item := range lists {
-		for _, itemInDB := range listsInDB {
-			if item.User == itemInDB.User {
-				sameData[item.User] = struct{}{}
-				if item.Path != itemInDB.Path || item.Status != itemInDB.Status {
-					_ = ftpRepo.Update(itemInDB.ID, map[string]interface{}{"path": item.Path, "status": item.Status})
-				}
-				break
-			}
-		}
-	}
-	for _, item := range lists {
-		if _, ok := sameData[item.User]; !ok {
-			_ = ftpRepo.Create(&model.Ftp{User: item.User, Path: item.Path, Status: item.Status})
-		}
-	}
-	for _, item := range listsInDB {
-		if _, ok := sameData[item.User]; !ok {
-			_ = ftpRepo.Update(item.ID, map[string]interface{}{"status": "deleted"})
-		}
-	}
-	return nil
-}
-
-func (f *FtpService) Create(req dto.FtpCreate) (uint, error) {
-	if _, err := os.Stat(req.Path); err != nil {
-		if os.IsNotExist(err) {
-			if err := os.MkdirAll(req.Path, os.ModePerm); err != nil {
-				return 0, err
-			}
-		} else {
-			return 0, err
-		}
-	}
-	pass, err := encrypt.StringEncrypt(req.Password)
-	if err != nil {
-		return 0, err
-	}
-	userInDB, _ := ftpRepo.Get(hostRepo.WithByUser(req.User))
-	if userInDB.ID != 0 {
-		return 0, constant.ErrRecordExist
-	}
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return 0, err
-	}
-	if err := client.UserAdd(req.User, req.Password, req.Path); err != nil {
-		return 0, err
-	}
-	var ftp model.Ftp
-	if err := copier.Copy(&ftp, &req); err != nil {
-		return 0, errors.WithMessage(constant.ErrStructTransform, err.Error())
-	}
-	ftp.Status = constant.StatusEnable
-	ftp.Password = pass
-	if err := ftpRepo.Create(&ftp); err != nil {
-		return 0, err
-	}
-	return ftp.ID, nil
-}
-
-func (f *FtpService) Delete(req dto.BatchDeleteReq) error {
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return err
-	}
-	for _, id := range req.Ids {
-		ftpItem, err := ftpRepo.Get(commonRepo.WithByID(id))
-		if err != nil {
-			return err
-		}
-		_ = client.UserDel(ftpItem.User)
-		_ = ftpRepo.Delete(commonRepo.WithByID(id))
-	}
-	return nil
-}
-
-func (f *FtpService) Update(req dto.FtpUpdate) error {
-	if _, err := os.Stat(req.Path); err != nil {
-		if os.IsNotExist(err) {
-			if err := os.MkdirAll(req.Path, os.ModePerm); err != nil {
-				return err
-			}
-		} else {
-			return err
-		}
-	}
-
-	pass, err := encrypt.StringEncrypt(req.Password)
-	if err != nil {
-		return err
-	}
-	ftpItem, _ := ftpRepo.Get(commonRepo.WithByID(req.ID))
-	if ftpItem.ID == 0 {
-		return constant.ErrRecordNotFound
-	}
-	passItem, err := encrypt.StringDecrypt(ftpItem.Password)
-	if err != nil {
-		return err
-	}
-
-	client, err := toolbox.NewFtpClient()
-	if err != nil {
-		return err
-	}
-	needReload := false
-	updates := make(map[string]interface{})
-	if req.Password != passItem {
-		if err := client.SetPasswd(ftpItem.User, req.Password); err != nil {
-			return err
-		}
-		updates["password"] = pass
-		needReload = true
-	}
-	if req.Status != ftpItem.Status {
-		if err := client.SetStatus(ftpItem.User, req.Status); err != nil {
-			return err
-		}
-		updates["status"] = req.Status
-		needReload = true
-	}
-	if req.Path != ftpItem.Path {
-		if err := client.SetPath(ftpItem.User, req.Path); err != nil {
-			return err
-		}
-		updates["path"] = req.Path
-		needReload = true
-	}
-	if req.Description != ftpItem.Description {
-		updates["description"] = req.Description
-	}
-	if needReload {
-		_ = client.Reload()
-	}
-	if len(updates) != 0 {
-		return ftpRepo.Update(ftpItem.ID, updates)
-	}
-	return nil
-}

backend/app/service/host_tool.go

@@ -307,7 +307,7 @@ func (h *HostToolService) OperateSupervisorProcess(req request.SupervisorProcess
 		if err != nil {
 			return err
 		}
-		_, _ = section.NewKey("command", strings.TrimSpace(req.Command))
+		_, _ = section.NewKey("command", req.Command)
 		_, _ = section.NewKey("directory", req.Dir)
 		_, _ = section.NewKey("autorestart", "true")
 		_, _ = section.NewKey("startsecs", "3")
@@ -338,7 +338,7 @@ func (h *HostToolService) OperateSupervisorProcess(req request.SupervisorProcess
 		}
 
 		commandKey := section.Key("command")
-		commandKey.SetValue(strings.TrimSpace(req.Command))
+		commandKey.SetValue(req.Command)
 		directoryKey := section.Key("directory")
 		directoryKey.SetValue(req.Dir)
 		userKey := section.Key("user")