添加enable

convenient/data_containers/query_rule/query_rule.yaml

@@ -6,16 +6,18 @@ spec:
   spec:
     table_name: # 替换.query_rules
     columns:
+      - name: id
+        type: "varchar(32)"
+        comment: id
+        primary_key: true
       - name: scope
         type: varchar(256)
         comment: 范围
         not_null: true
-        primary_key: true
       - name: domain_name
         type: varchar(256)
         comment: 领域名
         not_null: true
-        primary_key: true
       - name: rule
         type: text
         comment: 规则

convenient/domain/query_rule/api.go

@@ -1,16 +1,18 @@
 package query_rule
 
 import (
-	"git.sxidc.com/go-framework/baize/convenient/value_object_crud"
+	"git.sxidc.com/go-framework/baize/convenient/entity_crud"
 	"git.sxidc.com/go-framework/baize/framework/binding"
 	"git.sxidc.com/go-framework/baize/framework/core/api"
 	"git.sxidc.com/go-framework/baize/framework/core/api/request"
 	"git.sxidc.com/go-framework/baize/framework/core/api/response"
 	"git.sxidc.com/go-framework/baize/framework/core/application"
 	"git.sxidc.com/go-framework/baize/framework/core/domain"
+	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/sql"
+	"git.sxidc.com/go-tools/utils/strutils"
 )
 
 // Simple Bind参数
@@ -20,45 +22,125 @@ type Simple struct {
 }
 
 func (simple *Simple) bind(binder *binding.Binder) {
-	queryRuleTableName := domain.TableName(simple.Schema, &ValueObject{})
-
-	value_object_crud.BindSimple(binder, &value_object_crud.Simple[any]{
-		ValueObject:    &ValueObject{},
-		Schema:         simple.Schema,
-		CreateJsonBody: &AddQueryRuleJsonBody{},
-		DeleteJsonBody: &RemoveQueryRuleJsonBody{},
-	}, value_object_crud.WithDisableQuery[any]())
+	queryRuleTableName := domain.TableName(simple.Schema, &Entity{})
 
 	binding.GetBind(binder, &binding.SimpleBindItem[map[string]any]{
 		Path:             "/queryRuleDefinition/get",
 		SendResponseFunc: response.SendMapResponse,
 		RequestParams:    &GetQueryRuleDefinitionQueryParams{},
-		Objects:          []domain.Object{&ValueObject{}},
+		Objects:          []domain.Object{&Entity{}},
 		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (map[string]any, error) {
 			errResponse := map[string]any{
 				"definition": make([]QueryRuleDefinitionItem, 0),
 			}
 
-			valueObject, err := domain.ToConcrete[*ValueObject](objects[0])
+			e, err := domain.ToConcrete[*Entity](objects[0])
 			if err != nil {
 				return errResponse, err
 			}
 
 			return map[string]any{
-				"definition": GetQueryRuleDefinition(valueObject.RuleDomainName),
+				"definition": GetQueryRuleDefinition(e.DomainName),
+			}, nil
+		},
+	})
+
+	entity_crud.BindSimple(binder,
+		&entity_crud.Simple[any]{
+			Entity:            &Entity{},
+			Schema:            simple.Schema,
+			CreateJsonBody:    &AddQueryRuleJsonBody{},
+			DeleteQueryParams: &RemoveQueryRuleQueryParams{},
+		},
+		entity_crud.WithDisableUpdate(),
+		entity_crud.WithDisableQuery[any](),
+		entity_crud.WithDisableGetByID[any](),
+		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
+			Prepare: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+				queryRuleEntity, err := domain.ToConcrete[*Entity](e)
+				if err != nil {
+					return nil, err
+				}
+
+				hasExistQueryRule, err := database.CheckExist(i.DBExecutor(), &sql.CheckExistExecuteParams{
+					TableName: domain.TableName(simple.Schema, &Entity{}),
+					Conditions: sql.NewConditions().
+						Equal(ColumnScope, queryRuleEntity.Scope).
+						Equal(ColumnScope, queryRuleEntity.DomainName),
+				})
+				if err != nil {
+					return nil, err
+				}
+
+				if hasExistQueryRule {
+					return nil, nil
+				}
+
+				queryRuleEntity.Enabled = true
+
+				return nil, nil
+			},
+		}))
+
+	binding.PostBind(binder, &binding.SimpleBindItem[response.InfosData[Info]]{
+		Path:             "/queryRule/query",
+		SendResponseFunc: response.SendInfosResponse[Info],
+		RequestParams:    &GetQueryRulesQueryParams{},
+		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[Info], error) {
+			errResponse := response.InfosData[Info]{
+				Infos: make([]Info, 0),
+			}
+
+			dbExecutor := i.DBExecutor()
+
+			jsonBody, err := request.ToConcrete[*GetQueryRulesQueryParams](params)
+			if err != nil {
+				return errResponse, err
+			}
+
+			conditions := sql.NewConditions()
+
+			if strutils.IsStringNotEmpty(jsonBody.Scope) {
+				conditions.Equal(ColumnScope, jsonBody.Scope)
+			}
+
+			if strutils.IsStringNotEmpty(jsonBody.DomainName) {
+				conditions.Equal(ColumnDomainName, jsonBody.DomainName)
+			}
+
+			results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
+				TableName:  queryRuleTableName,
+				Conditions: conditions,
+				OrderBy:    ColumnEnabled + " DESC",
+				PageNo:     jsonBody.PageNo,
+				PageSize:   jsonBody.PageSize,
+			})
+			if err != nil {
+				return errResponse, err
+			}
+
+			infos := make([]Info, 0)
+			err = sql.ParseSqlResult(results, &infos)
+			if err != nil {
+				return errResponse, err
+			}
+
+			return response.InfosData[Info]{
+				Infos:      infos,
+				TotalCount: totalCount,
+				PageNo:     jsonBody.PageNo,
 			}, nil
 		},
 	})
 
 	binding.PostBind(binder, &binding.SimpleBindItem[Info]{
-		Path:             "/queryRule/get",
+		Path:             "/queryRule/enabled/get",
 		SendResponseFunc: response.SendInfoResponse[Info],
-		RequestParams:    &GetQueryRuleQueryParams{},
-		Objects:          []domain.Object{&ValueObject{}},
+		RequestParams:    &GetEnabledQueryRuleQueryParams{},
 		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (Info, error) {
 			dbExecutor := i.DBExecutor()
 
-			valueObject, err := domain.ToConcrete[*ValueObject](objects[0])
+			jsonBody, err := request.ToConcrete[*GetEnabledQueryRuleQueryParams](params)
 			if err != nil {
 				return Info{}, err
 			}
@@ -66,8 +148,9 @@ func (simple *Simple) bind(binder *binding.Binder) {
 			result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
 				TableName: queryRuleTableName,
 				Conditions: sql.NewConditions().
-					Equal(ColumnScope, valueObject.Scope).
-					Equal(ColumnDomainName, valueObject.RuleDomainName),
+					Equal(ColumnScope, jsonBody.Scope).
+					Equal(ColumnDomainName, jsonBody.DomainName).
+					Equal(ColumnEnabled, true),
 			})
 			if err != nil {
 				return Info{}, err
@@ -82,6 +165,64 @@ func (simple *Simple) bind(binder *binding.Binder) {
 			return *info, nil
 		},
 	})
+
+	binding.PostBind(binder, &binding.SimpleBindItem[any]{
+		Path:             "/queryRule/enable",
+		SendResponseFunc: response.SendMsgResponse,
+		RequestParams:    &EnableQueryRuleJsonBody{},
+		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+			dbExecutor := i.DBExecutor()
+
+			e, err := domain.ToConcrete[*Entity](objects[0])
+			if err != nil {
+				return nil, err
+			}
+
+			existQueryRuleResult, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
+				TableName:  domain.TableName(simple.Schema, e),
+				Conditions: sql.NewConditions().Equal(entity.ColumnID, e.ID),
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			existQueryRuleEntity := new(Entity)
+			err = sql.ParseSqlResult(existQueryRuleResult, existQueryRuleEntity)
+			if err != nil {
+				return nil, err
+			}
+
+			err = database.Transaction(dbExecutor, func(tx database.Executor) error {
+				err := database.Update(tx, &sql.UpdateExecuteParams{
+					TableName: domain.TableName(simple.Schema, existQueryRuleEntity),
+					TableRow:  sql.NewTableRow().Add(ColumnEnabled, false),
+					Conditions: sql.NewConditions().
+						Equal(ColumnScope, existQueryRuleEntity.Scope).
+						Equal(ColumnDomainName, existQueryRuleEntity.DomainName),
+				})
+				if err != nil {
+					return err
+				}
+
+				err = database.Update(tx, &sql.UpdateExecuteParams{
+					TableName: domain.TableName(simple.Schema, existQueryRuleEntity),
+					TableRow:  sql.NewTableRow().Add(ColumnEnabled, true),
+					Conditions: sql.NewConditions().
+						Equal(entity.ColumnID, existQueryRuleEntity.ID),
+				})
+				if err != nil {
+					return err
+				}
+
+				return nil
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			return nil, nil
+		},
+	})
 }
 
 func Bind(app *application.App, simple *Simple) {

convenient/domain/query_rule/entity.go

@@ -0,0 +1,89 @@
+package query_rule
+
+import (
+	"git.sxidc.com/go-framework/baize/framework/core/domain"
+	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
+	"git.sxidc.com/go-framework/baize/framework/core/tag/check"
+)
+
+const (
+	FieldScope      = "Scope"
+	FieldDomainName = "DomainName"
+	FieldRule       = "Rule"
+	FieldEnabled    = "Enabled"
+)
+
+var (
+	ColumnScope      = domain.ColumnName(FieldScope)
+	ColumnDomainName = domain.ColumnName(FieldDomainName)
+	ColumnRule       = domain.ColumnName(FieldRule)
+	ColumnEnabled    = domain.ColumnName(FieldEnabled)
+)
+
+var fieldMap = map[string]string{
+	FieldScope:      "范围",
+	FieldDomainName: "领域名",
+	FieldRule:       "规则",
+}
+
+type Entity struct {
+	entity.Base
+	Scope      string `sqlmapping:"column:scope;key;notUpdate;" sqlresult:"column:scope;" check:"required,lte=256"`
+	DomainName string `sqlmapping:"column:domain_name;notUpdate;" sqlresult:"column:domain_name;" check:"required,lte=256"`
+	Rule       string `sqlmapping:"column:rule;notUpdate;" sqlresult:"column:rule;" check:"required"`
+	Enabled    bool   `sqlresult:"column:enabled;" sqlresult:"column:enabled;"`
+}
+
+func (e *Entity) DomainCNName() string {
+	return "查询规则"
+}
+
+func (e *Entity) DomainCamelName() string {
+	return "QueryRule"
+}
+
+func (e *Entity) ForCreate() error {
+	checkResult := check.Struct(e, fieldMap)
+
+	err := entity.CheckFieldIDResult(checkResult)
+	if err != nil {
+		return err
+	}
+
+	err = domain.CheckField(checkResult, e.DomainCNName(), FieldScope)
+	if err != nil {
+		return err
+	}
+
+	err = domain.CheckField(checkResult, e.DomainCNName(), FieldDomainName)
+	if err != nil {
+		return err
+	}
+
+	err = domain.CheckField(checkResult, e.DomainCNName(), FieldRule)
+	if err != nil {
+		return err
+	}
+
+	err = Lint(e.Rule)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (e *Entity) ForDelete() error {
+	checkResult := check.Struct(e, fieldMap)
+
+	err := entity.CheckFieldIDResult(checkResult)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (e *Entity) ForUpdate() error {
+	return nil
+}

convenient/domain/query_rule/info.go

@@ -1,7 +1,10 @@
 package query_rule
 
+import "git.sxidc.com/go-framework/baize/framework/core/application"
+
 type Info struct {
-	Scope          string `json:"scope" sqlresult:"column:scope"`
-	RuleDomainName string `json:"domainName" sqlresult:"column:domain_name"`
-	Rule           string `json:"rule" sqlresult:"column:rule"`
+	application.InfoIDField
+	Scope      string `json:"scope" sqlresult:"column:scope"`
+	DomainName string `json:"domainName" sqlresult:"column:domain_name"`
+	Rule       string `json:"rule" sqlresult:"column:rule"`
 }

convenient/domain/query_rule/query_rule_parser.go

@@ -117,7 +117,7 @@ func HasRule(dbSchema string, scope string, domainName string, i *infrastructure
 	dbExecutor := i.DBExecutor()
 
 	return database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-		TableName:  domain.TableName(dbSchema, &ValueObject{}),
+		TableName:  domain.TableName(dbSchema, &Entity{}),
 		Conditions: sql.NewConditions().Equal(ColumnScope, scope).Equal(ColumnDomainName, domainName),
 	})
 }
@@ -150,7 +150,7 @@ func getRule(dbSchema string, scope string, domainName string, i *infrastructure
 	dbExecutor := i.DBExecutor()
 
 	result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
-		TableName:  domain.TableName(dbSchema, &ValueObject{}),
+		TableName:  domain.TableName(dbSchema, &Entity{}),
 		Conditions: sql.NewConditions().Equal(ColumnScope, scope).Equal(ColumnDomainName, domainName),
 	})
 	if err != nil {

convenient/domain/query_rule/request_params.go

@@ -1,23 +1,35 @@
 package query_rule
 
+import "git.sxidc.com/go-framework/baize/framework/core/api/request"
+
 type (
+	GetQueryRuleDefinitionQueryParams struct {
+		DomainName string `form:"domainName" binding:"required" assign:"toField:DomainName"`
+	}
+
 	AddQueryRuleJsonBody struct {
 		Scope      string `json:"scope" binding:"required" assign:"toField:Scope"`
-		DomainName string `json:"domainName" binding:"required" assign:"toField:RuleDomainName"`
+		DomainName string `json:"domainName" binding:"required" assign:"toField:DomainName"`
 		Rule       string `json:"rule" binding:"required" assign:"toField:Rule"`
 	}
 
-	RemoveQueryRuleJsonBody struct {
-		Scope      string `json:"scope" binding:"required" assign:"toField:Scope"`
-		DomainName string `json:"domainName" binding:"required" assign:"toField:RuleDomainName"`
+	RemoveQueryRuleQueryParams struct {
+		request.IDQueryParam
+	}
+
+	GetQueryRulesQueryParams struct {
+		Scope      string `json:"scope" assign:"toField:Scope"`
+		DomainName string `json:"domainName" assign:"toField:DomainName"`
+		PageNo     int    `json:"pageNo"`
+		PageSize   int    `json:"pageSize"`
 	}
 
-	GetQueryRuleQueryParams struct {
+	GetEnabledQueryRuleQueryParams struct {
 		Scope      string `json:"scope" binding:"required" assign:"toField:Scope"`
-		DomainName string `json:"domainName" binding:"required" assign:"toField:RuleDomainName"`
+		DomainName string `json:"domainName" binding:"required" assign:"toField:DomainName"`
 	}
 
-	GetQueryRuleDefinitionQueryParams struct {
-		DomainName string `form:"domainName" binding:"required" assign:"toField:RuleDomainName"`
+	EnableQueryRuleJsonBody struct {
+		request.IDJsonBody
 	}
 )

convenient/domain/query_rule/value_object.go

@@ -1,82 +0,0 @@
-package query_rule
-
-import (
-	"git.sxidc.com/go-framework/baize/framework/core/domain"
-	"git.sxidc.com/go-framework/baize/framework/core/domain/value_object"
-	"git.sxidc.com/go-framework/baize/framework/core/tag/check"
-)
-
-const (
-	FieldScope      = "Scope"
-	FieldDomainName = "DomainName"
-	FieldRule       = "Rule"
-)
-
-var (
-	ColumnScope      = domain.ColumnName(FieldScope)
-	ColumnDomainName = "domain_name"
-	ColumnRule       = domain.ColumnName(FieldRule)
-)
-
-var fieldMap = map[string]string{
-	FieldScope:      "范围",
-	FieldDomainName: "领域名",
-	FieldRule:       "规则",
-}
-
-type ValueObject struct {
-	value_object.Base
-	Scope          string `sqlmapping:"column:scope;key;notUpdate;" sqlresult:"column:scope;" check:"required,lte=256"`
-	RuleDomainName string `sqlmapping:"column:domain_name;key;notUpdate;" sqlresult:"column:domain_name;" check:"required,lte=256"`
-	Rule           string `sqlmapping:"column:rule;notUpdate;" sqlresult:"column:rule;" check:"required"`
-}
-
-func (valueObject *ValueObject) DomainCNName() string {
-	return "查询规则"
-}
-
-func (valueObject *ValueObject) DomainCamelName() string {
-	return "QueryRule"
-}
-
-func (valueObject *ValueObject) CheckKeyFields() error {
-	checkResult := check.Struct(valueObject, fieldMap)
-
-	err := domain.CheckField(checkResult, valueObject.DomainCNName(), FieldScope)
-	if err != nil {
-		return err
-	}
-
-	err = domain.CheckField(checkResult, valueObject.DomainCNName(), FieldDomainName)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (valueObject *ValueObject) ForCreate() error {
-	checkResult := check.Struct(valueObject, fieldMap)
-
-	err := domain.CheckField(checkResult, valueObject.DomainCNName(), FieldScope)
-	if err != nil {
-		return err
-	}
-
-	err = domain.CheckField(checkResult, valueObject.DomainCNName(), FieldDomainName)
-	if err != nil {
-		return err
-	}
-
-	err = domain.CheckField(checkResult, valueObject.DomainCNName(), FieldRule)
-	if err != nil {
-		return err
-	}
-
-	err = Lint(valueObject.Rule)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}