From 87f462bc9467e76a5d5070234802d52032703910 Mon Sep 17 00:00:00 2001 From: zhanghan Date: Tue, 9 Sep 2025 16:25:32 +0800 Subject: [PATCH] List data supports pagination; Reference encapsulation response --- automation/server/go.mod | 2 +- .../controller/dangerous_rule.go | 49 ++++++++++++++----- .../dangerous_rule/dao/dangerous_rule.go | 23 +++++++-- .../internal/module/dangerous_rule/router.go | 3 +- .../dangerous_rule/service/dangerous_rule.go | 41 ++++++++++++++-- 5 files changed, 97 insertions(+), 21 deletions(-) diff --git a/automation/server/go.mod b/automation/server/go.mod index b7059690..30b36025 100644 --- a/automation/server/go.mod +++ b/automation/server/go.mod @@ -8,6 +8,7 @@ require ( gitee.com/openeuler/PilotGo/sdk v0.0.0-20250903062443-96565885a85b github.com/gin-gonic/gin v1.9.1 github.com/go-redis/redis/v8 v8.11.5 + github.com/go-sql-driver/mysql v1.8.1 github.com/spf13/cobra v1.10.1 go.etcd.io/etcd/client/v3 v3.6.4 gopkg.in/yaml.v2 v2.4.0 @@ -30,7 +31,6 @@ require ( github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.14.1 // indirect - github.com/go-sql-driver/mysql v1.8.1 // indirect github.com/goccy/go-json v0.10.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/protobuf v1.5.4 // indirect diff --git a/automation/server/internal/module/dangerous_rule/controller/dangerous_rule.go b/automation/server/internal/module/dangerous_rule/controller/dangerous_rule.go index 48514549..734cfbc8 100644 --- a/automation/server/internal/module/dangerous_rule/controller/dangerous_rule.go +++ b/automation/server/internal/module/dangerous_rule/controller/dangerous_rule.go @@ -1,6 +1,7 @@ package controller import ( + "gitee.com/openeuler/PilotGo/sdk/response" "github.com/gin-gonic/gin" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/module/dangerous_rule/model" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/module/dangerous_rule/service" @@ -9,36 +10,60 @@ import ( func AddDangerousRuleHandler(c *gin.Context) { var rule model.DangerousRule if err := c.ShouldBindJSON(&rule); err != nil { - c.JSON(400, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } if err := service.AddDangerousRule(&rule); err != nil { - c.JSON(500, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } - c.JSON(200, gin.H{"message": "success"}) + response.Success(c, nil, "success") } func GetDangerousRulesHandler(c *gin.Context) { - rules, err := service.GetDangerousRules() + query := &response.PaginationQ{} + if err := c.ShouldBindQuery(query); err != nil { + response.Fail(c, nil, err.Error()) + return + } + + rules, total, err := service.GetDangerousRules(query) if err != nil { - c.JSON(500, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } - c.JSON(200, gin.H{"data": rules}) + + response.DataPagination(c, rules, total, query) + } func UpdateDangerousRuleHandler(c *gin.Context) { var rule model.DangerousRule if err := c.ShouldBindJSON(&rule); err != nil { - c.JSON(400, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } if err := service.UpdateDangerousRule(&rule); err != nil { - c.JSON(500, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) + return + } + response.Success(c, nil, "success") +} +func ChangeDangerousRuleStatusHandler(c *gin.Context) { + var rule struct { + ID int `json:"id"` + Status bool `json:"status"` + } + if err := c.ShouldBindJSON(&rule); err != nil { + response.Fail(c, nil, err.Error()) + return + } + + if err := service.ChangeDangerousRuleStatus(rule.ID, rule.Status); err != nil { + response.Fail(c, nil, err.Error()) return } - c.JSON(200, gin.H{"message": "success"}) + response.Success(c, nil, "success") } func DeleteDangerousRuleHandler(c *gin.Context) { @@ -46,12 +71,12 @@ func DeleteDangerousRuleHandler(c *gin.Context) { ID []int `json:"id"` } if err := c.ShouldBindJSON(&ids); err != nil { - c.JSON(400, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } if err := service.DeleteDangerousRule(ids.ID); err != nil { - c.JSON(500, gin.H{"error": err.Error()}) + response.Fail(c, nil, err.Error()) return } - c.JSON(200, gin.H{"message": "success"}) + response.Success(c, nil, "success") } diff --git a/automation/server/internal/module/dangerous_rule/dao/dangerous_rule.go b/automation/server/internal/module/dangerous_rule/dao/dangerous_rule.go index 75eba32c..861fd83e 100644 --- a/automation/server/internal/module/dangerous_rule/dao/dangerous_rule.go +++ b/automation/server/internal/module/dangerous_rule/dao/dangerous_rule.go @@ -1,6 +1,7 @@ package dao import ( + "gitee.com/openeuler/PilotGo/sdk/response" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/global" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/module/dangerous_rule/model" ) @@ -9,16 +10,32 @@ func AddDangerousRule(rule *model.DangerousRule) error { return global.App.MySQL.Save(rule).Error } -func GetDangerousRules() ([]model.DangerousRule, error) { +func GetDangerousRules(query *response.PaginationQ) ([]model.DangerousRule, int, error) { var rules []model.DangerousRule - err := global.App.MySQL.Find(&rules).Error - return rules, err + var total int64 + + q := global.App.MySQL.Model(&model.DangerousRule{}).Limit(query.PageSize).Offset((query.Page - 1) * query.PageSize) + qc := global.App.MySQL.Model(&model.DangerousRule{}) + + if err := q.Order("id desc").Find(&rules).Error; err != nil { + return rules, 0, err + } + + if err := qc.Count(&total).Error; err != nil { + return nil, 0, err + } + + return rules, int(total), nil } func UpdateDangerousRule(rule *model.DangerousRule) error { return global.App.MySQL.Model(&model.DangerousRule{}).Where("id = ?", rule.ID).Updates(rule).Error } +func ChangeDangerousRuleStatus(id int, data interface{}) error { + return global.App.MySQL.Model(&model.DangerousRule{}).Where("id = ?", id).Updates(data).Error +} + func DeleteDangerousRule(id []int) error { return global.App.MySQL.Where("id IN ?", id).Delete(&model.DangerousRule{}).Unscoped().Error } diff --git a/automation/server/internal/module/dangerous_rule/router.go b/automation/server/internal/module/dangerous_rule/router.go index 8a8021b5..120ad2ac 100644 --- a/automation/server/internal/module/dangerous_rule/router.go +++ b/automation/server/internal/module/dangerous_rule/router.go @@ -9,8 +9,9 @@ func DangerousRuleHandler(router *gin.RouterGroup) { api := router.Group("/dangerousRule") { api.POST("/add", controller.AddDangerousRuleHandler) + api.GET("/list", controller.GetDangerousRulesHandler) api.PUT("/update", controller.UpdateDangerousRuleHandler) + api.PUT("/changeStatus", controller.ChangeDangerousRuleStatusHandler) api.DELETE("/delete", controller.DeleteDangerousRuleHandler) - api.GET("/list", controller.GetDangerousRulesHandler) } } diff --git a/automation/server/internal/module/dangerous_rule/service/dangerous_rule.go b/automation/server/internal/module/dangerous_rule/service/dangerous_rule.go index f67feef8..ec484be9 100644 --- a/automation/server/internal/module/dangerous_rule/service/dangerous_rule.go +++ b/automation/server/internal/module/dangerous_rule/service/dangerous_rule.go @@ -1,8 +1,11 @@ package service import ( + "fmt" "time" + "gitee.com/openeuler/PilotGo/sdk/response" + "github.com/go-sql-driver/mysql" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/module/dangerous_rule/dao" "openeuler.org/PilotGo/PilotGo-plugin-automation/internal/module/dangerous_rule/model" ) @@ -18,18 +21,48 @@ func AddDangerousRule(rule *model.DangerousRule) error { UpdatedAt: time.Now().Format("2006-01-02 15:04:05"), Status: rule.Status, }); err != nil { + if mysqlErr, ok := err.(*mysql.MySQLError); ok { + if mysqlErr.Number == 1062 { // ER_DUP_ENTRY + return fmt.Errorf("规则已存在: %s", rule.Expression) + } + } return err } return nil } -func GetDangerousRules() ([]model.DangerousRule, error) { - return dao.GetDangerousRules() +func GetDangerousRules(query *response.PaginationQ) ([]model.DangerousRule, int, error) { + return dao.GetDangerousRules(query) } func UpdateDangerousRule(rule *model.DangerousRule) error { - rule.UpdatedAt = time.Now().Format("2006-01-02 15:04:05") - return dao.UpdateDangerousRule(rule) + if err := dao.UpdateDangerousRule(&model.DangerousRule{ + ID: rule.ID, + Expression: rule.Expression, + Description: rule.Description, + ScriptTypes: rule.ScriptTypes, + Severity: rule.Severity, + UpdatedAt: time.Now().Format("2006-01-02 15:04:05"), + Status: rule.Status, + }); err != nil { + if mysqlErr, ok := err.(*mysql.MySQLError); ok { + if mysqlErr.Number == 1062 { // ER_DUP_ENTRY + return fmt.Errorf("规则已存在: %s", rule.Expression) + } + } + return err + } + return nil +} + +func ChangeDangerousRuleStatus(id int, status bool) error { + if id == 0 { + return fmt.Errorf("ID is required") + } + return dao.ChangeDangerousRuleStatus(id, map[string]interface{}{ + "updated_at": time.Now().Format("2006-01-02 15:04:05"), + "status": status, + }) } func DeleteDangerousRule(id []int) error { -- Gitee