feat: 优化分页函数

app/http/controllers/plugins/fail2ban_controller.go

@@ -28,8 +28,6 @@ func NewFail2banController() *Fail2banController {
 
 // List 所有 Fail2ban 规则
 func (r *Fail2banController) List(ctx http.Context) http.Response {
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
 	raw, err := tools.Read("/etc/fail2ban/jail.local")
 	if err != nil {
 		return controllers.Error(ctx, http.StatusUnprocessableEntity, err.Error())
@@ -67,25 +65,11 @@ func (r *Fail2banController) List(ctx http.Context) http.Response {
 		})
 	}
 
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(jails) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.Fail2banJail{},
-		})
-	}
-	if endIndex > len(jails) {
-		endIndex = len(jails)
-	}
-	pagedJails := jails[startIndex:endIndex]
-	if pagedJails == nil {
-		pagedJails = []types.Fail2banJail{}
-	}
+	paged, total := controllers.Paginate(ctx, jails)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(jails),
-		"items": pagedJails,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/mysql_controller.go

@@ -187,21 +187,16 @@ func (r *MySQLController) SetRootPassword(ctx http.Context) http.Response {
 
 	oldRootPassword := r.setting.Get(models.SettingKeyMysqlRootPassword)
 	if oldRootPassword != rootPassword {
-		if _, err := tools.Exec("/www/server/mysql/bin/mysql -uroot -p" + oldRootPassword + " -e \"ALTER USER 'root'@'localhost' IDENTIFIED BY '" + rootPassword + "';\""); err != nil {
+		if _, err = tools.Exec(fmt.Sprintf(`/www/server/mysql/bin/mysql -uroot -p%s -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '%s';"`, oldRootPassword, rootPassword)); err != nil {
+			return controllers.Error(ctx, http.StatusInternalServerError, fmt.Sprintf("设置root密码失败: %v", err))
+		}
+		if _, err = tools.Exec(fmt.Sprintf(`/www/server/mysql/bin/mysql -uroot -p%s -e "FLUSH PRIVILEGES;"`, rootPassword)); err != nil {
 			return controllers.Error(ctx, http.StatusInternalServerError, "设置root密码失败")
 		}
-		if _, err := tools.Exec("/www/server/mysql/bin/mysql -uroot -p" + oldRootPassword + " -e \"FLUSH PRIVILEGES;\""); err != nil {
-			return controllers.Error(ctx, http.StatusInternalServerError, "设置root密码失败")
-		}
-		err := r.setting.Set(models.SettingKeyMysqlRootPassword, rootPassword)
-		if err != nil {
-			if _, err := tools.Exec("/www/server/mysql/bin/mysql -uroot -p" + rootPassword + " -e \"ALTER USER 'root'@'localhost' IDENTIFIED BY '" + oldRootPassword + "';\""); err != nil {
-				return nil
-			}
-			if _, err := tools.Exec("/www/server/mysql/bin/mysql -uroot -p" + rootPassword + " -e \"FLUSH PRIVILEGES;\""); err != nil {
-				return nil
-			}
-			return controllers.Error(ctx, http.StatusInternalServerError, "设置root密码失败")
+		if err = r.setting.Set(models.SettingKeyMysqlRootPassword, rootPassword); err != nil {
+			_, _ = tools.Exec(fmt.Sprintf(`/www/server/mysql/bin/mysql -uroot -p%s -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '%s';"`, rootPassword, oldRootPassword))
+			_, _ = tools.Exec(fmt.Sprintf(`/www/server/mysql/bin/mysql -uroot -p%s -e "FLUSH PRIVILEGES;"`, oldRootPassword))
+			return controllers.Error(ctx, http.StatusInternalServerError, fmt.Sprintf("设置保存失败: %v", err))
 		}
 	}
 
@@ -240,40 +235,22 @@ func (r *MySQLController) DatabaseList(ctx http.Context) http.Response {
 	var databases []database
 	for rows.Next() {
 		var d database
-		err := rows.Scan(&d.Name)
-		if err != nil {
+		if err = rows.Scan(&d.Name); err != nil {
 			continue
 		}
 
 		databases = append(databases, d)
 	}
 
-	if err := rows.Err(); err != nil {
+	if err = rows.Err(); err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, "获取数据库列表失败")
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(databases) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []database{},
-		})
-	}
-	if endIndex > len(databases) {
-		endIndex = len(databases)
-	}
-	pagedDatabases := databases[startIndex:endIndex]
-
-	if pagedDatabases == nil {
-		pagedDatabases = []database{}
-	}
+	paged, total := controllers.Paginate(ctx, databases)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(databases),
-		"items": pagedDatabases,
+		"total": total,
+		"items": paged,
 	})
 }
 
@@ -327,32 +304,16 @@ func (r *MySQLController) DeleteDatabase(ctx http.Context) http.Response {
 
 // BackupList 获取备份列表
 func (r *MySQLController) BackupList(ctx http.Context) http.Response {
-	backupList, err := r.backup.MysqlList()
+	backups, err := r.backup.MysqlList()
 	if err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, err.Error())
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(backupList) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.BackupFile{},
-		})
-	}
-	if endIndex > len(backupList) {
-		endIndex = len(backupList)
-	}
-	pagedBackupList := backupList[startIndex:endIndex]
-	if pagedBackupList == nil {
-		pagedBackupList = []types.BackupFile{}
-	}
+	paged, total := controllers.Paginate(ctx, backups)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(backupList),
-		"items": pagedBackupList,
+		"total": total,
+		"items": paged,
 	})
 }
 
@@ -463,8 +424,7 @@ func (r *MySQLController) UserList(ctx http.Context) http.Response {
 
 	for rows.Next() {
 		var u user
-		err := rows.Scan(&u.User, &u.Host)
-		if err != nil {
+		if err = rows.Scan(&u.User, &u.Host); err != nil {
 			continue
 		}
 
@@ -477,47 +437,29 @@ func (r *MySQLController) UserList(ctx http.Context) http.Response {
 
 		for grantsRows.Next() {
 			var grant string
-			err := grantsRows.Scan(&grant)
-			if err != nil {
+			if err = grantsRows.Scan(&grant); err != nil {
 				continue
 			}
 
 			u.Grants = append(u.Grants, grant)
 		}
 
-		if err := grantsRows.Err(); err != nil {
+		if err = grantsRows.Err(); err != nil {
 			continue
 		}
 
 		userGrants = append(userGrants, u)
 	}
 
-	if err := rows.Err(); err != nil {
+	if err = rows.Err(); err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, "获取用户列表失败")
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(userGrants) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []user{},
-		})
-	}
-	if endIndex > len(userGrants) {
-		endIndex = len(userGrants)
-	}
-	pagedUserGrants := userGrants[startIndex:endIndex]
-
-	if pagedUserGrants == nil {
-		pagedUserGrants = []user{}
-	}
+	paged, total := controllers.Paginate(ctx, userGrants)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(userGrants),
-		"items": pagedUserGrants,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/postgresql_controller.go

@@ -189,28 +189,11 @@ func (r *PostgreSQLController) DatabaseList(ctx http.Context) http.Response {
 		return controllers.Error(ctx, http.StatusInternalServerError, err.Error())
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(databases) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []database{},
-		})
-	}
-	if endIndex > len(databases) {
-		endIndex = len(databases)
-	}
-	pagedDatabases := databases[startIndex:endIndex]
-
-	if pagedDatabases == nil {
-		pagedDatabases = []database{}
-	}
+	paged, total := controllers.Paginate(ctx, databases)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(databases),
-		"items": pagedDatabases,
+		"total": total,
+		"items": paged,
 	})
 }
 
@@ -271,32 +254,16 @@ func (r *PostgreSQLController) DeleteDatabase(ctx http.Context) http.Response {
 
 // BackupList 获取备份列表
 func (r *PostgreSQLController) BackupList(ctx http.Context) http.Response {
-	backupList, err := r.backup.PostgresqlList()
+	backups, err := r.backup.PostgresqlList()
 	if err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, "获取备份列表失败")
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(backupList) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.BackupFile{},
-		})
-	}
-	if endIndex > len(backupList) {
-		endIndex = len(backupList)
-	}
-	pagedBackupList := backupList[startIndex:endIndex]
-	if pagedBackupList == nil {
-		pagedBackupList = []types.BackupFile{}
-	}
+	paged, total := controllers.Paginate(ctx, backups)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(backupList),
-		"items": pagedBackupList,
+		"total": total,
+		"items": paged,
 	})
 }
 
@@ -440,28 +407,11 @@ func (r *PostgreSQLController) RoleList(ctx http.Context) http.Response {
 		return controllers.Error(ctx, http.StatusInternalServerError, err.Error())
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(roles) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []role{},
-		})
-	}
-	if endIndex > len(roles) {
-		endIndex = len(roles)
-	}
-	pagedRoles := roles[startIndex:endIndex]
-
-	if pagedRoles == nil {
-		pagedRoles = []role{}
-	}
+	paged, total := controllers.Paginate(ctx, roles)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(roles),
-		"items": pagedRoles,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/pureftpd_controller.go

@@ -43,28 +43,11 @@ func (r *PureFtpdController) List(ctx http.Context) http.Response {
 		})
 	}
 
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(users) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.PureFtpdUser{},
-		})
-	}
-	if endIndex > len(users) {
-		endIndex = len(users)
-	}
-	pagedUsers := users[startIndex:endIndex]
-
-	if pagedUsers == nil {
-		pagedUsers = []types.PureFtpdUser{}
-	}
+	paged, total := controllers.Paginate(ctx, users)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(users),
-		"items": pagedUsers,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/rsync_controller.go

@@ -7,7 +7,6 @@ import (
 	"github.com/goravel/framework/contracts/http"
 
 	"github.com/TheTNB/panel/app/http/controllers"
-	commonrequests "github.com/TheTNB/panel/app/http/requests/common"
 	requests "github.com/TheTNB/panel/app/http/requests/plugins/rsync"
 	"github.com/TheTNB/panel/pkg/tools"
 	"github.com/TheTNB/panel/types"
@@ -31,12 +30,6 @@ func NewRsyncController() *RsyncController {
 //	@Success		200		{object}	controllers.SuccessResponse
 //	@Router			/plugins/rsync/modules [get]
 func (r *RsyncController) List(ctx http.Context) http.Response {
-	var paginateRequest commonrequests.Paginate
-	sanitize := controllers.SanitizeRequest(ctx, &paginateRequest)
-	if sanitize != nil {
-		return sanitize
-	}
-
 	config, err := tools.Read("/etc/rsyncd.conf")
 	if err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, err.Error())
@@ -91,25 +84,11 @@ func (r *RsyncController) List(ctx http.Context) http.Response {
 		modules = append(modules, *currentModule)
 	}
 
-	startIndex := (paginateRequest.Page - 1) * paginateRequest.Limit
-	endIndex := paginateRequest.Page * paginateRequest.Limit
-	if startIndex > len(modules) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.RsyncModule{},
-		})
-	}
-	if endIndex > len(modules) {
-		endIndex = len(modules)
-	}
-	pagedModules := modules[startIndex:endIndex]
-	if pagedModules == nil {
-		pagedModules = []types.RsyncModule{}
-	}
+	paged, total := controllers.Paginate(ctx, modules)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(modules),
-		"items": pagedModules,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/s3fs_controller.go

@@ -27,34 +27,17 @@ func NewS3fsController() *S3fsController {
 
 // List 所有 S3fs 挂载
 func (r *S3fsController) List(ctx http.Context) http.Response {
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-
 	var s3fsList []types.S3fsMount
 	err := json.UnmarshalString(r.setting.Get("s3fs", "[]"), &s3fsList)
 	if err != nil {
 		return controllers.Error(ctx, http.StatusInternalServerError, "获取 S3fs 挂载失败")
 	}
 
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(s3fsList) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []types.S3fsMount{},
-		})
-	}
-	if endIndex > len(s3fsList) {
-		endIndex = len(s3fsList)
-	}
-	pagedS3fsList := s3fsList[startIndex:endIndex]
-	if pagedS3fsList == nil {
-		pagedS3fsList = []types.S3fsMount{}
-	}
+	paged, total := controllers.Paginate(ctx, s3fsList)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(s3fsList),
-		"items": pagedS3fsList,
+		"total": total,
+		"items": paged,
 	})
 }
 

app/http/controllers/plugins/supervisor_controller.go

@@ -92,9 +92,6 @@ func (r *SupervisorController) SaveConfig(ctx http.Context) http.Response {
 
 // Processes 进程列表
 func (r *SupervisorController) Processes(ctx http.Context) http.Response {
-	page := ctx.Request().QueryInt("page", 1)
-	limit := ctx.Request().QueryInt("limit", 10)
-
 	type process struct {
 		Name   string `json:"name"`
 		Status string `json:"status"`
@@ -107,7 +104,7 @@ func (r *SupervisorController) Processes(ctx http.Context) http.Response {
 		return controllers.Error(ctx, http.StatusInternalServerError, out)
 	}
 
-	var processList []process
+	var processes []process
 	for _, line := range strings.Split(out, "\n") {
 		if len(line) == 0 {
 			continue
@@ -127,28 +124,14 @@ func (r *SupervisorController) Processes(ctx http.Context) http.Response {
 			p.Pid = "-"
 			p.Uptime = "-"
 		}
-		processList = append(processList, p)
+		processes = append(processes, p)
 	}
 
-	startIndex := (page - 1) * limit
-	endIndex := page * limit
-	if startIndex > len(processList) {
-		return controllers.Success(ctx, http.Json{
-			"total": 0,
-			"items": []process{},
-		})
-	}
-	if endIndex > len(processList) {
-		endIndex = len(processList)
-	}
-	pagedProcessList := processList[startIndex:endIndex]
-	if pagedProcessList == nil {
-		pagedProcessList = []process{}
-	}
+	paged, total := controllers.Paginate(ctx, processes)
 
 	return controllers.Success(ctx, http.Json{
-		"total": len(processList),
-		"items": pagedProcessList,
+		"total": total,
+		"items": paged,
 	})
 }