From 09ef0ebc8030701f55b146daa7951de30ccef15a Mon Sep 17 00:00:00 2001
From: zhengkunwang223 <zhengkun@fit2cloud.com>
Date: Tue, 13 Dec 2022 17:20:13 +0800
Subject: [PATCH] =?UTF-8?q?style:=20=E4=BF=AE=E6=94=B9website=E7=9A=84API?=
 =?UTF-8?q?=E5=92=8Cmodel?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 backend/app/api/v1/entry.go                   |   6 +-
 backend/app/api/v1/nginx.go                   |   2 +-
 backend/app/api/v1/website.go                 |  45 +++--
 backend/app/api/v1/website_group.go           |   8 +-
 backend/app/dto/nginx.go                      |   4 +-
 backend/app/{ => dto}/request/nginx.go        |   0
 backend/app/dto/request/website.go            | 100 +++++++++++
 backend/app/dto/response/website.go           |  33 ++++
 backend/app/dto/website.go                    | 123 -------------
 backend/app/dto/website_ssl.go                |   2 +-
 backend/app/model/website.go                  |  12 +-
 backend/app/model/website_domain.go           |   6 +-
 backend/app/model/website_group.go            |   4 +-
 backend/app/model/website_ssl.go              |   4 +-
 backend/app/repo/entry.go                     |   6 +-
 backend/app/repo/website.go                   |  50 +++---
 backend/app/repo/website_domain.go            |  40 ++---
 backend/app/repo/website_group.go             |  26 +--
 backend/app/repo/website_ssl.go               |  34 ++--
 backend/app/request/website.go                |  20 ---
 backend/app/service/entry.go                  |  10 +-
 backend/app/service/nginx.go                  |   2 +-
 backend/app/service/nginx_utils.go            |   8 +-
 backend/app/service/website.go                | 163 +++++++++---------
 backend/app/service/website_acme_account.go   |   8 +-
 backend/app/service/website_dns_account.go    |  10 +-
 backend/app/service/website_group.go          |  14 +-
 backend/app/service/website_ssl.go            |  26 +--
 backend/app/service/website_utils.go          |  42 ++---
 backend/constant/app.go                       |   4 -
 backend/constant/website.go                   |  13 +-
 backend/init/migration/migrations/init.go     |   4 +-
 backend/router/ro_website.go                  |  14 +-
 frontend/src/api/interface/website.ts         |  21 +--
 frontend/src/api/modules/website.ts           |  90 +++++-----
 .../views/website/ssl/acme-account/index.vue  |   4 +-
 .../src/views/website/ssl/create/index.vue    |  14 +-
 .../views/website/ssl/dns-account/index.vue   |   8 +-
 frontend/src/views/website/ssl/index.vue      |   6 +-
 .../src/views/website/website/check/index.vue |   4 +-
 .../config/basic/default-doc/index.vue        |   4 +-
 .../config/basic/domain/create/index.vue      |   4 +-
 .../website/config/basic/domain/index.vue     |   8 +-
 .../website/config/basic/https/index.vue      |   4 +-
 .../website/config/basic/limit-conn/index.vue |   4 +-
 .../website/config/basic/other/index.vue      |   4 +-
 .../website/config/safety/ccdeny/index.vue    |   8 +-
 .../config/safety/file-block-list/index.vue   |   6 +-
 .../website/config/safety/ip-list/index.vue   |   6 +-
 .../config/safety/value-list/index.vue        |   6 +-
 .../views/website/website/create/index.vue    |   4 +-
 .../views/website/website/delete/index.vue    |   4 +-
 frontend/src/views/website/website/index.vue  |  16 +-
 53 files changed, 520 insertions(+), 548 deletions(-)
 rename backend/app/{ => dto}/request/nginx.go (100%)
 create mode 100644 backend/app/dto/request/website.go
 create mode 100644 backend/app/dto/response/website.go
 delete mode 100644 backend/app/request/website.go

diff --git a/backend/app/api/v1/entry.go b/backend/app/api/v1/entry.go
index 6306eb915..9e268db1e 100644
--- a/backend/app/api/v1/entry.go
+++ b/backend/app/api/v1/entry.go
@@ -37,9 +37,9 @@ var (
 
 	websiteGroupService       = service.ServiceGroupApp.WebsiteGroupService
 	websiteService            = service.ServiceGroupApp.WebsiteService
-	websiteDnsAccountService  = service.ServiceGroupApp.WebSiteDnsAccountService
-	websiteSSLService         = service.ServiceGroupApp.WebSiteSSLService
-	websiteAcmeAccountService = service.ServiceGroupApp.WebSiteAcmeAccountService
+	websiteDnsAccountService  = service.ServiceGroupApp.WebsiteDnsAccountService
+	websiteSSLService         = service.ServiceGroupApp.WebsiteSSLService
+	websiteAcmeAccountService = service.ServiceGroupApp.WebsiteAcmeAccountService
 
 	nginxService = service.ServiceGroupApp.NginxService
 
diff --git a/backend/app/api/v1/nginx.go b/backend/app/api/v1/nginx.go
index 8db5c4337..954473841 100644
--- a/backend/app/api/v1/nginx.go
+++ b/backend/app/api/v1/nginx.go
@@ -3,7 +3,7 @@ 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/app/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/gin-gonic/gin"
 )
diff --git a/backend/app/api/v1/website.go b/backend/app/api/v1/website.go
index 909fbfad1..7895c7848 100644
--- a/backend/app/api/v1/website.go
+++ b/backend/app/api/v1/website.go
@@ -4,19 +4,19 @@ import (
 	"errors"
 	"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/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/gin-gonic/gin"
 )
 
 func (b *BaseApi) PageWebsite(c *gin.Context) {
-	var req dto.WebSiteReq
+	var req request.WebsiteSearch
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	total, websites, err := websiteService.PageWebSite(req)
+	total, websites, err := websiteService.PageWebsite(req)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -37,7 +37,7 @@ func (b *BaseApi) GetWebsiteOptions(c *gin.Context) {
 }
 
 func (b *BaseApi) CreateWebsite(c *gin.Context) {
-	var req dto.WebSiteCreate
+	var req request.WebsiteCreate
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -64,7 +64,7 @@ func (b *BaseApi) BackupWebsite(c *gin.Context) {
 }
 
 func (b *BaseApi) RecoverWebsiteByUpload(c *gin.Context) {
-	var req dto.WebSiteRecoverByFile
+	var req request.WebsiteRecoverByFile
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -82,7 +82,7 @@ func (b *BaseApi) RecoverWebsiteByUpload(c *gin.Context) {
 }
 
 func (b *BaseApi) RecoverWebsite(c *gin.Context) {
-	var req dto.WebSiteRecover
+	var req request.WebsiteRecover
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -99,13 +99,13 @@ func (b *BaseApi) RecoverWebsite(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-func (b *BaseApi) DeleteWebSite(c *gin.Context) {
-	var req request.WebSiteDel
+func (b *BaseApi) DeleteWebsite(c *gin.Context) {
+	var req request.WebsiteDelete
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	err := websiteService.DeleteWebSite(req)
+	err := websiteService.DeleteWebsite(req)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -113,8 +113,8 @@ func (b *BaseApi) DeleteWebSite(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-func (b *BaseApi) UpdateWebSite(c *gin.Context) {
-	var req dto.WebSiteUpdate
+func (b *BaseApi) UpdateWebsite(c *gin.Context) {
+	var req request.WebsiteUpdate
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -126,8 +126,7 @@ func (b *BaseApi) UpdateWebSite(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
-func (b *BaseApi) GetWebSite(c *gin.Context) {
-
+func (b *BaseApi) GetWebsite(c *gin.Context) {
 	id, err := helper.GetParamID(c)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
@@ -141,8 +140,7 @@ func (b *BaseApi) GetWebSite(c *gin.Context) {
 	helper.SuccessWithData(c, website)
 }
 
-func (b *BaseApi) GetWebSiteNginx(c *gin.Context) {
-
+func (b *BaseApi) GetWebsiteNginx(c *gin.Context) {
 	id, err := helper.GetParamID(c)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
@@ -157,13 +155,11 @@ func (b *BaseApi) GetWebSiteNginx(c *gin.Context) {
 }
 
 func (b *BaseApi) GetWebDomains(c *gin.Context) {
-
 	websiteId, err := helper.GetIntParamByKey(c, "websiteId")
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
 		return
 	}
-
 	list, err := websiteService.GetWebsiteDomain(websiteId)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
@@ -173,14 +169,13 @@ func (b *BaseApi) GetWebDomains(c *gin.Context) {
 }
 
 func (b *BaseApi) DeleteWebDomain(c *gin.Context) {
-
-	id, err := helper.GetParamID(c)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
+	var req request.WebsiteDomainDelete
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
 
-	if err := websiteService.DeleteWebsiteDomain(id); err != nil {
+	if err := websiteService.DeleteWebsiteDomain(req.ID); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
@@ -188,7 +183,7 @@ func (b *BaseApi) DeleteWebDomain(c *gin.Context) {
 }
 
 func (b *BaseApi) CreateWebDomain(c *gin.Context) {
-	var req dto.WebSiteDomainCreate
+	var req request.WebsiteDomainCreate
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -243,7 +238,7 @@ func (b *BaseApi) GetHTTPSConfig(c *gin.Context) {
 }
 
 func (b *BaseApi) UpdateHTTPSConfig(c *gin.Context) {
-	var req dto.WebsiteHTTPSOp
+	var req request.WebsiteHTTPSOp
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -257,7 +252,7 @@ func (b *BaseApi) UpdateHTTPSConfig(c *gin.Context) {
 }
 
 func (b *BaseApi) CreateWebsiteCheck(c *gin.Context) {
-	var req dto.WebsiteInstallCheckReq
+	var req request.WebsiteInstallCheckReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
diff --git a/backend/app/api/v1/website_group.go b/backend/app/api/v1/website_group.go
index 5991555ac..636974511 100644
--- a/backend/app/api/v1/website_group.go
+++ b/backend/app/api/v1/website_group.go
@@ -2,7 +2,7 @@ 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/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/gin-gonic/gin"
 )
@@ -17,7 +17,7 @@ func (b *BaseApi) GetWebGroups(c *gin.Context) {
 }
 
 func (b *BaseApi) CreateWebGroup(c *gin.Context) {
-	var req dto.WebSiteGroupCreate
+	var req request.WebsiteGroupCreate
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -30,7 +30,7 @@ func (b *BaseApi) CreateWebGroup(c *gin.Context) {
 }
 
 func (b *BaseApi) UpdateWebGroup(c *gin.Context) {
-	var req dto.WebSiteGroupUpdate
+	var req request.WebsiteGroupUpdate
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -43,13 +43,11 @@ func (b *BaseApi) UpdateWebGroup(c *gin.Context) {
 }
 
 func (b *BaseApi) DeleteWebGroup(c *gin.Context) {
-
 	groupId, err := helper.GetIntParamByKey(c, "groupId")
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
 		return
 	}
-
 	if err := websiteGroupService.DeleteGroup(groupId); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
diff --git a/backend/app/dto/nginx.go b/backend/app/dto/nginx.go
index 7a364a633..2a7907779 100644
--- a/backend/app/dto/nginx.go
+++ b/backend/app/dto/nginx.go
@@ -7,7 +7,7 @@ import (
 
 type NginxFull struct {
 	Install    model.AppInstall
-	Website    model.WebSite
+	Website    model.Website
 	ConfigDir  string
 	ConfigFile string
 	SiteDir    string
@@ -25,7 +25,7 @@ type NginxConfig struct {
 type NginxConfigReq struct {
 	Scope     NginxKey    `json:"scope"`
 	Operate   NginxOp     `json:"operate"`
-	WebSiteID uint        `json:"webSiteId"`
+	WebsiteID uint        `json:"webSiteId"`
 	Params    interface{} `json:"params"`
 }
 
diff --git a/backend/app/request/nginx.go b/backend/app/dto/request/nginx.go
similarity index 100%
rename from backend/app/request/nginx.go
rename to backend/app/dto/request/nginx.go
diff --git a/backend/app/dto/request/website.go b/backend/app/dto/request/website.go
new file mode 100644
index 000000000..74ec2e6cc
--- /dev/null
+++ b/backend/app/dto/request/website.go
@@ -0,0 +1,100 @@
+package request
+
+import "github.com/1Panel-dev/1Panel/backend/app/dto"
+
+type WebsiteSearch struct {
+	dto.PageInfo
+}
+
+type WebsiteCreate struct {
+	PrimaryDomain  string `json:"primaryDomain" validate:"required"`
+	Type           string `json:"type" validate:"required"`
+	Alias          string `json:"alias" validate:"required"`
+	Remark         string `json:"remark"`
+	OtherDomains   string `json:"otherDomains"`
+	Proxy          string `json:"proxy"`
+	WebsiteGroupID uint   `json:"webSiteGroupID" validate:"required"`
+
+	AppType      string        `json:"appType" validate:"oneof=new installed"`
+	AppInstall   NewAppInstall `json:"appInstall"`
+	AppID        uint          `json:"appID"`
+	AppInstallID uint          `json:"appInstallID"`
+}
+
+type NewAppInstall struct {
+	Name        string                 `json:"name"`
+	AppDetailId uint                   `json:"appDetailID"`
+	Params      map[string]interface{} `json:"params"`
+}
+
+type WebsiteInstallCheckReq struct {
+	InstallIds []uint `json:"InstallIds" validate:"required"`
+}
+
+type WebsiteUpdate struct {
+	ID             uint   `json:"id" validate:"required"`
+	PrimaryDomain  string `json:"primaryDomain" validate:"required"`
+	Remark         string `json:"remark"`
+	WebsiteGroupID uint   `json:"webSiteGroupID" validate:"required"`
+}
+
+type WebsiteDelete struct {
+	ID           uint `json:"id" validate:"required"`
+	DeleteApp    bool `json:"deleteApp"`
+	DeleteBackup bool `json:"deleteBackup"`
+	ForceDelete  bool `json:"forceDelete"`
+}
+
+type WebsiteWafReq struct {
+	WebsiteID uint   `json:"websiteId" validate:"required"`
+	Key       string `json:"key" validate:"required"`
+	Rule      string `json:"rule" validate:"required"`
+}
+
+type WebsiteWafUpdate struct {
+	WebsiteID uint   `json:"websiteId" validate:"required"`
+	Key       string `json:"key" validate:"required"`
+	Enable    bool   `json:"enable" validate:"required"`
+}
+
+type WebsiteRecover struct {
+	WebsiteName string `json:"websiteName" validate:"required"`
+	Type        string `json:"type" validate:"required"`
+	BackupName  string `json:"backupName" validate:"required"`
+}
+
+type WebsiteRecoverByFile struct {
+	WebsiteName string `json:"websiteName" validate:"required"`
+	Type        string `json:"type" validate:"required"`
+	FileDir     string `json:"fileDir" validate:"required"`
+	FileName    string `json:"fileName" validate:"required"`
+}
+
+type WebsiteGroupCreate struct {
+	Name string `json:"name" validate:"required"`
+}
+
+type WebsiteGroupUpdate struct {
+	ID      uint   `json:"id" validate:"required"`
+	Name    string `json:"name"`
+	Default bool   `json:"default"`
+}
+
+type WebsiteDomainCreate struct {
+	WebsiteID uint   `json:"websiteId" validate:"required"`
+	Port      int    `json:"port" validate:"required"`
+	Domain    string `json:"domain" validate:"required"`
+}
+
+type WebsiteDomainDelete struct {
+	ID uint `json:"id" validate:"required"`
+}
+
+type WebsiteHTTPSOp struct {
+	WebsiteID    uint   `json:"websiteId" validate:"required"`
+	Enable       bool   `json:"enable" validate:"required"`
+	WebsiteSSLID uint   `json:"websiteSSLId"`
+	Type         string `json:"type"  validate:"oneof=existed auto manual"`
+	PrivateKey   string `json:"privateKey"`
+	Certificate  string `json:"certificate"`
+}
diff --git a/backend/app/dto/response/website.go b/backend/app/dto/response/website.go
new file mode 100644
index 000000000..6206a86ef
--- /dev/null
+++ b/backend/app/dto/response/website.go
@@ -0,0 +1,33 @@
+package response
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+)
+
+type WebsiteDTO struct {
+	model.Website
+}
+
+type WebsitePreInstallCheck struct {
+	Name    string `json:"name"`
+	Status  string `json:"status"`
+	Version string `json:"version"`
+	AppName string `json:"appName"`
+}
+
+type WebsiteNginxConfig struct {
+	Enable bool             `json:"enable"`
+	Params []dto.NginxParam `json:"params"`
+}
+
+type WebsiteWafConfig struct {
+	Enable   bool   `json:"enable"`
+	FilePath string `json:"filePath"`
+	Content  string `json:"content"`
+}
+
+type WebsiteHTTPS struct {
+	Enable bool             `json:"enable"`
+	SSL    model.WebsiteSSL `json:"SSL"`
+}
diff --git a/backend/app/dto/website.go b/backend/app/dto/website.go
index 6dab41f02..76d3a1725 100644
--- a/backend/app/dto/website.go
+++ b/backend/app/dto/website.go
@@ -1,124 +1 @@
 package dto
-
-import (
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-)
-
-type WebSiteReq struct {
-	PageInfo
-}
-
-type AppType string
-
-const (
-	NewApp       AppType = "new"
-	InstalledApp AppType = "installed"
-)
-
-type WebSiteCreate struct {
-	PrimaryDomain  string        `json:"primaryDomain" validate:"required"`
-	Type           string        `json:"type" validate:"required"`
-	Alias          string        `json:"alias" validate:"required"`
-	Remark         string        `json:"remark"`
-	OtherDomains   string        `json:"otherDomains"`
-	Proxy          string        `json:"proxy"`
-	AppType        AppType       `json:"appType"`
-	AppInstall     NewAppInstall `json:"appInstall"`
-	AppID          uint          `json:"appID"`
-	AppInstallID   uint          `json:"appInstallID"`
-	WebSiteGroupID uint          `json:"webSiteGroupID" validate:"required"`
-}
-
-type WebsiteDTO struct {
-	model.WebSite
-}
-
-type WebSiteUpdate struct {
-	ID             uint   `json:"id" validate:"required"`
-	PrimaryDomain  string `json:"primaryDomain" validate:"required"`
-	Remark         string `json:"remark"`
-	WebSiteGroupID uint   `json:"webSiteGroupID" validate:"required"`
-}
-
-type NewAppInstall struct {
-	Name        string                 `json:"name"`
-	AppDetailId uint                   `json:"appDetailID"`
-	Params      map[string]interface{} `json:"params"`
-}
-
-type WebSiteRecover struct {
-	WebsiteName string `json:"websiteName" validate:"required"`
-	Type        string `json:"type" validate:"required"`
-	BackupName  string `json:"backupName" validate:"required"`
-}
-
-type WebSiteRecoverByFile struct {
-	WebsiteName string `json:"websiteName" validate:"required"`
-	Type        string `json:"type" validate:"required"`
-	FileDir     string `json:"fileDir" validate:"required"`
-	FileName    string `json:"fileName" validate:"required"`
-}
-
-type WebSiteDTO struct {
-	model.WebSite
-}
-
-type WebSiteGroupCreate struct {
-	Name string `json:"name"`
-}
-
-type WebSiteGroupUpdate struct {
-	ID      uint   `json:"id"`
-	Name    string `json:"name"`
-	Default bool   `json:"default"`
-}
-
-type WebSiteDomainCreate struct {
-	WebSiteID uint   `json:"webSiteId"`
-	Port      int    `json:"port"`
-	Domain    string `json:"domain"`
-}
-
-type WebsiteHTTPS struct {
-	Enable bool             `json:"enable"`
-	SSL    model.WebSiteSSL `json:"SSL"`
-}
-
-type SSlType string
-
-const (
-	SSLExisted SSlType = "existed"
-	SSLAuto    SSlType = "auto"
-	SSLManual  SSlType = "manual"
-)
-
-type WebsiteHTTPSOp struct {
-	WebsiteID    uint    `json:"websiteId" validate:"required"`
-	Enable       bool    `json:"enable" validate:"required"`
-	WebsiteSSLID uint    `json:"websiteSSLId"`
-	Type         SSlType `json:"type"`
-	PrivateKey   string  `json:"privateKey"`
-	Certificate  string  `json:"certificate"`
-}
-
-type WebsiteNginxConfig struct {
-	Enable bool         `json:"enable"`
-	Params []NginxParam `json:"params"`
-}
-
-type WebsitePreInstallCheck struct {
-	Name    string `json:"name"`
-	Status  string `json:"status"`
-	Version string `json:"version"`
-	AppName string `json:"appName"`
-}
-
-type WebsiteInstallCheckReq struct {
-	InstallIds []uint `json:"InstallIds"`
-}
-
-type WebsiteWafConfig struct {
-	Enable   bool   `json:"enable"`
-	FilePath string `json:"filePath"`
-	Content  string `json:"content"`
-}
diff --git a/backend/app/dto/website_ssl.go b/backend/app/dto/website_ssl.go
index 09f4a2d80..bfda3f84c 100644
--- a/backend/app/dto/website_ssl.go
+++ b/backend/app/dto/website_ssl.go
@@ -3,7 +3,7 @@ package dto
 import "github.com/1Panel-dev/1Panel/backend/app/model"
 
 type WebsiteSSLDTO struct {
-	model.WebSiteSSL
+	model.WebsiteSSL
 }
 
 type SSLProvider string
diff --git a/backend/app/model/website.go b/backend/app/model/website.go
index aef7ae3d0..e8c8a4310 100644
--- a/backend/app/model/website.go
+++ b/backend/app/model/website.go
@@ -2,7 +2,7 @@ package model
 
 import "time"
 
-type WebSite struct {
+type Website struct {
 	BaseModel
 	Protocol       string          `gorm:"type:varchar(64);not null" json:"protocol"`
 	PrimaryDomain  string          `gorm:"type:varchar(128);not null" json:"primaryDomain"`
@@ -12,13 +12,13 @@ type WebSite struct {
 	Status         string          `gorm:"type:varchar(64);not null" json:"status"`
 	ExpireDate     time.Time       `json:"expireDate"`
 	AppInstallID   uint            `gorm:"type:integer" json:"appInstallId"`
-	WebSiteGroupID uint            `gorm:"type:integer" json:"webSiteGroupId"`
-	WebSiteSSLID   uint            `gorm:"type:integer" json:"webSiteSSLId"`
+	WebsiteGroupID uint            `gorm:"type:integer" json:"webSiteGroupId"`
+	WebsiteSSLID   uint            `gorm:"type:integer" json:"webSiteSSLId"`
 	Proxy          string          `gorm:"type:varchar(128);not null" json:"proxy"`
-	Domains        []WebSiteDomain `json:"domains"`
-	WebSiteSSL     WebSiteSSL      `json:"webSiteSSL"`
+	Domains        []WebsiteDomain `json:"domains"`
+	WebsiteSSL     WebsiteSSL      `json:"webSiteSSL"`
 }
 
-func (w WebSite) TableName() string {
+func (w Website) TableName() string {
 	return "websites"
 }
diff --git a/backend/app/model/website_domain.go b/backend/app/model/website_domain.go
index 6c54a4ccb..e6fb77e93 100644
--- a/backend/app/model/website_domain.go
+++ b/backend/app/model/website_domain.go
@@ -1,12 +1,12 @@
 package model
 
-type WebSiteDomain struct {
+type WebsiteDomain struct {
 	BaseModel
-	WebSiteID uint   `gorm:"type:varchar(64);not null" json:"web_site_id"`
+	WebsiteID uint   `gorm:"column:website_id;type:varchar(64);not null;" json:"websiteId"`
 	Domain    string `gorm:"type:varchar(256);not null" json:"domain"`
 	Port      int    `gorm:"type:integer" json:"port"`
 }
 
-func (w WebSiteDomain) TableName() string {
+func (w WebsiteDomain) TableName() string {
 	return "website_domains"
 }
diff --git a/backend/app/model/website_group.go b/backend/app/model/website_group.go
index 166127dcd..f0634c619 100644
--- a/backend/app/model/website_group.go
+++ b/backend/app/model/website_group.go
@@ -1,11 +1,11 @@
 package model
 
-type WebSiteGroup struct {
+type WebsiteGroup struct {
 	BaseModel
 	Name    string `gorm:"type:varchar(64);not null" json:"name"`
 	Default bool   `json:"default"`
 }
 
-func (w WebSiteGroup) TableName() string {
+func (w WebsiteGroup) TableName() string {
 	return "website_groups"
 }
diff --git a/backend/app/model/website_ssl.go b/backend/app/model/website_ssl.go
index e5b0fbdfa..92d48aae8 100644
--- a/backend/app/model/website_ssl.go
+++ b/backend/app/model/website_ssl.go
@@ -2,7 +2,7 @@ package model
 
 import "time"
 
-type WebSiteSSL struct {
+type WebsiteSSL struct {
 	BaseModel
 	PrimaryDomain string             `gorm:"type:varchar(256);not null" json:"primaryDomain"`
 	PrivateKey    string             `gorm:"type:longtext;not null" json:"privateKey"`
@@ -19,6 +19,6 @@ type WebSiteSSL struct {
 	StartDate     time.Time          `json:"startDate"`
 }
 
-func (w WebSiteSSL) TableName() string {
+func (w WebsiteSSL) TableName() string {
 	return "website_ssls"
 }
diff --git a/backend/app/repo/entry.go b/backend/app/repo/entry.go
index 6f81d7fae..88d82fc1d 100644
--- a/backend/app/repo/entry.go
+++ b/backend/app/repo/entry.go
@@ -18,9 +18,9 @@ type RepoGroup struct {
 	GroupRepo
 	SettingRepo
 	BackupRepo
-	WebSiteRepo
-	WebSiteDomainRepo
-	WebSiteGroupRepo
+	WebsiteRepo
+	WebsiteDomainRepo
+	WebsiteGroupRepo
 	WebsiteDnsAccountRepo
 	WebsiteSSLRepo
 	WebsiteAcmeAccountRepo
diff --git a/backend/app/repo/website.go b/backend/app/repo/website.go
index 2cb5f94b7..b84bd5a2a 100644
--- a/backend/app/repo/website.go
+++ b/backend/app/repo/website.go
@@ -13,80 +13,80 @@ type IWebsiteRepo interface {
 	WithDomain(domain string) DBOption
 	WithAlias(alias string) DBOption
 	WithWebsiteSSLID(sslId uint) DBOption
-	Page(page, size int, opts ...DBOption) (int64, []model.WebSite, error)
-	GetFirst(opts ...DBOption) (model.WebSite, error)
-	GetBy(opts ...DBOption) ([]model.WebSite, error)
-	Save(ctx context.Context, app *model.WebSite) error
+	Page(page, size int, opts ...DBOption) (int64, []model.Website, error)
+	GetFirst(opts ...DBOption) (model.Website, error)
+	GetBy(opts ...DBOption) ([]model.Website, error)
+	Save(ctx context.Context, app *model.Website) error
 	DeleteBy(ctx context.Context, opts ...DBOption) error
-	Create(ctx context.Context, app *model.WebSite) error
+	Create(ctx context.Context, app *model.Website) error
 }
 
 func NewIWebsiteRepo() IWebsiteRepo {
-	return &WebSiteRepo{}
+	return &WebsiteRepo{}
 }
 
-type WebSiteRepo struct {
+type WebsiteRepo struct {
 }
 
-func (w *WebSiteRepo) WithAppInstallId(appInstallId uint) DBOption {
+func (w *WebsiteRepo) WithAppInstallId(appInstallId uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("app_install_id = ?", appInstallId)
 	}
 }
 
-func (w *WebSiteRepo) WithDomain(domain string) DBOption {
+func (w *WebsiteRepo) WithDomain(domain string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("primary_domain = ?", domain)
 	}
 }
 
-func (w *WebSiteRepo) WithAlias(alias string) DBOption {
+func (w *WebsiteRepo) WithAlias(alias string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("alias = ?", alias)
 	}
 }
 
-func (w *WebSiteRepo) WithWebsiteSSLID(sslId uint) DBOption {
+func (w *WebsiteRepo) WithWebsiteSSLID(sslId uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("web_site_ssl_id = ?", sslId)
 	}
 }
 
-func (w *WebSiteRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebSite, error) {
-	var websites []model.WebSite
-	db := getDb(opts...).Model(&model.WebSite{})
+func (w *WebsiteRepo) Page(page, size int, opts ...DBOption) (int64, []model.Website, error) {
+	var websites []model.Website
+	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.Debug().Limit(size).Offset(size * (page - 1)).Preload("WebsiteSSL").Find(&websites).Error
 	return count, websites, err
 }
 
-func (w *WebSiteRepo) GetFirst(opts ...DBOption) (model.WebSite, error) {
-	var website model.WebSite
-	db := getDb(opts...).Model(&model.WebSite{})
+func (w *WebsiteRepo) GetFirst(opts ...DBOption) (model.Website, error) {
+	var website model.Website
+	db := getDb(opts...).Model(&model.Website{})
 	if err := db.Preload("Domains").First(&website).Error; err != nil {
 		return website, err
 	}
 	return website, nil
 }
 
-func (w *WebSiteRepo) GetBy(opts ...DBOption) ([]model.WebSite, error) {
-	var websites []model.WebSite
-	db := getDb(opts...).Model(&model.WebSite{})
+func (w *WebsiteRepo) GetBy(opts ...DBOption) ([]model.Website, error) {
+	var websites []model.Website
+	db := getDb(opts...).Model(&model.Website{})
 	if err := db.Find(&websites).Error; err != nil {
 		return websites, err
 	}
 	return websites, nil
 }
 
-func (w *WebSiteRepo) Create(ctx context.Context, app *model.WebSite) error {
+func (w *WebsiteRepo) Create(ctx context.Context, app *model.Website) error {
 	return getTx(ctx).Omit(clause.Associations).Create(app).Error
 }
 
-func (w *WebSiteRepo) Save(ctx context.Context, app *model.WebSite) error {
+func (w *WebsiteRepo) Save(ctx context.Context, app *model.Website) error {
 	return getTx(ctx).Omit(clause.Associations).Save(app).Error
 }
 
-func (w *WebSiteRepo) DeleteBy(ctx context.Context, opts ...DBOption) error {
-	return getTx(ctx, opts...).Delete(&model.WebSite{}).Error
+func (w *WebsiteRepo) DeleteBy(ctx context.Context, opts ...DBOption) error {
+	return getTx(ctx, opts...).Delete(&model.Website{}).Error
 }
diff --git a/backend/app/repo/website_domain.go b/backend/app/repo/website_domain.go
index 5f2a47d9b..46c639294 100644
--- a/backend/app/repo/website_domain.go
+++ b/backend/app/repo/website_domain.go
@@ -7,64 +7,64 @@ import (
 	"gorm.io/gorm/clause"
 )
 
-type WebSiteDomainRepo struct {
+type WebsiteDomainRepo struct {
 }
 
-func (w WebSiteDomainRepo) WithWebSiteId(websiteId uint) DBOption {
+func (w WebsiteDomainRepo) WithWebsiteId(websiteId uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("web_site_id = ?", websiteId)
+		return db.Where("website_id = ?", websiteId)
 	}
 }
 
-func (w WebSiteDomainRepo) WithPort(port int) DBOption {
+func (w WebsiteDomainRepo) WithPort(port int) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("port = ?", port)
 	}
 }
-func (w WebSiteDomainRepo) WithDomain(domain string) DBOption {
+func (w WebsiteDomainRepo) WithDomain(domain string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("domain = ?", domain)
 	}
 }
-func (w WebSiteDomainRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebSiteDomain, error) {
-	var domains []model.WebSiteDomain
-	db := getDb(opts...).Model(&model.WebSiteDomain{})
+func (w WebsiteDomainRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDomain, error) {
+	var domains []model.WebsiteDomain
+	db := getDb(opts...).Model(&model.WebsiteDomain{})
 	count := int64(0)
 	db = db.Count(&count)
 	err := db.Debug().Limit(size).Offset(size * (page - 1)).Find(&domains).Error
 	return count, domains, err
 }
 
-func (w WebSiteDomainRepo) GetFirst(opts ...DBOption) (model.WebSiteDomain, error) {
-	var domain model.WebSiteDomain
-	db := getDb(opts...).Model(&model.WebSiteDomain{})
+func (w WebsiteDomainRepo) GetFirst(opts ...DBOption) (model.WebsiteDomain, error) {
+	var domain model.WebsiteDomain
+	db := getDb(opts...).Model(&model.WebsiteDomain{})
 	if err := db.First(&domain).Error; err != nil {
 		return domain, err
 	}
 	return domain, nil
 }
 
-func (w WebSiteDomainRepo) GetBy(opts ...DBOption) ([]model.WebSiteDomain, error) {
-	var domains []model.WebSiteDomain
-	db := getDb(opts...).Model(&model.WebSiteDomain{})
+func (w WebsiteDomainRepo) GetBy(opts ...DBOption) ([]model.WebsiteDomain, error) {
+	var domains []model.WebsiteDomain
+	db := getDb(opts...).Model(&model.WebsiteDomain{})
 	if err := db.Find(&domains).Error; err != nil {
 		return domains, err
 	}
 	return domains, nil
 }
 
-func (w WebSiteDomainRepo) BatchCreate(ctx context.Context, domains []model.WebSiteDomain) error {
-	return getTx(ctx).Model(&model.WebSiteDomain{}).Create(&domains).Error
+func (w WebsiteDomainRepo) BatchCreate(ctx context.Context, domains []model.WebsiteDomain) error {
+	return getTx(ctx).Model(&model.WebsiteDomain{}).Create(&domains).Error
 }
 
-func (w WebSiteDomainRepo) Create(ctx context.Context, app *model.WebSiteDomain) error {
+func (w WebsiteDomainRepo) Create(ctx context.Context, app *model.WebsiteDomain) error {
 	return getTx(ctx).Omit(clause.Associations).Create(app).Error
 }
 
-func (w WebSiteDomainRepo) Save(ctx context.Context, app *model.WebSiteDomain) error {
+func (w WebsiteDomainRepo) Save(ctx context.Context, app *model.WebsiteDomain) error {
 	return getTx(ctx).Omit(clause.Associations).Save(app).Error
 }
 
-func (w WebSiteDomainRepo) DeleteBy(ctx context.Context, opts ...DBOption) error {
-	return getTx(ctx, opts...).Delete(&model.WebSiteDomain{}).Error
+func (w WebsiteDomainRepo) DeleteBy(ctx context.Context, opts ...DBOption) error {
+	return getTx(ctx, opts...).Delete(&model.WebsiteDomain{}).Error
 }
diff --git a/backend/app/repo/website_group.go b/backend/app/repo/website_group.go
index 0b05083ac..241e8ade6 100644
--- a/backend/app/repo/website_group.go
+++ b/backend/app/repo/website_group.go
@@ -6,39 +6,39 @@ import (
 	"gorm.io/gorm/clause"
 )
 
-type WebSiteGroupRepo struct {
+type WebsiteGroupRepo struct {
 }
 
-func (w WebSiteGroupRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebSiteGroup, error) {
-	var groups []model.WebSiteGroup
-	db := getDb(opts...).Model(&model.WebSiteGroup{})
+func (w WebsiteGroupRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteGroup, error) {
+	var groups []model.WebsiteGroup
+	db := getDb(opts...).Model(&model.WebsiteGroup{})
 	count := int64(0)
 	db = db.Count(&count)
 	err := db.Limit(size).Offset(size * (page - 1)).Order("`default` desc").Find(&groups).Error
 	return count, groups, err
 }
 
-func (w WebSiteGroupRepo) GetBy(opts ...DBOption) ([]model.WebSiteGroup, error) {
-	var groups []model.WebSiteGroup
-	db := getDb(opts...).Model(&model.WebSiteGroup{})
+func (w WebsiteGroupRepo) GetBy(opts ...DBOption) ([]model.WebsiteGroup, error) {
+	var groups []model.WebsiteGroup
+	db := getDb(opts...).Model(&model.WebsiteGroup{})
 	if err := db.Order("`default` desc").Find(&groups).Error; err != nil {
 		return groups, err
 	}
 	return groups, nil
 }
 
-func (w WebSiteGroupRepo) Create(app *model.WebSiteGroup) error {
+func (w WebsiteGroupRepo) Create(app *model.WebsiteGroup) error {
 	return getDb().Omit(clause.Associations).Create(app).Error
 }
 
-func (w WebSiteGroupRepo) Save(app *model.WebSiteGroup) error {
+func (w WebsiteGroupRepo) Save(app *model.WebsiteGroup) error {
 	return getDb().Omit(clause.Associations).Save(app).Error
 }
 
-func (w WebSiteGroupRepo) DeleteBy(opts ...DBOption) error {
-	return getDb(opts...).Delete(&model.WebSiteGroup{}).Error
+func (w WebsiteGroupRepo) DeleteBy(opts ...DBOption) error {
+	return getDb(opts...).Delete(&model.WebsiteGroup{}).Error
 }
 
-func (w WebSiteGroupRepo) CancelDefault() error {
-	return global.DB.Model(&model.WebSiteGroup{}).Where("`default` = 1").Updates(map[string]interface{}{"default": 0}).Error
+func (w WebsiteGroupRepo) CancelDefault() error {
+	return global.DB.Model(&model.WebsiteGroup{}).Where("`default` = 1").Updates(map[string]interface{}{"default": 0}).Error
 }
diff --git a/backend/app/repo/website_ssl.go b/backend/app/repo/website_ssl.go
index 4d035df30..7e7457cca 100644
--- a/backend/app/repo/website_ssl.go
+++ b/backend/app/repo/website_ssl.go
@@ -14,11 +14,11 @@ type ISSLRepo interface {
 	WithByAlias(alias string) DBOption
 	WithByAcmeAccountId(acmeAccountId uint) DBOption
 	WithByDnsAccountId(dnsAccountId uint) DBOption
-	Page(page, size int, opts ...DBOption) (int64, []model.WebSiteSSL, error)
-	GetFirst(opts ...DBOption) (model.WebSiteSSL, error)
-	List(opts ...DBOption) ([]model.WebSiteSSL, error)
-	Create(ctx context.Context, ssl *model.WebSiteSSL) error
-	Save(ssl model.WebSiteSSL) error
+	Page(page, size int, opts ...DBOption) (int64, []model.WebsiteSSL, error)
+	GetFirst(opts ...DBOption) (model.WebsiteSSL, error)
+	List(opts ...DBOption) ([]model.WebsiteSSL, error)
+	Create(ctx context.Context, ssl *model.WebsiteSSL) error
+	Save(ssl model.WebsiteSSL) error
 	DeleteBy(opts ...DBOption) error
 }
 
@@ -43,41 +43,41 @@ func (w WebsiteSSLRepo) WithByDnsAccountId(dnsAccountId uint) DBOption {
 	}
 }
 
-func (w WebsiteSSLRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebSiteSSL, error) {
-	var sslList []model.WebSiteSSL
-	db := getDb(opts...).Model(&model.WebSiteSSL{})
+func (w WebsiteSSLRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteSSL, error) {
+	var sslList []model.WebsiteSSL
+	db := getDb(opts...).Model(&model.WebsiteSSL{})
 	count := int64(0)
 	db = db.Count(&count)
 	err := db.Limit(size).Offset(size * (page - 1)).Preload("AcmeAccount").Find(&sslList).Error
 	return count, sslList, err
 }
 
-func (w WebsiteSSLRepo) GetFirst(opts ...DBOption) (model.WebSiteSSL, error) {
-	var website model.WebSiteSSL
-	db := getDb(opts...).Model(&model.WebSiteSSL{})
+func (w WebsiteSSLRepo) GetFirst(opts ...DBOption) (model.WebsiteSSL, error) {
+	var website model.WebsiteSSL
+	db := getDb(opts...).Model(&model.WebsiteSSL{})
 	if err := db.Preload("AcmeAccount").First(&website).Error; err != nil {
 		return website, err
 	}
 	return website, nil
 }
 
-func (w WebsiteSSLRepo) List(opts ...DBOption) ([]model.WebSiteSSL, error) {
-	var websites []model.WebSiteSSL
-	db := getDb(opts...).Model(&model.WebSiteSSL{})
+func (w WebsiteSSLRepo) List(opts ...DBOption) ([]model.WebsiteSSL, error) {
+	var websites []model.WebsiteSSL
+	db := getDb(opts...).Model(&model.WebsiteSSL{})
 	if err := db.Preload("AcmeAccount").Find(&websites).Error; err != nil {
 		return websites, err
 	}
 	return websites, nil
 }
 
-func (w WebsiteSSLRepo) Create(ctx context.Context, ssl *model.WebSiteSSL) error {
+func (w WebsiteSSLRepo) Create(ctx context.Context, ssl *model.WebsiteSSL) error {
 	return getTx(ctx).Create(ssl).Error
 }
 
-func (w WebsiteSSLRepo) Save(ssl model.WebSiteSSL) error {
+func (w WebsiteSSLRepo) Save(ssl model.WebsiteSSL) error {
 	return getDb().Save(&ssl).Error
 }
 
 func (w WebsiteSSLRepo) DeleteBy(opts ...DBOption) error {
-	return getDb(opts...).Delete(&model.WebSiteSSL{}).Error
+	return getDb(opts...).Delete(&model.WebsiteSSL{}).Error
 }
diff --git a/backend/app/request/website.go b/backend/app/request/website.go
deleted file mode 100644
index b5c9819d2..000000000
--- a/backend/app/request/website.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package request
-
-type WebsiteWafReq struct {
-	WebsiteID uint   `json:"websiteId" validate:"required"`
-	Key       string `json:"key" validate:"required"`
-	Rule      string `json:"rule" validate:"required"`
-}
-
-type WebsiteWafUpdate struct {
-	WebsiteID uint   `json:"websiteId" validate:"required"`
-	Key       string `json:"key" validate:"required"`
-	Enable    bool   `json:"enable" validate:"required"`
-}
-
-type WebSiteDel struct {
-	ID           uint `json:"id" validate:"required"`
-	DeleteApp    bool `json:"deleteApp"`
-	DeleteBackup bool `json:"deleteBackup"`
-	ForceDelete  bool `json:"forceDelete"`
-}
diff --git a/backend/app/service/entry.go b/backend/app/service/entry.go
index 3d4c2ce36..9b4b16928 100644
--- a/backend/app/service/entry.go
+++ b/backend/app/service/entry.go
@@ -30,9 +30,9 @@ type ServiceGroup struct {
 
 	WebsiteGroupService
 	WebsiteService
-	WebSiteDnsAccountService
-	WebSiteSSLService
-	WebSiteAcmeAccountService
+	WebsiteDnsAccountService
+	WebsiteSSLService
+	WebsiteAcmeAccountService
 
 	NginxService
 
@@ -67,8 +67,8 @@ var (
 	backupRepo  = repo.RepoGroupApp.BackupRepo
 
 	websiteRepo       = repo.NewIWebsiteRepo()
-	websiteGroupRepo  = repo.RepoGroupApp.WebSiteGroupRepo
-	websiteDomainRepo = repo.RepoGroupApp.WebSiteDomainRepo
+	websiteGroupRepo  = repo.RepoGroupApp.WebsiteGroupRepo
+	websiteDomainRepo = repo.RepoGroupApp.WebsiteDomainRepo
 	websiteDnsRepo    = repo.RepoGroupApp.WebsiteDnsAccountRepo
 	websiteSSLRepo    = repo.NewISSLRepo()
 	websiteAcmeRepo   = repo.NewIAcmeAccountRepo()
diff --git a/backend/app/service/nginx.go b/backend/app/service/nginx.go
index 08729ccdc..f6d0bd7df 100644
--- a/backend/app/service/nginx.go
+++ b/backend/app/service/nginx.go
@@ -1,7 +1,7 @@
 package service
 
 import (
-	"github.com/1Panel-dev/1Panel/backend/app/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"io/ioutil"
 	"net/http"
 	"os"
diff --git a/backend/app/service/nginx_utils.go b/backend/app/service/nginx_utils.go
index 23bf426cd..d7bd31f62 100644
--- a/backend/app/service/nginx_utils.go
+++ b/backend/app/service/nginx_utils.go
@@ -17,7 +17,7 @@ import (
 	"strings"
 )
 
-func getNginxFull(website *model.WebSite) (dto.NginxFull, error) {
+func getNginxFull(website *model.Website) (dto.NginxFull, error) {
 	var nginxFull dto.NginxFull
 	nginxInstall, err := getAppInstallByKey("nginx")
 	if err != nil {
@@ -62,7 +62,7 @@ func getNginxFull(website *model.WebSite) (dto.NginxFull, error) {
 	return nginxFull, nil
 }
 
-func getNginxParamsByKeys(scope string, keys []string, website *model.WebSite) ([]dto.NginxParam, error) {
+func getNginxParamsByKeys(scope string, keys []string, website *model.Website) ([]dto.NginxParam, error) {
 	nginxFull, err := getNginxFull(website)
 	if err != nil {
 		return nil, err
@@ -94,7 +94,7 @@ func getNginxParamsByKeys(scope string, keys []string, website *model.WebSite) (
 	return res, nil
 }
 
-func updateNginxConfig(scope string, params []dto.NginxParam, website *model.WebSite) error {
+func updateNginxConfig(scope string, params []dto.NginxParam, website *model.Website) error {
 
 	nginxFull, err := getNginxFull(website)
 	if err != nil {
@@ -126,7 +126,7 @@ func updateNginxConfig(scope string, params []dto.NginxParam, website *model.Web
 	return nginxCheckAndReload(config.OldContent, config.FilePath, nginxFull.Install.ContainerName)
 }
 
-func deleteNginxConfig(scope string, keys []string, website *model.WebSite) error {
+func deleteNginxConfig(scope string, keys []string, website *model.Website) error {
 	nginxFull, err := getNginxFull(website)
 	if err != nil {
 		return err
diff --git a/backend/app/service/website.go b/backend/app/service/website.go
index 46d7b405f..a0386a294 100644
--- a/backend/app/service/website.go
+++ b/backend/app/service/website.go
@@ -6,7 +6,8 @@ import (
 	"encoding/json"
 	"encoding/pem"
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/app/request"
+	"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"
 	"os"
 	"path"
@@ -26,25 +27,25 @@ type WebsiteService struct {
 }
 
 type IWebsiteService interface {
-	PageWebSite(req dto.WebSiteReq) (int64, []dto.WebSiteDTO, error)
-	CreateWebsite(create dto.WebSiteCreate) error
+	PageWebsite(req request.WebsiteSearch) (int64, []response.WebsiteDTO, error)
+	CreateWebsite(create request.WebsiteCreate) error
 	GetWebsiteOptions() ([]string, error)
 	Backup(domain string) error
-	Recover(req dto.WebSiteRecover) error
-	RecoverByUpload(req dto.WebSiteRecoverByFile) error
-	UpdateWebsite(req dto.WebSiteUpdate) error
-	DeleteWebSite(req request.WebSiteDel) error
-	GetWebsite(id uint) (dto.WebsiteDTO, error)
-	CreateWebsiteDomain(create dto.WebSiteDomainCreate) (model.WebSiteDomain, error)
-	GetWebsiteDomain(websiteId uint) ([]model.WebSiteDomain, error)
+	Recover(req request.WebsiteRecover) error
+	RecoverByUpload(req request.WebsiteRecoverByFile) error
+	UpdateWebsite(req request.WebsiteUpdate) error
+	DeleteWebsite(req request.WebsiteDelete) error
+	GetWebsite(id uint) (response.WebsiteDTO, error)
+	CreateWebsiteDomain(create request.WebsiteDomainCreate) (model.WebsiteDomain, error)
+	GetWebsiteDomain(websiteId uint) ([]model.WebsiteDomain, error)
 	DeleteWebsiteDomain(domainId uint) error
-	GetNginxConfigByScope(req dto.NginxConfigReq) (*dto.WebsiteNginxConfig, error)
+	GetNginxConfigByScope(req dto.NginxConfigReq) (*response.WebsiteNginxConfig, error)
 	UpdateNginxConfigByScope(req dto.NginxConfigReq) error
 	GetWebsiteNginxConfig(websiteId uint) (dto.FileInfo, error)
-	GetWebsiteHTTPS(websiteId uint) (dto.WebsiteHTTPS, error)
-	OpWebsiteHTTPS(req dto.WebsiteHTTPSOp) (dto.WebsiteHTTPS, error)
-	PreInstallCheck(req dto.WebsiteInstallCheckReq) ([]dto.WebsitePreInstallCheck, error)
-	GetWafConfig(req request.WebsiteWafReq) (dto.WebsiteWafConfig, error)
+	GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS, error)
+	OpWebsiteHTTPS(req request.WebsiteHTTPSOp) (response.WebsiteHTTPS, error)
+	PreInstallCheck(req request.WebsiteInstallCheckReq) ([]response.WebsitePreInstallCheck, error)
+	GetWafConfig(req request.WebsiteWafReq) (response.WebsiteWafConfig, error)
 	UpdateWafConfig(req request.WebsiteWafUpdate) error
 }
 
@@ -52,21 +53,21 @@ func NewWebsiteService() IWebsiteService {
 	return &WebsiteService{}
 }
 
-func (w WebsiteService) PageWebSite(req dto.WebSiteReq) (int64, []dto.WebSiteDTO, error) {
-	var websiteDTOs []dto.WebSiteDTO
+func (w WebsiteService) PageWebsite(req request.WebsiteSearch) (int64, []response.WebsiteDTO, error) {
+	var websiteDTOs []response.WebsiteDTO
 	total, websites, err := websiteRepo.Page(req.Page, req.PageSize)
 	if err != nil {
 		return 0, nil, err
 	}
 	for _, web := range websites {
-		websiteDTOs = append(websiteDTOs, dto.WebSiteDTO{
-			WebSite: web,
+		websiteDTOs = append(websiteDTOs, response.WebsiteDTO{
+			Website: web,
 		})
 	}
 	return total, websiteDTOs, nil
 }
 
-func (w WebsiteService) CreateWebsite(create dto.WebSiteCreate) error {
+func (w WebsiteService) CreateWebsite(create request.WebsiteCreate) error {
 	if exist, _ := websiteRepo.GetBy(websiteRepo.WithDomain(create.PrimaryDomain)); len(exist) > 0 {
 		return buserr.New(constant.ErrNameIsExist)
 	}
@@ -78,7 +79,7 @@ func (w WebsiteService) CreateWebsite(create dto.WebSiteCreate) error {
 	}
 
 	defaultDate, _ := time.Parse(constant.DateLayout, constant.DefaultDate)
-	website := &model.WebSite{
+	website := &model.Website{
 		PrimaryDomain:  create.PrimaryDomain,
 		Type:           create.Type,
 		Alias:          create.Alias,
@@ -86,14 +87,14 @@ func (w WebsiteService) CreateWebsite(create dto.WebSiteCreate) error {
 		Status:         constant.WebRunning,
 		ExpireDate:     defaultDate,
 		AppInstallID:   create.AppInstallID,
-		WebSiteGroupID: create.WebSiteGroupID,
+		WebsiteGroupID: create.WebsiteGroupID,
 		Protocol:       constant.ProtocolHTTP,
 		Proxy:          create.Proxy,
 	}
 
 	switch create.Type {
 	case constant.Deployment:
-		if create.AppType == dto.NewApp {
+		if create.AppType == constant.NewApp {
 			install, err := ServiceGroupApp.Install(create.AppInstall.Name, create.AppInstall.AppDetailId, create.AppInstall.Params)
 			if err != nil {
 				return err
@@ -110,8 +111,8 @@ func (w WebsiteService) CreateWebsite(create dto.WebSiteCreate) error {
 	if err := websiteRepo.Create(ctx, website); err != nil {
 		return err
 	}
-	var domains []model.WebSiteDomain
-	domains = append(domains, model.WebSiteDomain{Domain: website.PrimaryDomain, WebSiteID: website.ID, Port: 80})
+	var domains []model.WebsiteDomain
+	domains = append(domains, model.WebsiteDomain{Domain: website.PrimaryDomain, WebsiteID: website.ID, Port: 80})
 
 	otherDomainArray := strings.Split(create.OtherDomains, "\n")
 	for _, domain := range otherDomainArray {
@@ -123,7 +124,7 @@ func (w WebsiteService) CreateWebsite(create dto.WebSiteCreate) error {
 			tx.Rollback()
 			return err
 		}
-		if reflect.DeepEqual(domainModel, model.WebSiteDomain{}) {
+		if reflect.DeepEqual(domainModel, model.WebsiteDomain{}) {
 			continue
 		}
 		domains = append(domains, domainModel)
@@ -170,7 +171,7 @@ func (w WebsiteService) Backup(domain string) error {
 	return nil
 }
 
-func (w WebsiteService) RecoverByUpload(req dto.WebSiteRecoverByFile) error {
+func (w WebsiteService) RecoverByUpload(req request.WebsiteRecoverByFile) error {
 	if err := handleUnTar(fmt.Sprintf("%s/%s", req.FileDir, req.FileName), req.FileDir); err != nil {
 		return err
 	}
@@ -179,7 +180,7 @@ func (w WebsiteService) RecoverByUpload(req dto.WebSiteRecoverByFile) error {
 	if err != nil {
 		return err
 	}
-	var websiteInfo WebSiteInfo
+	var websiteInfo WebsiteInfo
 	if err := json.Unmarshal(webJson, &websiteInfo); err != nil {
 		return err
 	}
@@ -198,7 +199,7 @@ func (w WebsiteService) RecoverByUpload(req dto.WebSiteRecoverByFile) error {
 	return nil
 }
 
-func (w WebsiteService) Recover(req dto.WebSiteRecover) error {
+func (w WebsiteService) Recover(req request.WebsiteRecover) error {
 	website, err := websiteRepo.GetFirst(websiteRepo.WithDomain(req.WebsiteName))
 	if err != nil {
 		return err
@@ -220,29 +221,29 @@ func (w WebsiteService) Recover(req dto.WebSiteRecover) error {
 	return nil
 }
 
-func (w WebsiteService) UpdateWebsite(req dto.WebSiteUpdate) error {
+func (w WebsiteService) UpdateWebsite(req request.WebsiteUpdate) error {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
 	if err != nil {
 		return err
 	}
 	website.PrimaryDomain = req.PrimaryDomain
-	website.WebSiteGroupID = req.WebSiteGroupID
+	website.WebsiteGroupID = req.WebsiteGroupID
 	website.Remark = req.Remark
 
 	return websiteRepo.Save(context.TODO(), &website)
 }
 
-func (w WebsiteService) GetWebsite(id uint) (dto.WebsiteDTO, error) {
-	var res dto.WebsiteDTO
+func (w WebsiteService) GetWebsite(id uint) (response.WebsiteDTO, error) {
+	var res response.WebsiteDTO
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(id))
 	if err != nil {
 		return res, err
 	}
-	res.WebSite = website
+	res.Website = website
 	return res, nil
 }
 
-func (w WebsiteService) DeleteWebSite(req request.WebSiteDel) error {
+func (w WebsiteService) DeleteWebsite(req request.WebsiteDelete) error {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
 	if err != nil {
 		return err
@@ -272,7 +273,7 @@ func (w WebsiteService) DeleteWebSite(req request.WebSiteDel) error {
 		tx.Rollback()
 		return err
 	}
-	if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebSiteId(req.ID)); err != nil {
+	if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebsiteId(req.ID)); err != nil {
 		tx.Rollback()
 		return err
 	}
@@ -280,32 +281,32 @@ func (w WebsiteService) DeleteWebSite(req request.WebSiteDel) error {
 	return nil
 }
 
-func (w WebsiteService) CreateWebsiteDomain(create dto.WebSiteDomainCreate) (model.WebSiteDomain, error) {
-	var domainModel model.WebSiteDomain
+func (w WebsiteService) CreateWebsiteDomain(create request.WebsiteDomainCreate) (model.WebsiteDomain, error) {
+	var domainModel model.WebsiteDomain
 	var ports []int
 	var domains []string
 
-	website, err := websiteRepo.GetFirst(commonRepo.WithByID(create.WebSiteID))
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(create.WebsiteID))
 	if err != nil {
 		return domainModel, err
 	}
-	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebSiteId(create.WebSiteID), websiteDomainRepo.WithPort(create.Port)); len(oldDomains) == 0 {
+	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(create.WebsiteID), websiteDomainRepo.WithPort(create.Port)); len(oldDomains) == 0 {
 		ports = append(ports, create.Port)
 	}
 	domains = append(domains, create.Domain)
 	if err := addListenAndServerName(website, ports, domains); err != nil {
 		return domainModel, err
 	}
-	domainModel = model.WebSiteDomain{
+	domainModel = model.WebsiteDomain{
 		Domain:    create.Domain,
 		Port:      create.Port,
-		WebSiteID: create.WebSiteID,
+		WebsiteID: create.WebsiteID,
 	}
 	return domainModel, websiteDomainRepo.Create(context.TODO(), &domainModel)
 }
 
-func (w WebsiteService) GetWebsiteDomain(websiteId uint) ([]model.WebSiteDomain, error) {
-	return websiteDomainRepo.GetBy(websiteDomainRepo.WithWebSiteId(websiteId))
+func (w WebsiteService) GetWebsiteDomain(websiteId uint) ([]model.WebsiteDomain, error) {
+	return websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(websiteId))
 }
 
 func (w WebsiteService) DeleteWebsiteDomain(domainId uint) error {
@@ -314,20 +315,20 @@ func (w WebsiteService) DeleteWebsiteDomain(domainId uint) error {
 		return err
 	}
 
-	if websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebSiteId(webSiteDomain.WebSiteID)); len(websiteDomains) == 1 {
+	if websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID)); len(websiteDomains) == 1 {
 		return fmt.Errorf("can not delete last domain")
 	}
-	website, err := websiteRepo.GetFirst(commonRepo.WithByID(webSiteDomain.WebSiteID))
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(webSiteDomain.WebsiteID))
 	if err != nil {
 		return err
 	}
 	var ports []int
-	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebSiteId(webSiteDomain.WebSiteID), websiteDomainRepo.WithPort(webSiteDomain.Port)); len(oldDomains) == 1 {
+	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID), websiteDomainRepo.WithPort(webSiteDomain.Port)); len(oldDomains) == 1 {
 		ports = append(ports, webSiteDomain.Port)
 	}
 
 	var domains []string
-	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebSiteId(webSiteDomain.WebSiteID), websiteDomainRepo.WithDomain(webSiteDomain.Domain)); len(oldDomains) == 1 {
+	if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID), websiteDomainRepo.WithDomain(webSiteDomain.Domain)); len(oldDomains) == 1 {
 		domains = append(domains, webSiteDomain.Domain)
 	}
 	if len(ports) > 0 || len(domains) > 0 {
@@ -339,17 +340,17 @@ func (w WebsiteService) DeleteWebsiteDomain(domainId uint) error {
 	return websiteDomainRepo.DeleteBy(context.TODO(), commonRepo.WithByID(domainId))
 }
 
-func (w WebsiteService) GetNginxConfigByScope(req dto.NginxConfigReq) (*dto.WebsiteNginxConfig, error) {
+func (w WebsiteService) GetNginxConfigByScope(req dto.NginxConfigReq) (*response.WebsiteNginxConfig, error) {
 	keys, ok := dto.ScopeKeyMap[req.Scope]
 	if !ok || len(keys) == 0 {
 		return nil, nil
 	}
 
-	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebSiteID))
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
 	if err != nil {
 		return nil, err
 	}
-	var config dto.WebsiteNginxConfig
+	var config response.WebsiteNginxConfig
 	params, err := getNginxParamsByKeys(constant.NginxScopeServer, keys, &website)
 	if err != nil {
 		return nil, err
@@ -365,7 +366,7 @@ func (w WebsiteService) UpdateNginxConfigByScope(req dto.NginxConfigReq) error {
 	if !ok || len(keys) == 0 {
 		return nil
 	}
-	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebSiteID))
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
 	if err != nil {
 		return err
 	}
@@ -408,54 +409,54 @@ func (w WebsiteService) GetWebsiteNginxConfig(websiteId uint) (dto.FileInfo, err
 	return dto.FileInfo{FileInfo: *info}, nil
 }
 
-func (w WebsiteService) GetWebsiteHTTPS(websiteId uint) (dto.WebsiteHTTPS, error) {
+func (w WebsiteService) GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS, error) {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteId))
 	if err != nil {
-		return dto.WebsiteHTTPS{}, err
+		return response.WebsiteHTTPS{}, err
 	}
-	var res dto.WebsiteHTTPS
-	if website.WebSiteSSLID == 0 {
+	var res response.WebsiteHTTPS
+	if website.WebsiteSSLID == 0 {
 		res.Enable = false
 		return res, nil
 	}
-	websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebSiteSSLID))
+	websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID))
 	if err != nil {
-		return dto.WebsiteHTTPS{}, err
+		return response.WebsiteHTTPS{}, err
 	}
 	res.SSL = websiteSSL
 	res.Enable = true
 	return res, nil
 }
 
-func (w WebsiteService) OpWebsiteHTTPS(req dto.WebsiteHTTPSOp) (dto.WebsiteHTTPS, error) {
+func (w WebsiteService) OpWebsiteHTTPS(req request.WebsiteHTTPSOp) (response.WebsiteHTTPS, error) {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
 	if err != nil {
-		return dto.WebsiteHTTPS{}, err
+		return response.WebsiteHTTPS{}, err
 	}
 
 	var (
-		res        dto.WebsiteHTTPS
-		websiteSSL model.WebSiteSSL
+		res        response.WebsiteHTTPS
+		websiteSSL model.WebsiteSSL
 	)
 	res.Enable = req.Enable
 
-	if req.Type == dto.SSLExisted {
+	if req.Type == constant.SSLExisted {
 		websiteSSL, err = websiteSSLRepo.GetFirst(commonRepo.WithByID(req.WebsiteSSLID))
 		if err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
-		website.WebSiteSSLID = websiteSSL.ID
+		website.WebsiteSSLID = websiteSSL.ID
 		if err := websiteRepo.Save(context.TODO(), &website); err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
 		res.SSL = websiteSSL
 	}
 
-	if req.Type == dto.Manual {
+	if req.Type == constant.SSLManual {
 		certBlock, _ := pem.Decode([]byte(req.Certificate))
 		cert, err := x509.ParseCertificate(certBlock.Bytes)
 		if err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
 		websiteSSL.ExpireDate = cert.NotAfter
 		websiteSSL.StartDate = cert.NotBefore
@@ -486,39 +487,39 @@ func (w WebsiteService) OpWebsiteHTTPS(req dto.WebsiteHTTPSOp) (dto.WebsiteHTTPS
 	if req.Enable {
 		website.Protocol = constant.ProtocolHTTPS
 		if err := applySSL(website, websiteSSL); err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
 	} else {
 		website.Protocol = constant.ProtocolHTTP
-		website.WebSiteSSLID = 0
+		website.WebsiteSSLID = 0
 
 		if err := deleteListenAndServerName(website, []int{443}, []string{}); err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
 
 		if err := deleteNginxConfig(constant.NginxScopeServer, getKeysFromStaticFile(dto.SSL), &website); err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
 	}
 
 	tx, ctx := getTxAndContext()
 	if websiteSSL.ID == 0 {
 		if err := websiteSSLRepo.Create(ctx, &websiteSSL); err != nil {
-			return dto.WebsiteHTTPS{}, err
+			return response.WebsiteHTTPS{}, err
 		}
-		website.WebSiteSSLID = websiteSSL.ID
+		website.WebsiteSSLID = websiteSSL.ID
 	}
 	if err := websiteRepo.Save(ctx, &website); err != nil {
-		return dto.WebsiteHTTPS{}, err
+		return response.WebsiteHTTPS{}, err
 	}
 
 	tx.Commit()
 	return res, nil
 }
 
-func (w WebsiteService) PreInstallCheck(req dto.WebsiteInstallCheckReq) ([]dto.WebsitePreInstallCheck, error) {
+func (w WebsiteService) PreInstallCheck(req request.WebsiteInstallCheckReq) ([]response.WebsitePreInstallCheck, error) {
 	var (
-		res      []dto.WebsitePreInstallCheck
+		res      []response.WebsitePreInstallCheck
 		checkIds []uint
 		showErr  = false
 	)
@@ -529,7 +530,7 @@ func (w WebsiteService) PreInstallCheck(req dto.WebsiteInstallCheckReq) ([]dto.W
 	}
 	appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithAppId(app.ID))
 	if reflect.DeepEqual(appInstall, model.AppInstall{}) {
-		res = append(res, dto.WebsitePreInstallCheck{
+		res = append(res, response.WebsitePreInstallCheck{
 			Name:    appInstall.Name,
 			AppName: app.Name,
 			Status:  buserr.WithMessage(constant.ErrNotInstall, app.Name, nil).Error(),
@@ -547,7 +548,7 @@ func (w WebsiteService) PreInstallCheck(req dto.WebsiteInstallCheckReq) ([]dto.W
 	if len(checkIds) > 0 {
 		installList, _ := appInstallRepo.GetBy(commonRepo.WithIdsIn(checkIds))
 		for _, install := range installList {
-			res = append(res, dto.WebsitePreInstallCheck{
+			res = append(res, response.WebsitePreInstallCheck{
 				Name:    install.Name,
 				Status:  install.Status,
 				Version: install.Version,
@@ -565,8 +566,8 @@ func (w WebsiteService) PreInstallCheck(req dto.WebsiteInstallCheckReq) ([]dto.W
 	}
 }
 
-func (w WebsiteService) GetWafConfig(req request.WebsiteWafReq) (dto.WebsiteWafConfig, error) {
-	var res dto.WebsiteWafConfig
+func (w WebsiteService) GetWafConfig(req request.WebsiteWafReq) (response.WebsiteWafConfig, error) {
+	var res response.WebsiteWafConfig
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
 	if err != nil {
 		return res, nil
diff --git a/backend/app/service/website_acme_account.go b/backend/app/service/website_acme_account.go
index 2b42e7966..480728f91 100644
--- a/backend/app/service/website_acme_account.go
+++ b/backend/app/service/website_acme_account.go
@@ -8,10 +8,10 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/utils/ssl"
 )
 
-type WebSiteAcmeAccountService struct {
+type WebsiteAcmeAccountService struct {
 }
 
-func (w WebSiteAcmeAccountService) Page(search dto.PageInfo) (int64, []dto.WebsiteAcmeAccountDTO, error) {
+func (w WebsiteAcmeAccountService) Page(search dto.PageInfo) (int64, []dto.WebsiteAcmeAccountDTO, error) {
 	total, accounts, err := websiteAcmeRepo.Page(search.Page, search.PageSize, commonRepo.WithOrderBy("created_at desc"))
 	var accountDTOs []dto.WebsiteAcmeAccountDTO
 	for _, account := range accounts {
@@ -22,7 +22,7 @@ func (w WebSiteAcmeAccountService) Page(search dto.PageInfo) (int64, []dto.Websi
 	return total, accountDTOs, err
 }
 
-func (w WebSiteAcmeAccountService) Create(create dto.WebsiteAcmeAccountCreate) (dto.WebsiteAcmeAccountDTO, error) {
+func (w WebsiteAcmeAccountService) Create(create dto.WebsiteAcmeAccountCreate) (dto.WebsiteAcmeAccountDTO, error) {
 	client, err := ssl.NewAcmeClient(create.Email, "")
 	if err != nil {
 		return dto.WebsiteAcmeAccountDTO{}, err
@@ -38,7 +38,7 @@ func (w WebSiteAcmeAccountService) Create(create dto.WebsiteAcmeAccountCreate) (
 	return dto.WebsiteAcmeAccountDTO{WebsiteAcmeAccount: acmeAccount}, nil
 }
 
-func (w WebSiteAcmeAccountService) Delete(id uint) error {
+func (w WebsiteAcmeAccountService) Delete(id uint) error {
 	if ssls, _ := websiteSSLRepo.List(websiteSSLRepo.WithByAcmeAccountId(id)); len(ssls) > 0 {
 		return buserr.New(constant.ErrAccountCannotDelete)
 	}
diff --git a/backend/app/service/website_dns_account.go b/backend/app/service/website_dns_account.go
index 9eda02169..150671a54 100644
--- a/backend/app/service/website_dns_account.go
+++ b/backend/app/service/website_dns_account.go
@@ -8,10 +8,10 @@ import (
 	"gopkg.in/square/go-jose.v2/json"
 )
 
-type WebSiteDnsAccountService struct {
+type WebsiteDnsAccountService struct {
 }
 
-func (w WebSiteDnsAccountService) Page(search dto.PageInfo) (int64, []dto.WebsiteDnsAccountDTO, error) {
+func (w WebsiteDnsAccountService) Page(search dto.PageInfo) (int64, []dto.WebsiteDnsAccountDTO, error) {
 	total, accounts, err := websiteDnsRepo.Page(search.Page, search.PageSize, commonRepo.WithOrderBy("created_at desc"))
 	var accountDTOs []dto.WebsiteDnsAccountDTO
 	for _, account := range accounts {
@@ -25,7 +25,7 @@ func (w WebSiteDnsAccountService) Page(search dto.PageInfo) (int64, []dto.Websit
 	return total, accountDTOs, err
 }
 
-func (w WebSiteDnsAccountService) Create(create dto.WebsiteDnsAccountCreate) (dto.WebsiteDnsAccountCreate, error) {
+func (w WebsiteDnsAccountService) Create(create dto.WebsiteDnsAccountCreate) (dto.WebsiteDnsAccountCreate, error) {
 	authorization, err := json.Marshal(create.Authorization)
 	if err != nil {
 		return dto.WebsiteDnsAccountCreate{}, err
@@ -42,7 +42,7 @@ func (w WebSiteDnsAccountService) Create(create dto.WebsiteDnsAccountCreate) (dt
 	return create, nil
 }
 
-func (w WebSiteDnsAccountService) Update(update dto.WebsiteDnsAccountUpdate) (dto.WebsiteDnsAccountUpdate, error) {
+func (w WebsiteDnsAccountService) Update(update dto.WebsiteDnsAccountUpdate) (dto.WebsiteDnsAccountUpdate, error) {
 	authorization, err := json.Marshal(update.Authorization)
 	if err != nil {
 		return dto.WebsiteDnsAccountUpdate{}, err
@@ -62,7 +62,7 @@ func (w WebSiteDnsAccountService) Update(update dto.WebsiteDnsAccountUpdate) (dt
 	return update, nil
 }
 
-func (w WebSiteDnsAccountService) Delete(id uint) error {
+func (w WebsiteDnsAccountService) Delete(id uint) error {
 	if ssls, _ := websiteSSLRepo.List(websiteSSLRepo.WithByDnsAccountId(id)); len(ssls) > 0 {
 		return buserr.New(constant.ErrAccountCannotDelete)
 	}
diff --git a/backend/app/service/website_group.go b/backend/app/service/website_group.go
index 93cdde93c..46efbca01 100644
--- a/backend/app/service/website_group.go
+++ b/backend/app/service/website_group.go
@@ -1,30 +1,30 @@
 package service
 
 import (
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 )
 
 type WebsiteGroupService struct {
 }
 
-func (w WebsiteGroupService) CreateGroup(create dto.WebSiteGroupCreate) error {
-	return websiteGroupRepo.Create(&model.WebSiteGroup{
+func (w WebsiteGroupService) CreateGroup(create request.WebsiteGroupCreate) error {
+	return websiteGroupRepo.Create(&model.WebsiteGroup{
 		Name: create.Name,
 	})
 }
 
-func (w WebsiteGroupService) GetGroups() ([]model.WebSiteGroup, error) {
+func (w WebsiteGroupService) GetGroups() ([]model.WebsiteGroup, error) {
 	return websiteGroupRepo.GetBy()
 }
 
-func (w WebsiteGroupService) UpdateGroup(update dto.WebSiteGroupUpdate) error {
+func (w WebsiteGroupService) UpdateGroup(update request.WebsiteGroupUpdate) error {
 
 	if update.Default {
 		if err := websiteGroupRepo.CancelDefault(); err != nil {
 			return err
 		}
-		return websiteGroupRepo.Save(&model.WebSiteGroup{
+		return websiteGroupRepo.Save(&model.WebsiteGroup{
 			BaseModel: model.BaseModel{
 				ID: update.ID,
 			},
@@ -32,7 +32,7 @@ func (w WebsiteGroupService) UpdateGroup(update dto.WebSiteGroupUpdate) error {
 			Default: true,
 		})
 	} else {
-		return websiteGroupRepo.Save(&model.WebSiteGroup{
+		return websiteGroupRepo.Save(&model.WebsiteGroup{
 			BaseModel: model.BaseModel{
 				ID: update.ID,
 			},
diff --git a/backend/app/service/website_ssl.go b/backend/app/service/website_ssl.go
index b98ccc6d8..a35cc7a23 100644
--- a/backend/app/service/website_ssl.go
+++ b/backend/app/service/website_ssl.go
@@ -13,10 +13,10 @@ import (
 	"strings"
 )
 
-type WebSiteSSLService struct {
+type WebsiteSSLService struct {
 }
 
-func (w WebSiteSSLService) Page(search dto.WebsiteSSLSearch) (int64, []dto.WebsiteSSLDTO, error) {
+func (w WebsiteSSLService) Page(search dto.WebsiteSSLSearch) (int64, []dto.WebsiteSSLDTO, error) {
 	total, sslList, err := websiteSSLRepo.Page(search.Page, search.PageSize, commonRepo.WithOrderBy("created_at desc"))
 	if err != nil {
 		return 0, nil, err
@@ -24,13 +24,13 @@ func (w WebSiteSSLService) Page(search dto.WebsiteSSLSearch) (int64, []dto.Websi
 	var sslDTOs []dto.WebsiteSSLDTO
 	for _, ssl := range sslList {
 		sslDTOs = append(sslDTOs, dto.WebsiteSSLDTO{
-			WebSiteSSL: ssl,
+			WebsiteSSL: ssl,
 		})
 	}
 	return total, sslDTOs, err
 }
 
-func (w WebSiteSSLService) Search() ([]dto.WebsiteSSLDTO, error) {
+func (w WebsiteSSLService) Search() ([]dto.WebsiteSSLDTO, error) {
 	sslList, err := websiteSSLRepo.List()
 	if err != nil {
 		return nil, err
@@ -38,13 +38,13 @@ func (w WebSiteSSLService) Search() ([]dto.WebsiteSSLDTO, error) {
 	var sslDTOs []dto.WebsiteSSLDTO
 	for _, ssl := range sslList {
 		sslDTOs = append(sslDTOs, dto.WebsiteSSLDTO{
-			WebSiteSSL: ssl,
+			WebsiteSSL: ssl,
 		})
 	}
 	return sslDTOs, err
 }
 
-func (w WebSiteSSLService) Create(create dto.WebsiteSSLCreate) (dto.WebsiteSSLCreate, error) {
+func (w WebsiteSSLService) Create(create dto.WebsiteSSLCreate) (dto.WebsiteSSLCreate, error) {
 
 	var res dto.WebsiteSSLCreate
 	acmeAccount, err := websiteAcmeRepo.GetFirst(commonRepo.WithByID(create.AcmeAccountID))
@@ -87,7 +87,7 @@ func (w WebSiteSSLService) Create(create dto.WebsiteSSLCreate) (dto.WebsiteSSLCr
 	if err != nil {
 		return res, err
 	}
-	var websiteSSL model.WebSiteSSL
+	var websiteSSL model.WebsiteSSL
 	websiteSSL.DnsAccountID = create.DnsAccountID
 	websiteSSL.AcmeAccountID = acmeAccount.ID
 	websiteSSL.Provider = string(create.Provider)
@@ -113,7 +113,7 @@ func (w WebSiteSSLService) Create(create dto.WebsiteSSLCreate) (dto.WebsiteSSLCr
 	return create, nil
 }
 
-func (w WebSiteSSLService) Renew(sslId uint) error {
+func (w WebsiteSSLService) Renew(sslId uint) error {
 
 	websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(sslId))
 	if err != nil {
@@ -169,7 +169,7 @@ func (w WebSiteSSLService) Renew(sslId uint) error {
 	return websiteSSLRepo.Save(websiteSSL)
 }
 
-func (w WebSiteSSLService) GetDNSResolve(req dto.WebsiteDNSReq) ([]dto.WebsiteDNSRes, error) {
+func (w WebsiteSSLService) GetDNSResolve(req dto.WebsiteDNSReq) ([]dto.WebsiteDNSRes, error) {
 	acmeAccount, err := websiteAcmeRepo.GetFirst(commonRepo.WithByID(req.AcmeAccountID))
 	if err != nil {
 		return nil, err
@@ -195,21 +195,21 @@ func (w WebSiteSSLService) GetDNSResolve(req dto.WebsiteDNSReq) ([]dto.WebsiteDN
 	return res, nil
 }
 
-func (w WebSiteSSLService) GetWebsiteSSL(websiteId uint) (dto.WebsiteSSLDTO, error) {
+func (w WebsiteSSLService) GetWebsiteSSL(websiteId uint) (dto.WebsiteSSLDTO, error) {
 	var res dto.WebsiteSSLDTO
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteId))
 	if err != nil {
 		return res, err
 	}
-	websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebSiteSSLID))
+	websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID))
 	if err != nil {
 		return res, err
 	}
-	res.WebSiteSSL = websiteSSL
+	res.WebsiteSSL = websiteSSL
 	return res, nil
 }
 
-func (w WebSiteSSLService) Delete(id uint) error {
+func (w WebsiteSSLService) Delete(id uint) error {
 	if websites, _ := websiteRepo.GetBy(websiteRepo.WithWebsiteSSLID(id)); len(websites) > 0 {
 		return buserr.New(constant.ErrSSLCannotDelete)
 	}
diff --git a/backend/app/service/website_utils.go b/backend/app/service/website_utils.go
index 10c364bf3..edc977882 100644
--- a/backend/app/service/website_utils.go
+++ b/backend/app/service/website_utils.go
@@ -24,9 +24,9 @@ import (
 	"strings"
 )
 
-func getDomain(domainStr string, websiteID uint) (model.WebSiteDomain, error) {
-	domain := model.WebSiteDomain{
-		WebSiteID: websiteID,
+func getDomain(domainStr string, websiteID uint) (model.WebsiteDomain, error) {
+	domain := model.WebsiteDomain{
+		WebsiteID: websiteID,
 	}
 	domainArray := strings.Split(domainStr, ":")
 	if len(domainArray) == 1 {
@@ -39,15 +39,15 @@ func getDomain(domainStr string, websiteID uint) (model.WebSiteDomain, error) {
 		portStr := domainArray[1]
 		portN, err := strconv.Atoi(portStr)
 		if err != nil {
-			return model.WebSiteDomain{}, err
+			return model.WebsiteDomain{}, err
 		}
 		domain.Port = portN
 		return domain, nil
 	}
-	return model.WebSiteDomain{}, nil
+	return model.WebsiteDomain{}, nil
 }
 
-func createStaticHtml(website *model.WebSite) error {
+func createStaticHtml(website *model.Website) error {
 	nginxInstall, err := getAppInstallByKey("nginx")
 	if err != nil {
 		return err
@@ -73,7 +73,7 @@ func createStaticHtml(website *model.WebSite) error {
 	return nil
 }
 
-func createWebsiteFolder(nginxInstall model.AppInstall, website *model.WebSite) error {
+func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website) error {
 	nginxFolder := path.Join(constant.AppInstallDir, "nginx", nginxInstall.Name)
 	siteFolder := path.Join(nginxFolder, "www", "sites", website.Alias)
 	fileOp := files.NewFileOp()
@@ -97,7 +97,7 @@ func createWebsiteFolder(nginxInstall model.AppInstall, website *model.WebSite)
 	return fileOp.CopyDir(path.Join(nginxFolder, "www", "common", "waf", "rules"), path.Join(siteFolder, "waf"))
 }
 
-func configDefaultNginx(website *model.WebSite, domains []model.WebSiteDomain) error {
+func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain) error {
 	nginxInstall, err := getAppInstallByKey("nginx")
 	if err != nil {
 		return err
@@ -155,7 +155,7 @@ func configDefaultNginx(website *model.WebSite, domains []model.WebSiteDomain) e
 	return opNginx(nginxInstall.ContainerName, constant.NginxReload)
 }
 
-func delNginxConfig(website model.WebSite, force bool) error {
+func delNginxConfig(website model.Website, force bool) error {
 	nginxApp, err := appRepo.GetFirst(appRepo.WithKey("nginx"))
 	if err != nil {
 		return err
@@ -187,7 +187,7 @@ func delNginxConfig(website model.WebSite, force bool) error {
 	return nil
 }
 
-func addListenAndServerName(website model.WebSite, ports []int, domains []string) error {
+func addListenAndServerName(website model.Website, ports []int, domains []string) error {
 	nginxFull, err := getNginxFull(&website)
 	if err != nil {
 		return nil
@@ -207,7 +207,7 @@ func addListenAndServerName(website model.WebSite, ports []int, domains []string
 	return nginxCheckAndReload(nginxConfig.OldContent, nginxConfig.FilePath, nginxFull.Install.ContainerName)
 }
 
-func deleteListenAndServerName(website model.WebSite, ports []int, domains []string) error {
+func deleteListenAndServerName(website model.Website, ports []int, domains []string) error {
 	nginxFull, err := getNginxFull(&website)
 	if err != nil {
 		return nil
@@ -241,7 +241,7 @@ func getKeysFromStaticFile(scope dto.NginxKey) []string {
 	return res
 }
 
-func createPemFile(website model.WebSite, websiteSSL model.WebSiteSSL) error {
+func createPemFile(website model.Website, websiteSSL model.WebsiteSSL) error {
 	nginxApp, err := appRepo.GetFirst(appRepo.WithKey("nginx"))
 	if err != nil {
 		return err
@@ -283,7 +283,7 @@ func createPemFile(website model.WebSite, websiteSSL model.WebSiteSSL) error {
 	return nil
 }
 
-func applySSL(website model.WebSite, websiteSSL model.WebSiteSSL) error {
+func applySSL(website model.Website, websiteSSL model.WebsiteSSL) error {
 	nginxFull, err := getNginxFull(&website)
 	if err != nil {
 		return nil
@@ -369,7 +369,7 @@ func toMapStr(m map[string]interface{}) map[string]string {
 	return ret
 }
 
-type WebSiteInfo struct {
+type WebsiteInfo struct {
 	WebsiteName string `json:"websiteName"`
 	WebsiteType string `json:"websiteType"`
 }
@@ -444,7 +444,7 @@ func handleWebsiteBackup(backupType, baseDir, backupDir, domain, backupName stri
 	return nil
 }
 
-func handleWebsiteRecover(website *model.WebSite, fileDir string) error {
+func handleWebsiteRecover(website *model.Website, fileDir string) error {
 	nginxInfo, err := appInstallRepo.LoadBaseInfoByKey("nginx")
 	if err != nil {
 		return err
@@ -486,7 +486,7 @@ func handleWebsiteRecover(website *model.WebSite, fileDir string) error {
 	return nil
 }
 
-func mysqlOpration(website *model.WebSite, operation, filePath string) error {
+func mysqlOpration(website *model.Website, operation, filePath string) error {
 	mysqlInfo, err := appInstallRepo.LoadBaseInfoByKey("mysql")
 	if err != nil {
 		return err
@@ -523,11 +523,11 @@ func mysqlOpration(website *model.WebSite, operation, filePath string) error {
 	return nil
 }
 
-func saveWebsiteJson(website *model.WebSite, tmpDir string) error {
-	var WebSiteInfo WebSiteInfo
-	WebSiteInfo.WebsiteType = website.Type
-	WebSiteInfo.WebsiteName = website.PrimaryDomain
-	remarkInfo, _ := json.Marshal(WebSiteInfo)
+func saveWebsiteJson(website *model.Website, tmpDir string) error {
+	var websiteInfo WebsiteInfo
+	websiteInfo.WebsiteType = website.Type
+	websiteInfo.WebsiteName = website.PrimaryDomain
+	remarkInfo, _ := json.Marshal(websiteInfo)
 	path := fmt.Sprintf("%s/website.json", tmpDir)
 	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
 	if err != nil {
diff --git a/backend/constant/app.go b/backend/constant/app.go
index 30964fee6..a401fbbd0 100644
--- a/backend/constant/app.go
+++ b/backend/constant/app.go
@@ -6,13 +6,9 @@ const (
 	Error      = "Error"
 	Stopped    = "Stopped"
 	Installing = "Installing"
-)
 
-const (
 	ContainerPrefix = "1Panel-"
-)
 
-const (
 	AppNormal   = "Normal"
 	AppTakeDown = "TakeDown"
 )
diff --git a/backend/constant/website.go b/backend/constant/website.go
index b0d90f742..e27021fb8 100644
--- a/backend/constant/website.go
+++ b/backend/constant/website.go
@@ -3,20 +3,21 @@ package constant
 const (
 	WebRunning = "Running"
 	WebStopped = "Stopped"
-)
 
-const (
 	DateLayout  = "2006-01-02"
 	DefaultDate = "1970-01-01"
-)
 
-const (
 	ProtocolHTTP  = "HTTP"
 	ProtocolHTTPS = "HTTPS"
-)
 
-const (
+	NewApp       = "new"
+	InstalledApp = "installed"
+
 	Deployment = "deployment"
 	Static     = "static"
 	Proxy      = "proxy"
+
+	SSLExisted = "existed"
+	SSLAuto    = "auto"
+	SSLManual  = "manual"
 )
diff --git a/backend/init/migration/migrations/init.go b/backend/init/migration/migrations/init.go
index af237d55a..f5a5e1a6d 100644
--- a/backend/init/migration/migrations/init.go
+++ b/backend/init/migration/migrations/init.go
@@ -185,10 +185,10 @@ var AddTableDatabaseMysql = &gormigrate.Migration{
 var AddTableWebsite = &gormigrate.Migration{
 	ID: "20201009-add-table-website",
 	Migrate: func(tx *gorm.DB) error {
-		if err := tx.AutoMigrate(&model.WebSite{}, &model.WebSiteDomain{}, &model.WebSiteGroup{}, &model.WebsiteDnsAccount{}, &model.WebSiteSSL{}, &model.WebsiteAcmeAccount{}); err != nil {
+		if err := tx.AutoMigrate(&model.Website{}, &model.WebsiteDomain{}, &model.WebsiteGroup{}, &model.WebsiteDnsAccount{}, &model.WebsiteSSL{}, &model.WebsiteAcmeAccount{}); err != nil {
 			return err
 		}
-		item := &model.WebSiteGroup{
+		item := &model.WebsiteGroup{
 			Name:    "默认分组",
 			Default: true,
 		}
diff --git a/backend/router/ro_website.go b/backend/router/ro_website.go
index b2574f1bb..e7e1e7725 100644
--- a/backend/router/ro_website.go
+++ b/backend/router/ro_website.go
@@ -15,20 +15,22 @@ func (a *WebsiteRouter) InitWebsiteRouter(Router *gin.RouterGroup) {
 
 	baseApi := v1.ApiGroupApp.BaseApi
 	{
+		groupRouter.POST("/search", baseApi.PageWebsite)
 		groupRouter.POST("", baseApi.CreateWebsite)
 		groupRouter.POST("/check", baseApi.CreateWebsiteCheck)
 		groupRouter.GET("/options", baseApi.GetWebsiteOptions)
+		groupRouter.POST("/update", baseApi.UpdateWebsite)
+		groupRouter.GET("/:id", baseApi.GetWebsite)
+		groupRouter.POST("/del", baseApi.DeleteWebsite)
 		groupRouter.POST("/backup/:domain", baseApi.BackupWebsite)
 		groupRouter.POST("/recover", baseApi.RecoverWebsite)
 		groupRouter.POST("/recover/byupload", baseApi.RecoverWebsiteByUpload)
-		groupRouter.POST("/update", baseApi.UpdateWebSite)
-		groupRouter.GET("/:id", baseApi.GetWebSite)
-		groupRouter.GET("/:id/nginx", baseApi.GetWebSiteNginx)
-		groupRouter.POST("/search", baseApi.PageWebsite)
-		groupRouter.POST("/del", baseApi.DeleteWebSite)
+
 		groupRouter.GET("/domains/:websiteId", baseApi.GetWebDomains)
-		groupRouter.DELETE("/domains/:id", baseApi.DeleteWebDomain)
+		groupRouter.POST("/domains/del", baseApi.DeleteWebDomain)
 		groupRouter.POST("/domains", baseApi.CreateWebDomain)
+
+		groupRouter.GET("/:id/nginx", baseApi.GetWebsiteNginx)
 		groupRouter.POST("/config", baseApi.GetNginxConfig)
 		groupRouter.POST("/config/update", baseApi.UpdateNginxConfig)
 		groupRouter.GET("/:id/https", baseApi.GetHTTPSConfig)
diff --git a/frontend/src/api/interface/website.ts b/frontend/src/api/interface/website.ts
index 1a1a967a9..16e717a05 100644
--- a/frontend/src/api/interface/website.ts
+++ b/frontend/src/api/interface/website.ts
@@ -1,7 +1,7 @@
 import { CommonModel, ReqPage } from '.';
 
-export namespace WebSite {
-    export interface WebSite extends CommonModel {
+export namespace Website {
+    export interface Website extends CommonModel {
         primaryDomain: string;
         type: string;
         alias: string;
@@ -15,19 +15,6 @@ export namespace WebSite {
         webSiteSSL: SSL;
     }
 
-    export interface WebSiteDTO extends CommonModel {
-        primaryDomain: string;
-        type: string;
-        alias: string;
-        remark: string;
-        domains: WebSite.Domain[];
-        appType: string;
-        appInstallId?: number;
-        webSiteGroupId: number;
-        otherDomains: string;
-        appinstall?: NewAppInstall;
-    }
-
     export interface NewAppInstall {
         name: string;
         appDetailId: number;
@@ -100,6 +87,10 @@ export namespace WebSite {
         domain: string;
     }
 
+    export interface DomainDelete {
+        id: number;
+    }
+
     export interface NginxConfigReq {
         operate: string;
         websiteId: number;
diff --git a/frontend/src/api/modules/website.ts b/frontend/src/api/modules/website.ts
index a71831500..db4c01a98 100644
--- a/frontend/src/api/modules/website.ts
+++ b/frontend/src/api/modules/website.ts
@@ -1,32 +1,34 @@
 import http from '@/api';
 import { ReqPage, ResPage } from '../interface';
-import { WebSite } from '../interface/website';
+import { Website } from '../interface/Website';
 import { File } from '../interface/file';
 
-export const SearchWebSites = (req: WebSite.WebSiteSearch) => {
-    return http.post<ResPage<WebSite.WebSite>>(`/websites/search`, req);
+export const SearchWebsites = (req: Website.WebSiteSearch) => {
+    return http.post<ResPage<Website.Website>>(`/websites/search`, req);
 };
 
-export const CreateWebsite = (req: WebSite.WebSiteCreateReq) => {
+export const CreateWebsite = (req: Website.WebSiteCreateReq) => {
     return http.post<any>(`/websites`, req);
 };
 
 export const BackupWebsite = (id: number) => {
     return http.post(`/websites/backup/${id}`);
 };
-export const RecoverWebsite = (req: WebSite.WebSiteRecover) => {
+
+export const RecoverWebsite = (req: Website.WebSiteRecover) => {
     return http.post(`/websites/recover`, req);
 };
-export const RecoverWebsiteByUpload = (req: WebSite.WebsiteRecoverByUpload) => {
+
+export const RecoverWebsiteByUpload = (req: Website.WebsiteRecoverByUpload) => {
     return http.post(`/websites/recover/byupload`, req);
 };
 
-export const UpdateWebsite = (req: WebSite.WebSiteUpdateReq) => {
+export const UpdateWebsite = (req: Website.WebSiteUpdateReq) => {
     return http.post<any>(`/websites/update`, req);
 };
 
 export const GetWebsite = (id: number) => {
-    return http.get<WebSite.WebSiteDTO>(`/websites/${id}`);
+    return http.get<Website.Website>(`/websites/${id}`);
 };
 
 export const GetWebsiteOptions = () => {
@@ -37,19 +39,19 @@ export const GetWebsiteNginx = (id: number) => {
     return http.get<File.File>(`/websites/${id}/nginx`);
 };
 
-export const DeleteWebsite = (req: WebSite.WebSiteDel) => {
+export const DeleteWebsite = (req: Website.WebSiteDel) => {
     return http.post<any>(`/websites/del`, req);
 };
 
 export const ListGroups = () => {
-    return http.get<WebSite.Group[]>(`/websites/groups`);
+    return http.get<Website.Group[]>(`/websites/groups`);
 };
 
-export const CreateGroup = (req: WebSite.GroupOp) => {
+export const CreateGroup = (req: Website.GroupOp) => {
     return http.post<any>(`/websites/groups`, req);
 };
 
-export const UpdateGroup = (req: WebSite.GroupOp) => {
+export const UpdateGroup = (req: Website.GroupOp) => {
     return http.put<any>(`/websites/groups`, req);
 };
 
@@ -58,34 +60,34 @@ export const DeleteGroup = (id: number) => {
 };
 
 export const ListDomains = (id: number) => {
-    return http.get<WebSite.Domain[]>(`/websites/domains/${id}`);
+    return http.get<Website.Domain[]>(`/websites/domains/${id}`);
 };
 
-export const DeleteDomain = (id: number) => {
-    return http.delete<any>(`/websites/domains/${id}`);
+export const DeleteDomain = (req: Website.DomainDelete) => {
+    return http.post<any>(`/websites/domains/del/`, req);
 };
 
-export const CreateDomain = (req: WebSite.DomainCreate) => {
+export const CreateDomain = (req: Website.DomainCreate) => {
     return http.post<any>(`/websites/domains`, req);
 };
 
-export const GetNginxConfig = (req: WebSite.NginxConfigReq) => {
-    return http.post<WebSite.NginxScopeConfig>(`/websites/config`, req);
+export const GetNginxConfig = (req: Website.NginxConfigReq) => {
+    return http.post<Website.NginxScopeConfig>(`/websites/config`, req);
 };
 
-export const UpdateNginxConfig = (req: WebSite.NginxConfigReq) => {
+export const UpdateNginxConfig = (req: Website.NginxConfigReq) => {
     return http.post<any>(`/websites/config/update`, req);
 };
 
 export const SearchDnsAccount = (req: ReqPage) => {
-    return http.post<ResPage<WebSite.DnsAccount>>(`/websites/dns/search`, req);
+    return http.post<ResPage<Website.DnsAccount>>(`/websites/dns/search`, req);
 };
 
-export const CreateDnsAccount = (req: WebSite.DnsAccountCreate) => {
+export const CreateDnsAccount = (req: Website.DnsAccountCreate) => {
     return http.post<any>(`/websites/dns`, req);
 };
 
-export const UpdateDnsAccount = (req: WebSite.DnsAccountUpdate) => {
+export const UpdateDnsAccount = (req: Website.DnsAccountUpdate) => {
     return http.post<any>(`/websites/dns/update`, req);
 };
 
@@ -94,11 +96,11 @@ export const DeleteDnsAccount = (id: number) => {
 };
 
 export const SearchAcmeAccount = (req: ReqPage) => {
-    return http.post<ResPage<WebSite.AcmeAccount>>(`/websites/acme/search`, req);
+    return http.post<ResPage<Website.AcmeAccount>>(`/websites/acme/search`, req);
 };
 
-export const CreateAcmeAccount = (req: WebSite.AcmeAccountCreate) => {
-    return http.post<WebSite.AcmeAccount>(`/websites/acme`, req);
+export const CreateAcmeAccount = (req: Website.AcmeAccountCreate) => {
+    return http.post<Website.AcmeAccount>(`/websites/acme`, req);
 };
 
 export const DeleteAcmeAccount = (id: number) => {
@@ -106,15 +108,15 @@ export const DeleteAcmeAccount = (id: number) => {
 };
 
 export const SearchSSL = (req: ReqPage) => {
-    return http.post<ResPage<WebSite.SSL>>(`/websites/ssl/search`, req);
+    return http.post<ResPage<Website.SSL>>(`/websites/ssl/search`, req);
 };
 
-export const ListSSL = (req: WebSite.SSLReq) => {
-    return http.post<WebSite.SSL[]>(`/websites/ssl/search`, req);
+export const ListSSL = (req: Website.SSLReq) => {
+    return http.post<Website.SSL[]>(`/websites/ssl/search`, req);
 };
 
-export const CreateSSL = (req: WebSite.SSLCreate) => {
-    return http.post<WebSite.SSLCreate>(`/websites/ssl`, req);
+export const CreateSSL = (req: Website.SSLCreate) => {
+    return http.post<Website.SSLCreate>(`/websites/ssl`, req);
 };
 
 export const DeleteSSL = (id: number) => {
@@ -122,37 +124,37 @@ export const DeleteSSL = (id: number) => {
 };
 
 export const GetWebsiteSSL = (websiteId: number) => {
-    return http.get<WebSite.SSL>(`/websites/ssl/${websiteId}`);
+    return http.get<Website.SSL>(`/websites/ssl/${websiteId}`);
 };
 
-export const ApplySSL = (req: WebSite.SSLApply) => {
-    return http.post<WebSite.SSLApply>(`/websites/ssl/apply`, req);
+export const ApplySSL = (req: Website.SSLApply) => {
+    return http.post<Website.SSLApply>(`/websites/ssl/apply`, req);
 };
 
-export const RenewSSL = (req: WebSite.SSLRenew) => {
+export const RenewSSL = (req: Website.SSLRenew) => {
     return http.post<any>(`/websites/ssl/renew`, req);
 };
 
-export const GetDnsResolve = (req: WebSite.DNSResolveReq) => {
-    return http.post<WebSite.DNSResolve[]>(`/websites/ssl/resolve`, req);
+export const GetDnsResolve = (req: Website.DNSResolveReq) => {
+    return http.post<Website.DNSResolve[]>(`/websites/ssl/resolve`, req);
 };
 
 export const GetHTTPSConfig = (id: number) => {
-    return http.get<WebSite.HTTPSConfig>(`/websites/${id}/https`);
+    return http.get<Website.HTTPSConfig>(`/websites/${id}/https`);
 };
 
-export const UpdateHTTPSConfig = (req: WebSite.HTTPSReq) => {
-    return http.post<WebSite.HTTPSConfig>(`/websites/${req.websiteId}/https`, req);
+export const UpdateHTTPSConfig = (req: Website.HTTPSReq) => {
+    return http.post<Website.HTTPSConfig>(`/websites/${req.websiteId}/https`, req);
 };
 
-export const PreCheck = (req: WebSite.CheckReq) => {
-    return http.post<WebSite.CheckRes[]>(`/websites/check`, req);
+export const PreCheck = (req: Website.CheckReq) => {
+    return http.post<Website.CheckRes[]>(`/websites/check`, req);
 };
 
-export const GetWafConfig = (req: WebSite.WafReq) => {
-    return http.post<WebSite.WafRes>(`/websites/waf/config`, req);
+export const GetWafConfig = (req: Website.WafReq) => {
+    return http.post<Website.WafRes>(`/websites/waf/config`, req);
 };
 
-export const UpdateWafEnable = (req: WebSite.WafUpdate) => {
+export const UpdateWafEnable = (req: Website.WafUpdate) => {
     return http.post<any>(`/websites/waf/update`, req);
 };
diff --git a/frontend/src/views/website/ssl/acme-account/index.vue b/frontend/src/views/website/ssl/acme-account/index.vue
index e3f727e4d..93465f657 100644
--- a/frontend/src/views/website/ssl/acme-account/index.vue
+++ b/frontend/src/views/website/ssl/acme-account/index.vue
@@ -23,7 +23,7 @@
     </el-dialog>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { DeleteAcmeAccount, SearchAcmeAccount } from '@/api/modules/website';
 import ComplexTable from '@/components/complex-table/index.vue';
 import { useDeleteData } from '@/hooks/use-delete-data';
@@ -44,7 +44,7 @@ const paginationConfig = reactive({
 const buttons = [
     {
         label: i18n.global.t('app.delete'),
-        click: function (row: WebSite.AcmeAccount) {
+        click: function (row: Website.AcmeAccount) {
             deleteAccount(row.id);
         },
     },
diff --git a/frontend/src/views/website/ssl/create/index.vue b/frontend/src/views/website/ssl/create/index.vue
index 595fa151b..8e8b3ea33 100644
--- a/frontend/src/views/website/ssl/create/index.vue
+++ b/frontend/src/views/website/ssl/create/index.vue
@@ -76,7 +76,7 @@
 </template>
 
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { CreateSSL, GetDnsResolve, SearchAcmeAccount, SearchDnsAccount } from '@/api/modules/website';
 import { Rules } from '@/global/form-rules';
 import i18n from '@/lang';
@@ -104,9 +104,9 @@ let acmeReq = reactive({
     page: 1,
     pageSize: 20,
 });
-let dnsAccounts = ref<WebSite.DnsAccount[]>();
-let acmeAccounts = ref<WebSite.AcmeAccount[]>();
-// let domains = ref<WebSite.Domain[]>([]);
+let dnsAccounts = ref<Website.DnsAccount[]>();
+let acmeAccounts = ref<Website.AcmeAccount[]>();
+// let domains = ref<Website.Domain[]>([]);
 let sslForm = ref<FormInstance>();
 let rules = ref({
     primaryDomain: [Rules.requiredInput],
@@ -122,7 +122,7 @@ let ssl = ref({
     acmeAccountId: undefined,
     dnsAccountId: undefined,
 });
-let dnsResolve = ref<WebSite.DNSResolve[]>([]);
+let dnsResolve = ref<Website.DNSResolve[]>([]);
 let hasResolve = ref(false);
 
 const em = defineEmits(['close']);
@@ -168,10 +168,6 @@ const getDnsAccounts = async () => {
     }
 };
 
-// const getWebsite = async (id: number) => {
-//     domains.value = (await GetWebsite(id)).data.domains || [];
-// };
-
 const getDnsResolve = async (acmeAccountId: number, domains: string[]) => {
     hasResolve.value = false;
     loading.value = true;
diff --git a/frontend/src/views/website/ssl/dns-account/index.vue b/frontend/src/views/website/ssl/dns-account/index.vue
index 8074a1b4e..fab927c7b 100644
--- a/frontend/src/views/website/ssl/dns-account/index.vue
+++ b/frontend/src/views/website/ssl/dns-account/index.vue
@@ -36,7 +36,7 @@
 <script lang="ts" setup>
 import ComplexTable from '@/components/complex-table/index.vue';
 import Create from './create/index.vue';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { DeleteDnsAccount, SearchDnsAccount } from '@/api/modules/website';
 import { onMounted, reactive, ref } from 'vue';
 import i18n from '@/lang';
@@ -47,7 +47,7 @@ const paginationConfig = reactive({
     pageSize: 20,
     total: 0,
 });
-let data = ref<WebSite.DnsAccount[]>();
+let data = ref<Website.DnsAccount[]>();
 let createRef = ref();
 let loading = ref(false);
 let open = ref(false);
@@ -55,7 +55,7 @@ let open = ref(false);
 const buttons = [
     {
         label: i18n.global.t('app.delete'),
-        click: function (row: WebSite.WebSite) {
+        click: function (row: Website.Website) {
             deleteAccount(row.id);
         },
     },
@@ -81,7 +81,7 @@ const openCreate = () => {
     createRef.value.acceptParams({ mode: 'add' });
 };
 
-const openEdit = (form: WebSite.DnsAccount) => {
+const openEdit = (form: Website.DnsAccount) => {
     createRef.value.acceptParams({ mode: 'edit', form: form });
 };
 
diff --git a/frontend/src/views/website/ssl/index.vue b/frontend/src/views/website/ssl/index.vue
index d0404e8ec..2f78b6564 100644
--- a/frontend/src/views/website/ssl/index.vue
+++ b/frontend/src/views/website/ssl/index.vue
@@ -68,7 +68,7 @@ import Renew from './renew/index.vue';
 import Create from './create/index.vue';
 import { dateFromat } from '@/utils/util';
 import i18n from '@/lang';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { useDeleteData } from '@/hooks/use-delete-data';
 
 const paginationConfig = reactive({
@@ -86,13 +86,13 @@ let loading = ref(false);
 const buttons = [
     {
         label: i18n.global.t('website.renewSSL'),
-        click: function (row: WebSite.WebSite) {
+        click: function (row: Website.Website) {
             openRenewSSL(row.id);
         },
     },
     {
         label: i18n.global.t('app.delete'),
-        click: function (row: WebSite.WebSite) {
+        click: function (row: Website.Website) {
             deleteSSL(row.id);
         },
     },
diff --git a/frontend/src/views/website/website/check/index.vue b/frontend/src/views/website/website/check/index.vue
index ad212bdce..35f8f71b3 100644
--- a/frontend/src/views/website/website/check/index.vue
+++ b/frontend/src/views/website/website/check/index.vue
@@ -29,13 +29,13 @@
     </el-dialog>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { ref } from 'vue';
 import { useRouter } from 'vue-router';
 const router = useRouter();
 
 interface InstallRrops {
-    items: WebSite.CheckRes[];
+    items: Website.CheckRes[];
 }
 
 let open = ref(false);
diff --git a/frontend/src/views/website/website/config/basic/default-doc/index.vue b/frontend/src/views/website/website/config/basic/default-doc/index.vue
index caa9a6035..328ed5214 100644
--- a/frontend/src/views/website/website/config/basic/default-doc/index.vue
+++ b/frontend/src/views/website/website/config/basic/default-doc/index.vue
@@ -18,7 +18,7 @@
 </template>
 
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetNginxConfig, UpdateNginxConfig } from '@/api/modules/website';
 import { Rules } from '@/global/form-rules';
 import { ElMessage, FormInstance } from 'element-plus';
@@ -69,7 +69,7 @@ const submit = async (formEl: FormInstance | undefined) => {
     });
 };
 
-const search = (req: WebSite.NginxConfigReq) => {
+const search = (req: Website.NginxConfigReq) => {
     loading.value = true;
     GetNginxConfig(req)
         .then((res) => {
diff --git a/frontend/src/views/website/website/config/basic/domain/create/index.vue b/frontend/src/views/website/website/config/basic/domain/create/index.vue
index 021c9afa5..af2fba94d 100644
--- a/frontend/src/views/website/website/config/basic/domain/create/index.vue
+++ b/frontend/src/views/website/website/config/basic/domain/create/index.vue
@@ -1,7 +1,6 @@
 <template>
     <el-dialog
         v-model="open"
-        :destroy-on-close="true"
         :close-on-click-modal="false"
         :title="$t('website.create')"
         width="40%"
@@ -36,7 +35,7 @@ import { ref } from 'vue';
 const domainForm = ref<FormInstance>();
 
 let rules = ref({
-    domain: [Rules.requiredInput],
+    domain: [Rules.requiredInput, Rules.domain],
     port: [Rules.requiredInput],
 });
 
@@ -50,6 +49,7 @@ let domain = ref({
 
 const em = defineEmits(['close']);
 const handleClose = () => {
+    domainForm.value?.resetFields();
     open.value = false;
     em('close', false);
 };
diff --git a/frontend/src/views/website/website/config/basic/domain/index.vue b/frontend/src/views/website/website/config/basic/domain/index.vue
index 36a6b73cd..605afad58 100644
--- a/frontend/src/views/website/website/config/basic/domain/index.vue
+++ b/frontend/src/views/website/website/config/basic/domain/index.vue
@@ -13,7 +13,7 @@
 <script lang="ts" setup>
 import ComplexTable from '@/components/complex-table/index.vue';
 import Domain from './create/index.vue';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { DeleteDomain, ListDomains } from '@/api/modules/website';
 import { computed, onMounted, ref } from 'vue';
 import i18n from '@/lang';
@@ -29,13 +29,13 @@ const id = computed(() => {
     return props.id;
 });
 let loading = ref(false);
-const data = ref<WebSite.Domain[]>([]);
+const data = ref<Website.Domain[]>([]);
 const domainRef = ref();
 
 const buttons = [
     {
         label: i18n.global.t('app.delete'),
-        click: function (row: WebSite.Domain) {
+        click: function (row: Website.Domain) {
             deleteDoamin(row.id);
         },
         disabled: () => {
@@ -49,7 +49,7 @@ const openCreate = () => {
 };
 
 const deleteDoamin = async (domainId: number) => {
-    await useDeleteData(DeleteDomain, domainId, 'commons.msg.delete');
+    await useDeleteData(DeleteDomain, { id: domainId }, 'commons.msg.delete');
     search(id.value);
 };
 
diff --git a/frontend/src/views/website/website/config/basic/https/index.vue b/frontend/src/views/website/website/config/basic/https/index.vue
index 533e1e081..a13143ea3 100644
--- a/frontend/src/views/website/website/config/basic/https/index.vue
+++ b/frontend/src/views/website/website/config/basic/https/index.vue
@@ -62,7 +62,7 @@
     </el-row>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetHTTPSConfig, ListSSL, UpdateHTTPSConfig } from '@/api/modules/website';
 import { ElMessage, FormInstance } from 'element-plus';
 import { computed, onMounted, reactive, ref } from 'vue';
@@ -104,7 +104,7 @@ const listSSL = () => {
 };
 
 const changeSSl = (sslid: number) => {
-    const res = ssls.value.filter((element: WebSite.SSL) => {
+    const res = ssls.value.filter((element: Website.SSL) => {
         return element.id == sslid;
     });
     websiteSSL.value = res[0];
diff --git a/frontend/src/views/website/website/config/basic/limit-conn/index.vue b/frontend/src/views/website/website/config/basic/limit-conn/index.vue
index 51719e07e..bedcc19a6 100644
--- a/frontend/src/views/website/website/config/basic/limit-conn/index.vue
+++ b/frontend/src/views/website/website/config/basic/limit-conn/index.vue
@@ -25,7 +25,7 @@
 
 <script lang="ts" setup>
 import { Rules } from '@/global/form-rules';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetNginxConfig, UpdateNginxConfig } from '@/api/modules/website';
 import { ElMessage, FormInstance } from 'element-plus';
 import { computed, onMounted, reactive, ref } from 'vue';
@@ -60,7 +60,7 @@ let req = reactive({
 let enable = ref(false);
 let loading = ref(false);
 
-const search = (req: WebSite.NginxConfigReq) => {
+const search = (req: Website.NginxConfigReq) => {
     loading.value = true;
     GetNginxConfig(req)
         .then((res) => {
diff --git a/frontend/src/views/website/website/config/basic/other/index.vue b/frontend/src/views/website/website/config/basic/other/index.vue
index 6069a66b2..9bbf2425b 100644
--- a/frontend/src/views/website/website/config/basic/other/index.vue
+++ b/frontend/src/views/website/website/config/basic/other/index.vue
@@ -36,7 +36,7 @@
 </template>
 
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetWebsite, UpdateWebsite } from '@/api/modules/website';
 import { Rules } from '@/global/form-rules';
 import { computed, onMounted, reactive, ref } from 'vue';
@@ -65,7 +65,7 @@ let rules = ref({
     primaryDomain: [Rules.requiredInput],
     webSiteGroupId: [Rules.requiredSelect],
 });
-let groups = ref<WebSite.Group[]>([]);
+let groups = ref<Website.Group[]>([]);
 
 const submit = async (formEl: FormInstance | undefined) => {
     if (!formEl) return;
diff --git a/frontend/src/views/website/website/config/safety/ccdeny/index.vue b/frontend/src/views/website/website/config/safety/ccdeny/index.vue
index 3df748600..26a808ced 100644
--- a/frontend/src/views/website/website/config/safety/ccdeny/index.vue
+++ b/frontend/src/views/website/website/config/safety/ccdeny/index.vue
@@ -39,7 +39,7 @@
 </template>
 
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { SaveFileContent } from '@/api/modules/files';
 import { GetWafConfig, UpdateWafEnable } from '@/api/modules/website';
 import { Rules } from '@/global/form-rules';
@@ -57,19 +57,19 @@ const id = computed(() => {
     return props.id;
 });
 
-let data = ref<WebSite.WafRes>();
+let data = ref<Website.WafRes>();
 let loading = ref(false);
 let form = reactive({
     enable: false,
     cycle: 60,
     frequency: 120,
 });
-let req = ref<WebSite.WafReq>({
+let req = ref<Website.WafReq>({
     websiteId: 0,
     key: '$CCDeny',
     rule: 'ccrate',
 });
-let enableUpdate = ref<WebSite.WafUpdate>({
+let enableUpdate = ref<Website.WafUpdate>({
     websiteId: 0,
     key: '$CCDeny',
     enable: false,
diff --git a/frontend/src/views/website/website/config/safety/file-block-list/index.vue b/frontend/src/views/website/website/config/safety/file-block-list/index.vue
index b44b289be..d763f5827 100644
--- a/frontend/src/views/website/website/config/safety/file-block-list/index.vue
+++ b/frontend/src/views/website/website/config/safety/file-block-list/index.vue
@@ -37,7 +37,7 @@
     </el-row>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetWafConfig, UpdateWafEnable } from '@/api/modules/website';
 import { computed, onMounted, reactive, ref } from 'vue';
 import ComplexTable from '@/components/complex-table/index.vue';
@@ -57,7 +57,7 @@ const id = computed(() => {
 
 let loading = ref(false);
 let data = ref([]);
-let req = ref<WebSite.WafReq>({
+let req = ref<Website.WafReq>({
     websiteId: 0,
     key: '$fileExtDeny',
     rule: 'fileExtBlockList',
@@ -66,7 +66,7 @@ let fileUpdate = reactive({
     path: '',
     content: '',
 });
-let enableUpdate = ref<WebSite.WafUpdate>({
+let enableUpdate = ref<Website.WafUpdate>({
     websiteId: 0,
     key: '$fileExtDeny',
     enable: false,
diff --git a/frontend/src/views/website/website/config/safety/ip-list/index.vue b/frontend/src/views/website/website/config/safety/ip-list/index.vue
index a15ac0098..a488a4b7b 100644
--- a/frontend/src/views/website/website/config/safety/ip-list/index.vue
+++ b/frontend/src/views/website/website/config/safety/ip-list/index.vue
@@ -37,7 +37,7 @@
     </el-row>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetWafConfig, UpdateWafEnable } from '@/api/modules/website';
 import { computed, onMounted, reactive, ref } from 'vue';
 import ComplexTable from '@/components/complex-table/index.vue';
@@ -72,7 +72,7 @@ const key = computed(() => {
 
 let loading = ref(false);
 let data = ref([]);
-let req = ref<WebSite.WafReq>({
+let req = ref<Website.WafReq>({
     websiteId: 0,
     key: '$ipWhiteAllow',
     rule: 'ipWhitelist',
@@ -81,7 +81,7 @@ let fileUpdate = reactive({
     path: '',
     content: '',
 });
-let enableUpdate = ref<WebSite.WafUpdate>({
+let enableUpdate = ref<Website.WafUpdate>({
     websiteId: 0,
     key: '$ipWhiteAllow',
     enable: false,
diff --git a/frontend/src/views/website/website/config/safety/value-list/index.vue b/frontend/src/views/website/website/config/safety/value-list/index.vue
index 0667eda3b..afd7c7ff3 100644
--- a/frontend/src/views/website/website/config/safety/value-list/index.vue
+++ b/frontend/src/views/website/website/config/safety/value-list/index.vue
@@ -42,7 +42,7 @@
     </el-row>
 </template>
 <script lang="ts" setup>
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetWafConfig, UpdateWafEnable } from '@/api/modules/website';
 import { computed, onMounted, reactive, ref } from 'vue';
 import ComplexTable from '@/components/complex-table/index.vue';
@@ -76,7 +76,7 @@ const key = computed(() => {
 
 let loading = ref(false);
 let data = ref([]);
-let req = ref<WebSite.WafReq>({
+let req = ref<Website.WafReq>({
     websiteId: 0,
     key: '',
     rule: 'url',
@@ -85,7 +85,7 @@ let fileUpdate = reactive({
     path: '',
     content: '',
 });
-let enableUpdate = ref<WebSite.WafUpdate>({
+let enableUpdate = ref<Website.WafUpdate>({
     websiteId: 0,
     key: '$UrlDeny',
     enable: false,
diff --git a/frontend/src/views/website/website/create/index.vue b/frontend/src/views/website/website/create/index.vue
index 1cdd24137..551258d8c 100644
--- a/frontend/src/views/website/website/create/index.vue
+++ b/frontend/src/views/website/website/create/index.vue
@@ -131,7 +131,7 @@
 
 <script lang="ts" setup name="CreateWebSite">
 import { App } from '@/api/interface/app';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 import { GetApp, GetAppDetail, SearchApp, GetAppInstalled } from '@/api/modules/app';
 import { CreateWebsite, ListGroups, PreCheck } from '@/api/modules/website';
 import { Rules } from '@/global/form-rules';
@@ -177,7 +177,7 @@ let rules = reactive({
 
 let open = ref(false);
 let loading = ref(false);
-let groups = ref<WebSite.Group[]>([]);
+let groups = ref<Website.Group[]>([]);
 let appInstalles = ref<App.AppInstalled[]>([]);
 let appReq = reactive({
     type: 'website',
diff --git a/frontend/src/views/website/website/delete/index.vue b/frontend/src/views/website/website/delete/index.vue
index c4929cb3c..4053775f2 100644
--- a/frontend/src/views/website/website/delete/index.vue
+++ b/frontend/src/views/website/website/delete/index.vue
@@ -27,7 +27,7 @@ import { DeleteWebsite } from '@/api/modules/website';
 import i18n from '@/lang';
 import { ElMessage } from 'element-plus';
 import { ref } from 'vue';
-import { WebSite } from '@/api/interface/website';
+import { Website } from '@/api/interface/website';
 
 let key = 1;
 let open = ref(false);
@@ -46,7 +46,7 @@ const handleClose = () => {
     em('close', false);
 };
 
-const acceptParams = async (website: WebSite.WebSite) => {
+const acceptParams = async (website: Website.Website) => {
     deleteReq.value = {
         id: 0,
         deleteApp: false,
diff --git a/frontend/src/views/website/website/index.vue b/frontend/src/views/website/website/index.vue
index 8a11bb1cf..d037566af 100644
--- a/frontend/src/views/website/website/index.vue
+++ b/frontend/src/views/website/website/index.vue
@@ -86,8 +86,8 @@ import { onMounted, reactive, ref } from '@vue/runtime-core';
 import CreateWebSite from './create/index.vue';
 import DeleteWebsite from './delete/index.vue';
 import WebSiteGroup from './group/index.vue';
-import { SearchWebSites } from '@/api/modules/website';
-import { WebSite } from '@/api/interface/website';
+import { SearchWebsites } from '@/api/modules/website';
+import { Website } from '@/api/interface/website';
 import AppStatus from '@/components/app-status/index.vue';
 import NginxConfig from './nginx/index.vue';
 import { dateFromat } from '@/utils/util';
@@ -121,7 +121,7 @@ const search = async () => {
         pageSize: paginationConfig.pageSize,
     };
 
-    SearchWebSites(req).then((res) => {
+    SearchWebsites(req).then((res) => {
         data.value = res.data.items;
         paginationConfig.total = res.data.total;
     });
@@ -140,13 +140,13 @@ const dialogBackupRef = ref();
 const buttons = [
     {
         label: i18n.global.t('website.config'),
-        click: function (row: WebSite.WebSite) {
+        click: function (row: Website.Website) {
             openConfig(row.id);
         },
     },
     {
         label: i18n.global.t('database.backupList'),
-        click: (row: WebSite.WebSite) => {
+        click: (row: Website.Website) => {
             let params = {
                 id: row.id,
                 type: row.type,
@@ -157,7 +157,7 @@ const buttons = [
     },
     {
         label: i18n.global.t('database.loadBackup'),
-        click: (row: WebSite.WebSite) => {
+        click: (row: Website.Website) => {
             let params = {
                 websiteName: row.primaryDomain,
                 websiteType: row.type,
@@ -167,13 +167,13 @@ const buttons = [
     },
     {
         label: i18n.global.t('app.delete'),
-        click: function (row: WebSite.WebSite) {
+        click: function (row: Website.Website) {
             openDelete(row);
         },
     },
 ];
 
-const openDelete = (website: WebSite.WebSite) => {
+const openDelete = (website: Website.Website) => {
     deleteRef.value.acceptParams(website);
 };