正在显示
87 个修改的文件
包含
3372 行增加
和
26 行删除
1 | +version: v1 | ||
2 | +kind: HttpApi | ||
3 | +metadata: | ||
4 | + service: querySet | ||
5 | + path: /query-sets | ||
6 | + endpoints: | ||
7 | + - method: createQuerySet | ||
8 | + route: | ||
9 | + post: / | ||
10 | + - method: updateQuerySet | ||
11 | + route: | ||
12 | + put: /{Id} | ||
13 | + - method: getQuerySet | ||
14 | + route: | ||
15 | + get: /{Id} | ||
16 | + - method: removeQuerySet | ||
17 | + route: | ||
18 | + delete: /{Id} | ||
19 | + - method: listQuerySet | ||
20 | + route: | ||
21 | + get: / | ||
22 | + params: | ||
23 | + - name: offset | ||
24 | + - name: limit | ||
25 | + - method: changeStatus | ||
26 | + route: | ||
27 | + post: /change-status | ||
28 | + - method: copy | ||
29 | + route: | ||
30 | + post: /copy | ||
31 | + - method: dependencyGraph | ||
32 | + route: | ||
33 | + post: /dependency-ggraph | ||
34 | + - method: move | ||
35 | + route: | ||
36 | + post: /move | ||
37 | + - method: rename | ||
38 | + route: | ||
39 | + post: /rename | ||
40 | + - method: searchQuerySet | ||
41 | + route: | ||
42 | + post: /search |
1 | +version: v1 | ||
2 | +kind: Schema | ||
3 | +metadata: | ||
4 | + name: querySet | ||
5 | + description: 查询集合 | ||
6 | + attributes: | ||
7 | + - ref: querySetId | ||
8 | + required: true | ||
9 | + - ref: type | ||
10 | + required: true | ||
11 | + - ref: flag | ||
12 | + required: true | ||
13 | + - ref: name | ||
14 | + required: true | ||
15 | + - ref: pinName | ||
16 | + required: true | ||
17 | + - ref: parentId | ||
18 | + required: true | ||
19 | + - ref: status | ||
20 | + required: true | ||
21 | + - ref: querySetInfo | ||
22 | + required: true | ||
23 | + - ref: queryComponents | ||
24 | + required: true | ||
25 | + - ref: sort | ||
26 | + required: true | ||
27 | + - ref: createdAt | ||
28 | + required: true | ||
29 | + - ref: updatedAt | ||
30 | + required: true | ||
31 | + - ref: deletedAt | ||
32 | + required: true | ||
33 | + - ref: context | ||
34 | + required: true |
1 | +version: v1 | ||
2 | +kind: Method | ||
3 | +metadata: | ||
4 | + name: copy | ||
5 | + type: command | ||
6 | + description: 移动 | ||
7 | + payload: | ||
8 | + - ref: flag | ||
9 | + required: true | ||
10 | + - ref: parentId | ||
11 | + required: true | ||
12 | + - ref: name | ||
13 | + required: true | ||
14 | + - ref: querySetId | ||
15 | + required: true | ||
16 | + result: | ||
17 | + - name: querySet | ||
18 | + type: | ||
19 | + schema: querySet | ||
20 | + required: true |
1 | +version: v1 | ||
2 | +kind: Method | ||
3 | +metadata: | ||
4 | + name: createQuerySet | ||
5 | + type: command | ||
6 | + description: 创建查询集合服务 | ||
7 | + payload: | ||
8 | + - ref: type | ||
9 | + required: true | ||
10 | + - ref: flag | ||
11 | + required: true | ||
12 | + - ref: name | ||
13 | + required: true | ||
14 | + - ref: parentId | ||
15 | + required: false | ||
16 | + result: | ||
17 | + - name: querySet | ||
18 | + type: | ||
19 | + schema: querySet | ||
20 | + required: true |
1 | +version: v1 | ||
2 | +kind: Method | ||
3 | +metadata: | ||
4 | + name: listQuerySet | ||
5 | + type: query | ||
6 | + description: 返回查询集合服务列表 | ||
7 | + payload: | ||
8 | + - ref: offset | ||
9 | + required: true | ||
10 | + - ref: limit | ||
11 | + required: true | ||
12 | + result: | ||
13 | + - ref: count | ||
14 | + required: true | ||
15 | + - name: querySets | ||
16 | + type: | ||
17 | + array: querySet | ||
18 | + required: true |
1 | +version: v1 | ||
2 | +kind: Method | ||
3 | +metadata: | ||
4 | + name: searchQuerySet | ||
5 | + type: query | ||
6 | + description: 返回查询集合服务列表 | ||
7 | + payload: | ||
8 | + - ref: offset | ||
9 | + required: true | ||
10 | + - ref: limit | ||
11 | + required: true | ||
12 | + result: | ||
13 | + - ref: count | ||
14 | + required: true | ||
15 | + - name: querySets | ||
16 | + type: | ||
17 | + array: querySet | ||
18 | + required: true |
@@ -13,6 +13,7 @@ require ( | @@ -13,6 +13,7 @@ require ( | ||
13 | github.com/go-pg/pg/v10 v10.10.6 | 13 | github.com/go-pg/pg/v10 v10.10.6 |
14 | github.com/go-redis/redis v6.15.9+incompatible | 14 | github.com/go-redis/redis v6.15.9+incompatible |
15 | github.com/google/go-querystring v1.1.0 // indirect | 15 | github.com/google/go-querystring v1.1.0 // indirect |
16 | + github.com/google/gofuzz v1.2.0 | ||
16 | github.com/google/uuid v1.3.0 | 17 | github.com/google/uuid v1.3.0 |
17 | github.com/imkira/go-interpol v1.1.0 // indirect | 18 | github.com/imkira/go-interpol v1.1.0 // indirect |
18 | github.com/linmadan/egglib-go v0.0.0-20210313060205-8b5e456b11f7 | 19 | github.com/linmadan/egglib-go v0.0.0-20210313060205-8b5e456b11f7 |
@@ -2,7 +2,9 @@ package factory | @@ -2,7 +2,9 @@ package factory | ||
2 | 2 | ||
3 | import ( | 3 | import ( |
4 | "github.com/linmadan/egglib-go/core/application" | 4 | "github.com/linmadan/egglib-go/core/application" |
5 | + pgTransaction "github.com/linmadan/egglib-go/transaction/pg" | ||
5 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | 6 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" |
7 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/domainService" | ||
6 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/starrocks" | 8 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/starrocks" |
7 | ) | 9 | ) |
8 | 10 | ||
@@ -25,3 +27,7 @@ func FastDataTable(options starrocks.QueryOptions) (*domain.DataTable, error) { | @@ -25,3 +27,7 @@ func FastDataTable(options starrocks.QueryOptions) (*domain.DataTable, error) { | ||
25 | } | 27 | } |
26 | return dataTable, nil | 28 | return dataTable, nil |
27 | } | 29 | } |
30 | + | ||
31 | +func FastQuerySetServices(transactionContext application.TransactionContext) (*domainService.QuerySetService, error) { | ||
32 | + return domainService.NewQuerySetService(transactionContext.(*pgTransaction.TransactionContext)) | ||
33 | +} |
@@ -111,3 +111,29 @@ func FastPgMappingRule(transactionContext application.TransactionContext, id int | @@ -111,3 +111,29 @@ func FastPgMappingRule(transactionContext application.TransactionContext, id int | ||
111 | } | 111 | } |
112 | return rep, mod, err | 112 | return rep, mod, err |
113 | } | 113 | } |
114 | + | ||
115 | +// FastPgQuerySet 快速返回查询集合 | ||
116 | +// | ||
117 | +// transactionContext 事务 | ||
118 | +// id 对象唯一标识 | ||
119 | +func FastPgQuerySet(transactionContext application.TransactionContext, id int) (domain.QuerySetRepository, *domain.QuerySet, error) { | ||
120 | + var rep domain.QuerySetRepository | ||
121 | + var mod *domain.QuerySet | ||
122 | + var err error | ||
123 | + if value, err := CreateQuerySetRepository(map[string]interface{}{ | ||
124 | + "transactionContext": transactionContext, | ||
125 | + }); err != nil { | ||
126 | + return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) | ||
127 | + } else { | ||
128 | + rep = value | ||
129 | + } | ||
130 | + if id > 0 { | ||
131 | + if mod, err = rep.FindOne(map[string]interface{}{"querySetId": id}); err != nil { | ||
132 | + if err == domain.ErrorNotFound { | ||
133 | + return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该查询集合不存在") | ||
134 | + } | ||
135 | + return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
136 | + } | ||
137 | + } | ||
138 | + return rep, mod, err | ||
139 | +} |
@@ -37,3 +37,11 @@ func CreateMappingRuleRepository(options map[string]interface{}) (domain.Mapping | @@ -37,3 +37,11 @@ func CreateMappingRuleRepository(options map[string]interface{}) (domain.Mapping | ||
37 | } | 37 | } |
38 | return repository.NewMappingRuleRepository(transactionContext) | 38 | return repository.NewMappingRuleRepository(transactionContext) |
39 | } | 39 | } |
40 | + | ||
41 | +func CreateQuerySetRepository(options map[string]interface{}) (domain.QuerySetRepository, error) { | ||
42 | + var transactionContext *pg.TransactionContext | ||
43 | + if value, ok := options["transactionContext"]; ok { | ||
44 | + transactionContext = value.(*pg.TransactionContext) | ||
45 | + } | ||
46 | + return repository.NewQuerySetRepository(transactionContext) | ||
47 | +} |
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type ChangeStatusCommand struct { | ||
13 | + // 查询集合ID | ||
14 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
15 | + // 状态 1:启用 2:关闭 (子过程默认启用) | ||
16 | + Status int `cname:"状态 1:启用 2:关闭 (子过程默认启用)" json:"status" valid:"Required"` | ||
17 | +} | ||
18 | + | ||
19 | +func (changeStatusCommand *ChangeStatusCommand) Valid(validation *validation.Validation) { | ||
20 | + if !(changeStatusCommand.Status == domain.StatusOn || changeStatusCommand.Status == domain.StatusOff) { | ||
21 | + validation.Error("状态值有误") | ||
22 | + } | ||
23 | +} | ||
24 | + | ||
25 | +func (changeStatusCommand *ChangeStatusCommand) ValidateCommand() error { | ||
26 | + valid := validation.Validation{} | ||
27 | + b, err := valid.Valid(changeStatusCommand) | ||
28 | + if err != nil { | ||
29 | + return err | ||
30 | + } | ||
31 | + if !b { | ||
32 | + elem := reflect.TypeOf(changeStatusCommand).Elem() | ||
33 | + for _, validErr := range valid.Errors { | ||
34 | + field, isExist := elem.FieldByName(validErr.Field) | ||
35 | + if isExist { | ||
36 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
37 | + } else { | ||
38 | + return fmt.Errorf(validErr.Message) | ||
39 | + } | ||
40 | + } | ||
41 | + } | ||
42 | + return nil | ||
43 | +} |
pkg/application/querySet/command/copy.go
0 → 100644
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type CopyCommand struct { | ||
13 | + // Schema:方案 SubProcess:子过程 | ||
14 | + Type string `cname:"类型" json:"type" valid:"Required"` | ||
15 | + // 父级ID | ||
16 | + ParentId int `cname:"父级ID" json:"parentId" valid:"Required"` | ||
17 | + // 名称 | ||
18 | + Name string `cname:"名称" json:"name" valid:"Required"` | ||
19 | + // 查询集合ID | ||
20 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
21 | +} | ||
22 | + | ||
23 | +func (cmd *CopyCommand) Valid(validation *validation.Validation) { | ||
24 | + if err := domain.ValidQuerySetType(cmd.Type); err != nil { | ||
25 | + validation.Error(err.Error()) | ||
26 | + return | ||
27 | + } | ||
28 | +} | ||
29 | + | ||
30 | +func (cmd *CopyCommand) ValidateCommand() error { | ||
31 | + valid := validation.Validation{} | ||
32 | + b, err := valid.Valid(cmd) | ||
33 | + if err != nil { | ||
34 | + return err | ||
35 | + } | ||
36 | + if !b { | ||
37 | + elem := reflect.TypeOf(cmd).Elem() | ||
38 | + for _, validErr := range valid.Errors { | ||
39 | + field, isExist := elem.FieldByName(validErr.Field) | ||
40 | + if isExist { | ||
41 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
42 | + } else { | ||
43 | + return fmt.Errorf(validErr.Message) | ||
44 | + } | ||
45 | + } | ||
46 | + } | ||
47 | + return nil | ||
48 | +} |
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type CreateQuerySetCommand struct { | ||
13 | + // Schema:方案 SubProcess:子过程 | ||
14 | + Type string `cname:"类型" json:"type" valid:"Required"` | ||
15 | + // 标识 | ||
16 | + Flag string `cname:"标识" json:"flag" valid:"Required"` | ||
17 | + // 名称 | ||
18 | + Name string `cname:"名称" json:"name" valid:"Required"` | ||
19 | + // 父级ID | ||
20 | + ParentId int `cname:"父级ID" json:"parentId,omitempty"` | ||
21 | +} | ||
22 | + | ||
23 | +func (cmd *CreateQuerySetCommand) Valid(validation *validation.Validation) { | ||
24 | + if err := domain.ValidQuerySetType(cmd.Type); err != nil { | ||
25 | + validation.Error(err.Error()) | ||
26 | + return | ||
27 | + } | ||
28 | + if err := domain.ValidQuerySetFlag(cmd.Flag); err != nil { | ||
29 | + validation.Error(err.Error()) | ||
30 | + return | ||
31 | + } | ||
32 | +} | ||
33 | + | ||
34 | +func (cmd *CreateQuerySetCommand) ValidateCommand() error { | ||
35 | + valid := validation.Validation{} | ||
36 | + b, err := valid.Valid(cmd) | ||
37 | + if err != nil { | ||
38 | + return err | ||
39 | + } | ||
40 | + if !b { | ||
41 | + elem := reflect.TypeOf(cmd).Elem() | ||
42 | + for _, validErr := range valid.Errors { | ||
43 | + field, isExist := elem.FieldByName(validErr.Field) | ||
44 | + if isExist { | ||
45 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
46 | + } else { | ||
47 | + return fmt.Errorf(validErr.Message) | ||
48 | + } | ||
49 | + } | ||
50 | + } | ||
51 | + return nil | ||
52 | +} |
pkg/application/querySet/command/move.go
0 → 100644
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type MoveCommand struct { | ||
12 | + // 查询集合ID | ||
13 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
14 | + // 父级ID | ||
15 | + ParentId int `cname:"父级ID" json:"parentId" valid:"Required"` | ||
16 | + // 排序 | ||
17 | + Index int `cname:"序号" json:"index" valid:"Required"` | ||
18 | +} | ||
19 | + | ||
20 | +func (moveCommand *MoveCommand) Valid(validation *validation.Validation) { | ||
21 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
22 | +} | ||
23 | + | ||
24 | +func (moveCommand *MoveCommand) ValidateCommand() error { | ||
25 | + valid := validation.Validation{} | ||
26 | + b, err := valid.Valid(moveCommand) | ||
27 | + if err != nil { | ||
28 | + return err | ||
29 | + } | ||
30 | + if !b { | ||
31 | + elem := reflect.TypeOf(moveCommand).Elem() | ||
32 | + for _, validErr := range valid.Errors { | ||
33 | + field, isExist := elem.FieldByName(validErr.Field) | ||
34 | + if isExist { | ||
35 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
36 | + } else { | ||
37 | + return fmt.Errorf(validErr.Message) | ||
38 | + } | ||
39 | + } | ||
40 | + } | ||
41 | + return nil | ||
42 | +} |
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type RemoveQuerySetCommand struct { | ||
12 | + // 查询集合ID | ||
13 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
14 | +} | ||
15 | + | ||
16 | +func (removeQuerySetCommand *RemoveQuerySetCommand) Valid(validation *validation.Validation) { | ||
17 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
18 | +} | ||
19 | + | ||
20 | +func (removeQuerySetCommand *RemoveQuerySetCommand) ValidateCommand() error { | ||
21 | + valid := validation.Validation{} | ||
22 | + b, err := valid.Valid(removeQuerySetCommand) | ||
23 | + if err != nil { | ||
24 | + return err | ||
25 | + } | ||
26 | + if !b { | ||
27 | + elem := reflect.TypeOf(removeQuerySetCommand).Elem() | ||
28 | + for _, validErr := range valid.Errors { | ||
29 | + field, isExist := elem.FieldByName(validErr.Field) | ||
30 | + if isExist { | ||
31 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
32 | + } else { | ||
33 | + return fmt.Errorf(validErr.Message) | ||
34 | + } | ||
35 | + } | ||
36 | + } | ||
37 | + return nil | ||
38 | +} |
pkg/application/querySet/command/rename.go
0 → 100644
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type RenameCommand struct { | ||
12 | + // 查询集合ID | ||
13 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
14 | + // 名称 | ||
15 | + Name string `cname:"名称" json:"name" valid:"Required"` | ||
16 | +} | ||
17 | + | ||
18 | +func (renameCommand *RenameCommand) Valid(validation *validation.Validation) { | ||
19 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
20 | +} | ||
21 | + | ||
22 | +func (renameCommand *RenameCommand) ValidateCommand() error { | ||
23 | + valid := validation.Validation{} | ||
24 | + b, err := valid.Valid(renameCommand) | ||
25 | + if err != nil { | ||
26 | + return err | ||
27 | + } | ||
28 | + if !b { | ||
29 | + elem := reflect.TypeOf(renameCommand).Elem() | ||
30 | + for _, validErr := range valid.Errors { | ||
31 | + field, isExist := elem.FieldByName(validErr.Field) | ||
32 | + if isExist { | ||
33 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
34 | + } else { | ||
35 | + return fmt.Errorf(validErr.Message) | ||
36 | + } | ||
37 | + } | ||
38 | + } | ||
39 | + return nil | ||
40 | +} |
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type UpdateQuerySetCommand struct { | ||
13 | + // 查询集合ID | ||
14 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
15 | + QueryComponents []*domain.QueryComponent `cname:"查询组件" json:"queryComponents" valid:"Required"` | ||
16 | +} | ||
17 | + | ||
18 | +func (updateQuerySetCommand *UpdateQuerySetCommand) Valid(validation *validation.Validation) { | ||
19 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
20 | +} | ||
21 | + | ||
22 | +func (updateQuerySetCommand *UpdateQuerySetCommand) ValidateCommand() error { | ||
23 | + valid := validation.Validation{} | ||
24 | + b, err := valid.Valid(updateQuerySetCommand) | ||
25 | + if err != nil { | ||
26 | + return err | ||
27 | + } | ||
28 | + if !b { | ||
29 | + elem := reflect.TypeOf(updateQuerySetCommand).Elem() | ||
30 | + for _, validErr := range valid.Errors { | ||
31 | + field, isExist := elem.FieldByName(validErr.Field) | ||
32 | + if isExist { | ||
33 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
34 | + } else { | ||
35 | + return fmt.Errorf(validErr.Message) | ||
36 | + } | ||
37 | + } | ||
38 | + } | ||
39 | + return nil | ||
40 | +} |
1 | +package dto | ||
2 | + | ||
3 | +import "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
4 | + | ||
5 | +type QuerySetDetailDto struct { | ||
6 | + // 查询集合ID | ||
7 | + QuerySetId int `json:"querySetId"` | ||
8 | + // Schema:方案 SubProcess:子过程 | ||
9 | + Type string `json:"type"` | ||
10 | + // 标识 分组:Group 子过程/方案:Set | ||
11 | + Flag string `json:"flag"` | ||
12 | + // 名称 | ||
13 | + Name string `json:"name"` | ||
14 | + // 查询组件 | ||
15 | + QueryComponents []*domain.QueryComponent `json:"queryComponents"` | ||
16 | +} | ||
17 | + | ||
18 | +func (d *QuerySetDetailDto) Load(m *domain.QuerySet) *QuerySetDetailDto { | ||
19 | + d.QuerySetId = m.QuerySetId | ||
20 | + d.Type = m.Type | ||
21 | + d.Flag = m.Flag | ||
22 | + d.Name = m.Name | ||
23 | + d.QueryComponents = m.QueryComponents | ||
24 | + return d | ||
25 | +} |
1 | +package dto | ||
2 | + | ||
3 | +import "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
4 | + | ||
5 | +type QuerySetDto struct { | ||
6 | + // 查询集合ID | ||
7 | + QuerySetId int `json:"querySetId"` | ||
8 | + // Schema:方案 SubProcess:子过程 | ||
9 | + Type string `json:"type"` | ||
10 | + // 标识 分组:Group 子过程/方案:Set | ||
11 | + Flag string `json:"flag"` | ||
12 | + // 名称 | ||
13 | + Name string `json:"name"` | ||
14 | + // 父级ID | ||
15 | + ParentId int `json:"parentId"` | ||
16 | + // 状态 1:启用 2:关闭 (子过程默认启用) | ||
17 | + Status int `json:"status"` | ||
18 | + // 排序 | ||
19 | + Sort int `json:"sort"` | ||
20 | +} | ||
21 | + | ||
22 | +func (d *QuerySetDto) Load(m *domain.QuerySet) { | ||
23 | + d.QuerySetId = m.QuerySetId | ||
24 | + d.Type = m.Type | ||
25 | + d.Flag = m.Flag | ||
26 | + d.Name = m.Name | ||
27 | + d.ParentId = m.ParentId | ||
28 | + d.Status = m.Status | ||
29 | + d.Sort = m.Sort | ||
30 | +} |
1 | +package query | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type DependencyGraphQuery struct { | ||
12 | + // 查询集合ID | ||
13 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
14 | +} | ||
15 | + | ||
16 | +func (dependencyGraphQuery *DependencyGraphQuery) Valid(validation *validation.Validation) { | ||
17 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
18 | +} | ||
19 | + | ||
20 | +func (dependencyGraphQuery *DependencyGraphQuery) ValidateQuery() error { | ||
21 | + valid := validation.Validation{} | ||
22 | + b, err := valid.Valid(dependencyGraphQuery) | ||
23 | + if err != nil { | ||
24 | + return err | ||
25 | + } | ||
26 | + if !b { | ||
27 | + elem := reflect.TypeOf(dependencyGraphQuery).Elem() | ||
28 | + for _, validErr := range valid.Errors { | ||
29 | + field, isExist := elem.FieldByName(validErr.Field) | ||
30 | + if isExist { | ||
31 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
32 | + } else { | ||
33 | + return fmt.Errorf(validErr.Message) | ||
34 | + } | ||
35 | + } | ||
36 | + } | ||
37 | + return nil | ||
38 | +} |
1 | +package query | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type GetQuerySetQuery struct { | ||
12 | + // 查询集合ID | ||
13 | + QuerySetId int `cname:"查询集合ID" json:"querySetId" valid:"Required"` | ||
14 | +} | ||
15 | + | ||
16 | +func (getQuerySetQuery *GetQuerySetQuery) Valid(validation *validation.Validation) { | ||
17 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
18 | +} | ||
19 | + | ||
20 | +func (getQuerySetQuery *GetQuerySetQuery) ValidateQuery() error { | ||
21 | + valid := validation.Validation{} | ||
22 | + b, err := valid.Valid(getQuerySetQuery) | ||
23 | + if err != nil { | ||
24 | + return err | ||
25 | + } | ||
26 | + if !b { | ||
27 | + elem := reflect.TypeOf(getQuerySetQuery).Elem() | ||
28 | + for _, validErr := range valid.Errors { | ||
29 | + field, isExist := elem.FieldByName(validErr.Field) | ||
30 | + if isExist { | ||
31 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
32 | + } else { | ||
33 | + return fmt.Errorf(validErr.Message) | ||
34 | + } | ||
35 | + } | ||
36 | + } | ||
37 | + return nil | ||
38 | +} |
1 | +package query | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type ListQuerySetQuery struct { | ||
12 | + // 查询偏离量 | ||
13 | + Offset int `cname:"查询偏离量" json:"offset" valid:"Required"` | ||
14 | + // 查询限制 | ||
15 | + Limit int `cname:"查询限制" json:"limit" valid:"Required"` | ||
16 | +} | ||
17 | + | ||
18 | +func (listQuerySetQuery *ListQuerySetQuery) Valid(validation *validation.Validation) { | ||
19 | + //validation.SetError("CustomValid", "未实现的自定义认证") | ||
20 | +} | ||
21 | + | ||
22 | +func (listQuerySetQuery *ListQuerySetQuery) ValidateQuery() error { | ||
23 | + valid := validation.Validation{} | ||
24 | + b, err := valid.Valid(listQuerySetQuery) | ||
25 | + if err != nil { | ||
26 | + return err | ||
27 | + } | ||
28 | + if !b { | ||
29 | + elem := reflect.TypeOf(listQuerySetQuery).Elem() | ||
30 | + for _, validErr := range valid.Errors { | ||
31 | + field, isExist := elem.FieldByName(validErr.Field) | ||
32 | + if isExist { | ||
33 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
34 | + } else { | ||
35 | + return fmt.Errorf(validErr.Message) | ||
36 | + } | ||
37 | + } | ||
38 | + } | ||
39 | + return nil | ||
40 | +} |
1 | +package query | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "github.com/beego/beego/v2/adapter/utils" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type SearchQuerySetQuery struct { | ||
13 | + Type string `cname:"类型" json:"type" valid:"Required"` | ||
14 | + Flag string `cname:"标识" json:"flag"` | ||
15 | + MatchName string `cname:"匹配名称" json:"matchName"` | ||
16 | + SortByName string `json:"sortByName"` | ||
17 | + SortByTime string `json:"sortByTime"` | ||
18 | +} | ||
19 | + | ||
20 | +func (searchQuerySetQuery *SearchQuerySetQuery) Valid(validation *validation.Validation) { | ||
21 | + optionsValues := []string{"asc", "desc"} | ||
22 | + if searchQuerySetQuery.SortByName != "" && !utils.InSlice(strings.ToLower(searchQuerySetQuery.SortByName), optionsValues) { | ||
23 | + validation.Error("排序值有误 ASC|DESC") | ||
24 | + } | ||
25 | + if searchQuerySetQuery.SortByTime != "" && !utils.InSlice(strings.ToLower(searchQuerySetQuery.SortByTime), optionsValues) { | ||
26 | + validation.Error("排序值有误 ASC|DESC") | ||
27 | + } | ||
28 | +} | ||
29 | + | ||
30 | +func (searchQuerySetQuery *SearchQuerySetQuery) ValidateQuery() error { | ||
31 | + valid := validation.Validation{} | ||
32 | + b, err := valid.Valid(searchQuerySetQuery) | ||
33 | + if err != nil { | ||
34 | + return err | ||
35 | + } | ||
36 | + if !b { | ||
37 | + elem := reflect.TypeOf(searchQuerySetQuery).Elem() | ||
38 | + for _, validErr := range valid.Errors { | ||
39 | + field, isExist := elem.FieldByName(validErr.Field) | ||
40 | + if isExist { | ||
41 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
42 | + } else { | ||
43 | + return fmt.Errorf(validErr.Message) | ||
44 | + } | ||
45 | + } | ||
46 | + } | ||
47 | + return nil | ||
48 | +} |
1 | +package service | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/linmadan/egglib-go/core/application" | ||
5 | + "github.com/linmadan/egglib-go/utils/tool_funs" | ||
6 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/factory" | ||
7 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/command" | ||
8 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/dto" | ||
9 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/query" | ||
10 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
11 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils" | ||
12 | +) | ||
13 | + | ||
14 | +// 查询集合服务 | ||
15 | +type QuerySetService struct { | ||
16 | +} | ||
17 | + | ||
18 | +// 修改状态 | ||
19 | +func (querySetService *QuerySetService) ChangeStatus(ctx *domain.Context, changeStatusCommand *command.ChangeStatusCommand) (interface{}, error) { | ||
20 | + if err := changeStatusCommand.ValidateCommand(); err != nil { | ||
21 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
22 | + } | ||
23 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
24 | + if err != nil { | ||
25 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
26 | + } | ||
27 | + if err := transactionContext.StartTransaction(); err != nil { | ||
28 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
29 | + } | ||
30 | + defer func() { | ||
31 | + transactionContext.RollbackTransaction() | ||
32 | + }() | ||
33 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
34 | + if err := svr.ChangeStatus(ctx, changeStatusCommand.QuerySetId, changeStatusCommand.Status); err != nil { | ||
35 | + return nil, factory.FastError(err) | ||
36 | + } | ||
37 | + | ||
38 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
39 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
40 | + } | ||
41 | + return struct{}{}, nil | ||
42 | +} | ||
43 | + | ||
44 | +// 移动 | ||
45 | +func (querySetService *QuerySetService) Copy(ctx *domain.Context, copyCommand *command.CopyCommand) (interface{}, error) { | ||
46 | + if err := copyCommand.ValidateCommand(); err != nil { | ||
47 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
48 | + } | ||
49 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
50 | + if err != nil { | ||
51 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
52 | + } | ||
53 | + if err := transactionContext.StartTransaction(); err != nil { | ||
54 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
55 | + } | ||
56 | + defer func() { | ||
57 | + transactionContext.RollbackTransaction() | ||
58 | + }() | ||
59 | + | ||
60 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
61 | + if err := svr.Copy(ctx, copyCommand.QuerySetId, copyCommand.Type, copyCommand.ParentId, copyCommand.Name); err != nil { | ||
62 | + return nil, factory.FastError(err) | ||
63 | + } | ||
64 | + | ||
65 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
66 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
67 | + } | ||
68 | + return struct{}{}, nil | ||
69 | +} | ||
70 | + | ||
71 | +// 创建查询集合服务 | ||
72 | +func (querySetService *QuerySetService) CreateQuerySet(ctx *domain.Context, createQuerySetCommand *command.CreateQuerySetCommand) (interface{}, error) { | ||
73 | + if err := createQuerySetCommand.ValidateCommand(); err != nil { | ||
74 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
75 | + } | ||
76 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
77 | + if err != nil { | ||
78 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
79 | + } | ||
80 | + if err := transactionContext.StartTransaction(); err != nil { | ||
81 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
82 | + } | ||
83 | + defer func() { | ||
84 | + transactionContext.RollbackTransaction() | ||
85 | + }() | ||
86 | + newQuerySet := &domain.QuerySet{ | ||
87 | + Type: createQuerySetCommand.Type, | ||
88 | + Flag: createQuerySetCommand.Flag, | ||
89 | + Name: createQuerySetCommand.Name, | ||
90 | + ParentId: createQuerySetCommand.ParentId, | ||
91 | + } | ||
92 | + | ||
93 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
94 | + if err := svr.Create(ctx, newQuerySet); err != nil { | ||
95 | + return nil, factory.FastError(err) | ||
96 | + } | ||
97 | + | ||
98 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
99 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
100 | + } | ||
101 | + return struct{}{}, nil | ||
102 | +} | ||
103 | + | ||
104 | +// 依赖关系图 | ||
105 | +func (querySetService *QuerySetService) DependencyGraph(ctx *domain.Context, dependencyGraphQuery *query.DependencyGraphQuery) (interface{}, error) { | ||
106 | + if err := dependencyGraphQuery.ValidateQuery(); err != nil { | ||
107 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
108 | + } | ||
109 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
110 | + if err != nil { | ||
111 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
112 | + } | ||
113 | + if err := transactionContext.StartTransaction(); err != nil { | ||
114 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
115 | + } | ||
116 | + defer func() { | ||
117 | + transactionContext.RollbackTransaction() | ||
118 | + }() | ||
119 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
120 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
121 | + } | ||
122 | + return nil, nil | ||
123 | +} | ||
124 | + | ||
125 | +// 返回查询集合服务 | ||
126 | +func (querySetService *QuerySetService) GetQuerySet(ctx *domain.Context, getQuerySetQuery *query.GetQuerySetQuery) (interface{}, error) { | ||
127 | + if err := getQuerySetQuery.ValidateQuery(); err != nil { | ||
128 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
129 | + } | ||
130 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
131 | + if err != nil { | ||
132 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
133 | + } | ||
134 | + if err := transactionContext.StartTransaction(); err != nil { | ||
135 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
136 | + } | ||
137 | + defer func() { | ||
138 | + transactionContext.RollbackTransaction() | ||
139 | + }() | ||
140 | + _, querySet, err := factory.FastPgQuerySet(transactionContext, getQuerySetQuery.QuerySetId) | ||
141 | + if err != nil { | ||
142 | + return nil, factory.FastError(err) | ||
143 | + } | ||
144 | + return (&dto.QuerySetDetailDto{}).Load(querySet), nil | ||
145 | +} | ||
146 | + | ||
147 | +// 返回查询集合服务列表 | ||
148 | +func (querySetService *QuerySetService) ListQuerySet(ctx *domain.Context, listQuerySetQuery *query.ListQuerySetQuery) (interface{}, error) { | ||
149 | + if err := listQuerySetQuery.ValidateQuery(); err != nil { | ||
150 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
151 | + } | ||
152 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
153 | + if err != nil { | ||
154 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
155 | + } | ||
156 | + if err := transactionContext.StartTransaction(); err != nil { | ||
157 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
158 | + } | ||
159 | + defer func() { | ||
160 | + transactionContext.RollbackTransaction() | ||
161 | + }() | ||
162 | + var querySetRepository domain.QuerySetRepository | ||
163 | + if value, err := factory.CreateQuerySetRepository(map[string]interface{}{ | ||
164 | + "transactionContext": transactionContext, | ||
165 | + }); err != nil { | ||
166 | + return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) | ||
167 | + } else { | ||
168 | + querySetRepository = value | ||
169 | + } | ||
170 | + if count, querySets, err := querySetRepository.Find(tool_funs.SimpleStructToMap(listQuerySetQuery)); err != nil { | ||
171 | + return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) | ||
172 | + } else { | ||
173 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
174 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
175 | + } | ||
176 | + return map[string]interface{}{ | ||
177 | + "count": count, | ||
178 | + "querySets": querySets, | ||
179 | + }, nil | ||
180 | + } | ||
181 | +} | ||
182 | + | ||
183 | +// 移动 | ||
184 | +func (querySetService *QuerySetService) Move(ctx *domain.Context, moveCommand *command.MoveCommand) (interface{}, error) { | ||
185 | + if err := moveCommand.ValidateCommand(); err != nil { | ||
186 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
187 | + } | ||
188 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
189 | + if err != nil { | ||
190 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
191 | + } | ||
192 | + if err := transactionContext.StartTransaction(); err != nil { | ||
193 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
194 | + } | ||
195 | + defer func() { | ||
196 | + transactionContext.RollbackTransaction() | ||
197 | + }() | ||
198 | + | ||
199 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
200 | + if err := svr.Move(ctx, moveCommand.QuerySetId, moveCommand.ParentId, moveCommand.Index); err != nil { | ||
201 | + return nil, factory.FastError(err) | ||
202 | + } | ||
203 | + | ||
204 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
205 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
206 | + } | ||
207 | + return struct{}{}, nil | ||
208 | +} | ||
209 | + | ||
210 | +// 移除查询集合服务 | ||
211 | +func (querySetService *QuerySetService) RemoveQuerySet(ctx *domain.Context, removeQuerySetCommand *command.RemoveQuerySetCommand) (interface{}, error) { | ||
212 | + if err := removeQuerySetCommand.ValidateCommand(); err != nil { | ||
213 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
214 | + } | ||
215 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
216 | + if err != nil { | ||
217 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
218 | + } | ||
219 | + if err := transactionContext.StartTransaction(); err != nil { | ||
220 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
221 | + } | ||
222 | + defer func() { | ||
223 | + transactionContext.RollbackTransaction() | ||
224 | + }() | ||
225 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
226 | + if err := svr.Delete(ctx, removeQuerySetCommand.QuerySetId); err != nil { | ||
227 | + return nil, factory.FastError(err) | ||
228 | + } | ||
229 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
230 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
231 | + } | ||
232 | + return struct{}{}, nil | ||
233 | +} | ||
234 | + | ||
235 | +// 重命名 | ||
236 | +func (querySetService *QuerySetService) Rename(ctx *domain.Context, renameCommand *command.RenameCommand) (interface{}, error) { | ||
237 | + if err := renameCommand.ValidateCommand(); err != nil { | ||
238 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
239 | + } | ||
240 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
241 | + if err != nil { | ||
242 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
243 | + } | ||
244 | + if err := transactionContext.StartTransaction(); err != nil { | ||
245 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
246 | + } | ||
247 | + defer func() { | ||
248 | + transactionContext.RollbackTransaction() | ||
249 | + }() | ||
250 | + | ||
251 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
252 | + if err := svr.Rename(ctx, renameCommand.QuerySetId, renameCommand.Name); err != nil { | ||
253 | + return nil, factory.FastError(err) | ||
254 | + } | ||
255 | + | ||
256 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
257 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
258 | + } | ||
259 | + return struct{}{}, nil | ||
260 | +} | ||
261 | + | ||
262 | +// 返回查询集合服务列表 | ||
263 | +func (querySetService *QuerySetService) SearchQuerySet(ctx *domain.Context, searchQuerySetQuery *query.SearchQuerySetQuery) (interface{}, error) { | ||
264 | + if err := searchQuerySetQuery.ValidateQuery(); err != nil { | ||
265 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
266 | + } | ||
267 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
268 | + if err != nil { | ||
269 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
270 | + } | ||
271 | + if err := transactionContext.StartTransaction(); err != nil { | ||
272 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
273 | + } | ||
274 | + defer func() { | ||
275 | + transactionContext.RollbackTransaction() | ||
276 | + }() | ||
277 | + | ||
278 | + QuerySetRepository, _, _ := factory.FastPgQuerySet(transactionContext, 0) | ||
279 | + options := utils.ObjectToMap(searchQuerySetQuery) | ||
280 | + options["context"] = ctx | ||
281 | + count, querySets, err := QuerySetRepository.Find(options) | ||
282 | + if err != nil { | ||
283 | + return nil, factory.FastError(err) | ||
284 | + } | ||
285 | + | ||
286 | + var result = make([]*dto.QuerySetDto, 0) | ||
287 | + for _, set := range querySets { | ||
288 | + var item = &dto.QuerySetDto{} | ||
289 | + item.Load(set) | ||
290 | + result = append(result, item) | ||
291 | + } | ||
292 | + | ||
293 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
294 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
295 | + } | ||
296 | + return map[string]interface{}{ | ||
297 | + "count": count, | ||
298 | + "querySets": result, | ||
299 | + }, nil | ||
300 | +} | ||
301 | + | ||
302 | +// 更新查询集合服务 | ||
303 | +func (querySetService *QuerySetService) UpdateQuerySet(ctx *domain.Context, updateQuerySetCommand *command.UpdateQuerySetCommand) (interface{}, error) { | ||
304 | + if err := updateQuerySetCommand.ValidateCommand(); err != nil { | ||
305 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
306 | + } | ||
307 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
308 | + if err != nil { | ||
309 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
310 | + } | ||
311 | + if err := transactionContext.StartTransaction(); err != nil { | ||
312 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
313 | + } | ||
314 | + defer func() { | ||
315 | + transactionContext.RollbackTransaction() | ||
316 | + }() | ||
317 | + svr, _ := factory.FastQuerySetServices(transactionContext) | ||
318 | + if err := svr.Update(ctx, updateQuerySetCommand.QuerySetId, updateQuerySetCommand.QueryComponents); err != nil { | ||
319 | + return nil, factory.FastError(err) | ||
320 | + } | ||
321 | + | ||
322 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
323 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
324 | + } | ||
325 | + return struct{}{}, nil | ||
326 | +} | ||
327 | + | ||
328 | +func NewQuerySetService(options map[string]interface{}) *QuerySetService { | ||
329 | + newQuerySetService := &QuerySetService{} | ||
330 | + return newQuerySetService | ||
331 | +} |
pkg/application/table/command/apply_on.go
0 → 100644
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "reflect" | ||
6 | + "strings" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/core/validation" | ||
9 | +) | ||
10 | + | ||
11 | +type ApplyOnCommand struct { | ||
12 | + // 表Id | ||
13 | + TableId int `cname:"表Id" json:"tableId" valid:"Required"` | ||
14 | + // 模块 | ||
15 | + Module int `json:"module"` | ||
16 | +} | ||
17 | + | ||
18 | +func (c *ApplyOnCommand) Valid(validation *validation.Validation) { | ||
19 | + | ||
20 | +} | ||
21 | + | ||
22 | +func (c *ApplyOnCommand) ValidateCommand() error { | ||
23 | + valid := validation.Validation{} | ||
24 | + b, err := valid.Valid(c) | ||
25 | + if err != nil { | ||
26 | + return err | ||
27 | + } | ||
28 | + if !b { | ||
29 | + elem := reflect.TypeOf(c).Elem() | ||
30 | + for _, validErr := range valid.Errors { | ||
31 | + field, isExist := elem.FieldByName(validErr.Field) | ||
32 | + if isExist { | ||
33 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
34 | + } else { | ||
35 | + return fmt.Errorf(validErr.Message) | ||
36 | + } | ||
37 | + } | ||
38 | + } | ||
39 | + return nil | ||
40 | +} |
1 | +package command | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
6 | + "reflect" | ||
7 | + "strings" | ||
8 | + | ||
9 | + "github.com/beego/beego/v2/core/validation" | ||
10 | +) | ||
11 | + | ||
12 | +type ValidExprSqlCommand struct { | ||
13 | + domain.FieldExpr | ||
14 | +} | ||
15 | + | ||
16 | +func (c *ValidExprSqlCommand) Valid(validation *validation.Validation) { | ||
17 | + | ||
18 | +} | ||
19 | + | ||
20 | +func (c *ValidExprSqlCommand) ValidateCommand() error { | ||
21 | + valid := validation.Validation{} | ||
22 | + b, err := valid.Valid(c) | ||
23 | + if err != nil { | ||
24 | + return err | ||
25 | + } | ||
26 | + if !b { | ||
27 | + elem := reflect.TypeOf(c).Elem() | ||
28 | + for _, validErr := range valid.Errors { | ||
29 | + field, isExist := elem.FieldByName(validErr.Field) | ||
30 | + if isExist { | ||
31 | + return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1)) | ||
32 | + } else { | ||
33 | + return fmt.Errorf(validErr.Message) | ||
34 | + } | ||
35 | + } | ||
36 | + } | ||
37 | + return nil | ||
38 | +} |
@@ -17,6 +17,8 @@ type TableDetailDto struct { | @@ -17,6 +17,8 @@ type TableDetailDto struct { | ||
17 | ManualFields []*domain.Field `json:"manualFields"` | 17 | ManualFields []*domain.Field `json:"manualFields"` |
18 | // 数据列 | 18 | // 数据列 |
19 | Fields []*domain.Field `json:"fields"` | 19 | Fields []*domain.Field `json:"fields"` |
20 | + // 模块 应用于模块 1:数控中心 2:拆解模块 4:计算模块 | ||
21 | + Module int `json:"module"` | ||
20 | } | 22 | } |
21 | 23 | ||
22 | func (d *TableDetailDto) Load(table *domain.Table, mainTable *domain.Table) { | 24 | func (d *TableDetailDto) Load(table *domain.Table, mainTable *domain.Table) { |
@@ -34,4 +36,7 @@ func (d *TableDetailDto) Load(table *domain.Table, mainTable *domain.Table) { | @@ -34,4 +36,7 @@ func (d *TableDetailDto) Load(table *domain.Table, mainTable *domain.Table) { | ||
34 | if len(d.ManualFields) == 0 { | 36 | if len(d.ManualFields) == 0 { |
35 | d.ManualFields = make([]*domain.Field, 0) | 37 | d.ManualFields = make([]*domain.Field, 0) |
36 | } | 38 | } |
39 | + if table.TableInfo != nil { | ||
40 | + d.Module = table.TableInfo.ApplyOnModule | ||
41 | + } | ||
37 | } | 42 | } |
@@ -13,15 +13,34 @@ type TableDto struct { | @@ -13,15 +13,34 @@ type TableDto struct { | ||
13 | TableType string `json:"tableType"` | 13 | TableType string `json:"tableType"` |
14 | // 名称 | 14 | // 名称 |
15 | Name string `json:"name"` | 15 | Name string `json:"name"` |
16 | + // 对应数据库名称 | ||
17 | + SQLName string `json:"sqlName,omitempty"` | ||
16 | // 父级ID | 18 | // 父级ID |
17 | ParentId int `json:"parentId"` | 19 | ParentId int `json:"parentId"` |
20 | + // 模块 应用于模块 1:数控中心 2:拆解模块 4:计算模块 | ||
21 | + Module int `json:"module"` | ||
22 | + // 表字段 | ||
23 | + Fields []*domain.Field `json:"fields"` | ||
18 | } | 24 | } |
19 | 25 | ||
20 | -func (d *TableDto) Load(m *domain.Table) { | 26 | +func (d *TableDto) Load(m *domain.Table) *TableDto { |
21 | d.TableId = m.TableId | 27 | d.TableId = m.TableId |
22 | d.TableType = m.TableType | 28 | d.TableType = m.TableType |
23 | d.Name = m.Name | 29 | d.Name = m.Name |
24 | d.ParentId = m.ParentId | 30 | d.ParentId = m.ParentId |
31 | + if m.TableInfo != nil { | ||
32 | + d.Module = m.TableInfo.ApplyOnModule | ||
33 | + } | ||
34 | + d.Fields = make([]*domain.Field, 0) | ||
35 | + return d | ||
36 | +} | ||
37 | + | ||
38 | +func (d *TableDto) SetDetailStructInfo(m *domain.Table) *TableDto { | ||
39 | + d.Fields = append(d.Fields, m.DataFields...) | ||
40 | + d.Fields = append(d.Fields, m.ManualFields...) | ||
41 | + | ||
42 | + d.SQLName = m.SQLName | ||
43 | + return d | ||
25 | } | 44 | } |
26 | 45 | ||
27 | func SuitTableByView(tables []*TableDto, view string, name string) []*TableDto { | 46 | func SuitTableByView(tables []*TableDto, view string, name string) []*TableDto { |
@@ -11,17 +11,18 @@ import ( | @@ -11,17 +11,18 @@ import ( | ||
11 | 11 | ||
12 | type SearchTableQuery struct { | 12 | type SearchTableQuery struct { |
13 | // 表名称 | 13 | // 表名称 |
14 | - Name string `cname:"表名称" json:"name"` | 14 | + Name string `cname:"表名称" json:"name"` |
15 | ViewType string `cname:"视图类型 full:完整 main:主表关系" json:"viewType"` | 15 | ViewType string `cname:"视图类型 full:完整 main:主表关系" json:"viewType"` |
16 | - // 表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表 | 16 | + // 表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表 SubProcess:子过程 Schema:方案 |
17 | TableTypes []string `cname:"表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表" json:"tableTypes"` | 17 | TableTypes []string `cname:"表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表" json:"tableTypes"` |
18 | // 父级ID | 18 | // 父级ID |
19 | ParentId int `cname:"父级ID" json:"parentId"` | 19 | ParentId int `cname:"父级ID" json:"parentId"` |
20 | - | 20 | + // 模块 应用于模块 1:数控中心 2:拆解模块 4:计算模块 |
21 | + Module int `json:"module"` | ||
21 | // 父级ID | 22 | // 父级ID |
22 | - ParentTableId int `cname:"父级ID" json:"parentTableId"` | ||
23 | - | ||
24 | - Context *domain.Context | 23 | + ParentTableId int `cname:"父级ID" json:"parentTableId"` |
24 | + ReturnDetailStructInfo bool `cname:"返回具体的结构信息 默认不返回" json:"ReturnDetailStructInfo"` | ||
25 | + Context *domain.Context | ||
25 | } | 26 | } |
26 | 27 | ||
27 | func (searchQuery *SearchTableQuery) Valid(validation *validation.Validation) { | 28 | func (searchQuery *SearchTableQuery) Valid(validation *validation.Validation) { |
@@ -34,6 +34,7 @@ func (tableService *TableService) DBTablePreview(ctx *domain.Context, cmd *comma | @@ -34,6 +34,7 @@ func (tableService *TableService) DBTablePreview(ctx *domain.Context, cmd *comma | ||
34 | } | 34 | } |
35 | 35 | ||
36 | var options = starrocks.QueryOptions{ | 36 | var options = starrocks.QueryOptions{ |
37 | + Table: table, | ||
37 | TableName: table.SQLName, | 38 | TableName: table.SQLName, |
38 | Select: table.Fields(true), | 39 | Select: table.Fields(true), |
39 | Context: ctx, | 40 | Context: ctx, |
@@ -50,6 +51,14 @@ func (tableService *TableService) DBTablePreview(ctx *domain.Context, cmd *comma | @@ -50,6 +51,14 @@ func (tableService *TableService) DBTablePreview(ctx *domain.Context, cmd *comma | ||
50 | }, | 51 | }, |
51 | In: []interface{}{domain.CommonLog.ToString()}, | 52 | In: []interface{}{domain.CommonLog.ToString()}, |
52 | }}) | 53 | }}) |
54 | + case domain.DBTableQuerySetLog.ToInt(): | ||
55 | + options.SetCondition([]domain.Condition{{ | ||
56 | + Field: &domain.Field{ | ||
57 | + SQLName: "log_type", | ||
58 | + SQLType: domain.String.ToString(), | ||
59 | + }, | ||
60 | + In: []interface{}{domain.QuerySetLog.ToString()}, | ||
61 | + }}) | ||
53 | } | 62 | } |
54 | 63 | ||
55 | dataTable, err = starrocks.Query(options, starrocks.WrapQueryFuncWithDB(pg.GormDB)) | 64 | dataTable, err = starrocks.Query(options, starrocks.WrapQueryFuncWithDB(pg.GormDB)) |
@@ -4,12 +4,15 @@ import ( | @@ -4,12 +4,15 @@ import ( | ||
4 | "fmt" | 4 | "fmt" |
5 | "github.com/linmadan/egglib-go/core/application" | 5 | "github.com/linmadan/egglib-go/core/application" |
6 | "github.com/linmadan/egglib-go/utils/tool_funs" | 6 | "github.com/linmadan/egglib-go/utils/tool_funs" |
7 | + "github.com/zeromicro/go-zero/core/collection" | ||
7 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/factory" | 8 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/factory" |
8 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/command" | 9 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/command" |
9 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/dto" | 10 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/dto" |
10 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/query" | 11 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/query" |
11 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | 12 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" |
13 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/starrocks" | ||
12 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils" | 14 | "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils" |
15 | + "strings" | ||
13 | ) | 16 | ) |
14 | 17 | ||
15 | // 表服务 | 18 | // 表服务 |
@@ -229,6 +232,9 @@ func (tableService *TableService) Search(searchQuery *query.SearchTableQuery) (i | @@ -229,6 +232,9 @@ func (tableService *TableService) Search(searchQuery *query.SearchTableQuery) (i | ||
229 | for _, table := range tables { | 232 | for _, table := range tables { |
230 | var item = &dto.TableDto{} | 233 | var item = &dto.TableDto{} |
231 | item.Load(table) | 234 | item.Load(table) |
235 | + if searchQuery.ReturnDetailStructInfo { | ||
236 | + item.SetDetailStructInfo(table) | ||
237 | + } | ||
232 | result = append(result, item) | 238 | result = append(result, item) |
233 | } | 239 | } |
234 | 240 | ||
@@ -258,7 +264,7 @@ func (tableService *TableService) RelationGraph(searchQuery *query.SearchTableQu | @@ -258,7 +264,7 @@ func (tableService *TableService) RelationGraph(searchQuery *query.SearchTableQu | ||
258 | }() | 264 | }() |
259 | 265 | ||
260 | tableRepository, _, _ := factory.FastPgTable(transactionContext, 0) | 266 | tableRepository, _, _ := factory.FastPgTable(transactionContext, 0) |
261 | - name :=searchQuery.Name | 267 | + name := searchQuery.Name |
262 | searchQuery.Name = "" | 268 | searchQuery.Name = "" |
263 | _, tables, err := tableRepository.Find(utils.ObjectToMap(searchQuery)) | 269 | _, tables, err := tableRepository.Find(utils.ObjectToMap(searchQuery)) |
264 | if err != nil { | 270 | if err != nil { |
@@ -275,10 +281,10 @@ func (tableService *TableService) RelationGraph(searchQuery *query.SearchTableQu | @@ -275,10 +281,10 @@ func (tableService *TableService) RelationGraph(searchQuery *query.SearchTableQu | ||
275 | if err := transactionContext.CommitTransaction(); err != nil { | 281 | if err := transactionContext.CommitTransaction(); err != nil { |
276 | return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | 282 | return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) |
277 | } | 283 | } |
278 | - result = dto.SuitTableByView(result,searchQuery.ViewType,name) | 284 | + result = dto.SuitTableByView(result, searchQuery.ViewType, name) |
279 | return map[string]interface{}{ | 285 | return map[string]interface{}{ |
280 | "count": len(result), | 286 | "count": len(result), |
281 | - "tables":result, | 287 | + "tables": result, |
282 | }, nil | 288 | }, nil |
283 | } | 289 | } |
284 | 290 | ||
@@ -380,6 +386,66 @@ func (tableService *TableService) AddTableStruct(ctx *domain.Context, cmd *comma | @@ -380,6 +386,66 @@ func (tableService *TableService) AddTableStruct(ctx *domain.Context, cmd *comma | ||
380 | return tableDetailDto, nil | 386 | return tableDetailDto, nil |
381 | } | 387 | } |
382 | 388 | ||
389 | +// 应用于 | ||
390 | +func (tableService *TableService) ApplyOn(ctx *domain.Context, cmd *command.ApplyOnCommand) (interface{}, error) { | ||
391 | + if err := cmd.ValidateCommand(); err != nil { | ||
392 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
393 | + } | ||
394 | + transactionContext, err := factory.CreateTransactionContext(nil) | ||
395 | + if err != nil { | ||
396 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
397 | + } | ||
398 | + if err := transactionContext.StartTransaction(); err != nil { | ||
399 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
400 | + } | ||
401 | + defer func() { | ||
402 | + transactionContext.RollbackTransaction() | ||
403 | + }() | ||
404 | + | ||
405 | + tableRepository, table, err := factory.FastPgTable(transactionContext, cmd.TableId) | ||
406 | + if err != nil { | ||
407 | + return nil, factory.FastError(err) | ||
408 | + } | ||
409 | + if table.TableInfo == nil { | ||
410 | + table.TableInfo = domain.NewTableInfo().SetApplyOn(cmd.Module) | ||
411 | + } else { | ||
412 | + table.TableInfo.SetApplyOn(cmd.Module) | ||
413 | + } | ||
414 | + | ||
415 | + table, err = tableRepository.Save(table) | ||
416 | + if err != nil { | ||
417 | + return nil, factory.FastError(err) | ||
418 | + } | ||
419 | + if err := transactionContext.CommitTransaction(); err != nil { | ||
420 | + return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) | ||
421 | + } | ||
422 | + return struct{}{}, nil | ||
423 | +} | ||
424 | + | ||
425 | +func (tableService *TableService) ValidExprSql(ctx *domain.Context, cmd *command.ValidExprSqlCommand) (interface{}, error) { | ||
426 | + if err := cmd.ValidateCommand(); err != nil { | ||
427 | + return nil, application.ThrowError(application.ARG_ERROR, err.Error()) | ||
428 | + } | ||
429 | + var result string = "成功" | ||
430 | + | ||
431 | + set := collection.NewSet() | ||
432 | + for _, f := range cmd.TableFields { | ||
433 | + set.AddStr(f.TableSqlName) | ||
434 | + } | ||
435 | + sql := "select " + cmd.ExprSql + " as expr" | ||
436 | + if len(set.KeysStr()) > 0 { | ||
437 | + sql += " from " + strings.Join(set.KeysStr(), ",") | ||
438 | + } | ||
439 | + sql += " limit 1" | ||
440 | + tx := starrocks.DB.Exec(sql) | ||
441 | + if tx.Error != nil { | ||
442 | + result = tx.Error.Error() | ||
443 | + } | ||
444 | + return map[string]string{ | ||
445 | + "result": result, | ||
446 | + }, nil | ||
447 | +} | ||
448 | + | ||
383 | func NewTableService(options map[string]interface{}) *TableService { | 449 | func NewTableService(options map[string]interface{}) *TableService { |
384 | newTableService := &TableService{} | 450 | newTableService := &TableService{} |
385 | return newTableService | 451 | return newTableService |
@@ -31,6 +31,7 @@ func (tableService *TableService) TablePreview(ctx *domain.Context, cmd *command | @@ -31,6 +31,7 @@ func (tableService *TableService) TablePreview(ctx *domain.Context, cmd *command | ||
31 | } | 31 | } |
32 | 32 | ||
33 | var options = starrocks.QueryOptions{ | 33 | var options = starrocks.QueryOptions{ |
34 | + Table: table, | ||
34 | TableName: table.SQLName, | 35 | TableName: table.SQLName, |
35 | Select: table.Fields(true), | 36 | Select: table.Fields(true), |
36 | } | 37 | } |
@@ -21,6 +21,20 @@ var ( | @@ -21,6 +21,20 @@ var ( | ||
21 | FileVerify OperationType = "FileVerify" // 文件校验 | 21 | FileVerify OperationType = "FileVerify" // 文件校验 |
22 | 22 | ||
23 | ExcelTableEdit OperationType = "ExcelTableEdit" // 文档表格编辑 | 23 | ExcelTableEdit OperationType = "ExcelTableEdit" // 文档表格编辑 |
24 | + | ||
25 | + CreateSchema OperationType = "CreateSchema" // 新增方案 | ||
26 | + CreateSubProcess OperationType = "CreateSubProcess" // 新增子过程 | ||
27 | + AddSetCondition OperationType = "AddSetCondition" // 新增条件判断 | ||
28 | + EditSetCondition OperationType = "EditSetCondition" // 编辑条件判断 | ||
29 | + DeleteSetCondition OperationType = "DeleteSetCondition" // 删除条件判断 | ||
30 | + AddSelectCondition OperationType = "AddSelectCondition" // 新增拆分规则 | ||
31 | + EditSelectCondition OperationType = "EditSelectCondition" // 编辑拆分规则 | ||
32 | + DeleteSelectCondition OperationType = "DeleteSelectCondition" // 删除拆分规则 | ||
33 | + CopyQuerySet OperationType = "CopyQuerySet" // 复制 | ||
34 | + RenameQuerySet OperationType = "RenameQuerySet" // 重命名 | ||
35 | + DeleteQuerySet OperationType = "DeleteQuerySet" // 删除 | ||
36 | + | ||
37 | + UnKnown OperationType = "UnKnown" // 未知 | ||
24 | ) | 38 | ) |
25 | 39 | ||
26 | var OperationTypeMap = map[string]string{ | 40 | var OperationTypeMap = map[string]string{ |
@@ -34,11 +48,24 @@ var OperationTypeMap = map[string]string{ | @@ -34,11 +48,24 @@ var OperationTypeMap = map[string]string{ | ||
34 | FileUpload.ToString(): "文件上传", | 48 | FileUpload.ToString(): "文件上传", |
35 | FileVerify.ToString(): "文件校验", | 49 | FileVerify.ToString(): "文件校验", |
36 | ExcelTableEdit.ToString(): "文档表格编辑", | 50 | ExcelTableEdit.ToString(): "文档表格编辑", |
51 | + | ||
52 | + CreateSchema.ToString(): "新增方案", | ||
53 | + CreateSubProcess.ToString(): "新增子过程", | ||
54 | + AddSetCondition.ToString(): "新增条件判断", | ||
55 | + EditSetCondition.ToString(): "编辑条件判断", | ||
56 | + DeleteSetCondition.ToString(): "删除条件判断", | ||
57 | + AddSelectCondition.ToString(): "新增拆分规则", | ||
58 | + EditSelectCondition.ToString(): "编辑拆分规则", | ||
59 | + DeleteSelectCondition.ToString(): "删除拆分规则", | ||
60 | + CopyQuerySet.ToString(): "复制", | ||
61 | + RenameQuerySet.ToString(): "重命名", | ||
62 | + DeleteQuerySet.ToString(): "删除", | ||
37 | } | 63 | } |
38 | 64 | ||
39 | var ( | 65 | var ( |
40 | VerifiedStepLog LogType = "VerifiedStepLog" | 66 | VerifiedStepLog LogType = "VerifiedStepLog" |
41 | CommonLog LogType = "CommonLog" | 67 | CommonLog LogType = "CommonLog" |
68 | + QuerySetLog LogType = "QuerySetLog" | ||
42 | ) | 69 | ) |
43 | 70 | ||
44 | var ( | 71 | var ( |
@@ -61,12 +88,14 @@ var ( | @@ -61,12 +88,14 @@ var ( | ||
61 | ) | 88 | ) |
62 | 89 | ||
63 | var ObjectTypeMap = map[string]string{ | 90 | var ObjectTypeMap = map[string]string{ |
64 | - MainTable.ToString(): "主表", | ||
65 | - SideTable.ToString(): "副表", | ||
66 | - SubTable.ToString(): "分表", | ||
67 | - SourceFile.ToString(): "源文件", | ||
68 | - VerifiedFile.ToString(): "校验文件", | ||
69 | - ObjectDBTable: "业务表", | 91 | + MainTable.ToString(): "主表", |
92 | + SideTable.ToString(): "副表", | ||
93 | + SubTable.ToString(): "分表", | ||
94 | + SourceFile.ToString(): "源文件", | ||
95 | + VerifiedFile.ToString(): "校验文件", | ||
96 | + ObjectDBTable: "业务表", | ||
97 | + SchemaTable.ToString(): "方案", | ||
98 | + SubProcessTable.ToString(): "子过程", | ||
70 | } | 99 | } |
71 | 100 | ||
72 | var ( | 101 | var ( |
@@ -207,6 +236,64 @@ var DBTables = map[int]*Table{ | @@ -207,6 +236,64 @@ var DBTables = map[int]*Table{ | ||
207 | }, | 236 | }, |
208 | }, | 237 | }, |
209 | }, | 238 | }, |
239 | + DBTableQuerySetLog.ToInt(): &Table{ | ||
240 | + TableId: 1, | ||
241 | + TableType: ObjectDBTable, | ||
242 | + Name: "日志信息", | ||
243 | + SQLName: "metadata.logs", | ||
244 | + DataFieldIndex: 6, | ||
245 | + PK: &Field{ | ||
246 | + Index: 0, | ||
247 | + Name: "日志ID", | ||
248 | + SQLName: "log_id", | ||
249 | + SQLType: Int.ToString(), | ||
250 | + Flag: PKField, | ||
251 | + }, | ||
252 | + DataFields: []*Field{ | ||
253 | + { | ||
254 | + Index: 1, | ||
255 | + Name: "方案/子过程", | ||
256 | + SQLName: "object_name", | ||
257 | + SQLType: String.ToString(), | ||
258 | + Flag: MainTableField, | ||
259 | + }, | ||
260 | + { | ||
261 | + Index: 2, | ||
262 | + Name: "类型", | ||
263 | + SQLName: "object_type", | ||
264 | + SQLType: String.ToString(), | ||
265 | + Flag: MainTableField, | ||
266 | + }, | ||
267 | + { | ||
268 | + Index: 3, | ||
269 | + Name: "操作类型", | ||
270 | + SQLName: "operation_type", | ||
271 | + SQLType: String.ToString(), | ||
272 | + Flag: MainTableField, | ||
273 | + }, | ||
274 | + { | ||
275 | + Index: 4, | ||
276 | + Name: "日志内容", | ||
277 | + SQLName: "content", | ||
278 | + SQLType: String.ToString(), | ||
279 | + Flag: MainTableField, | ||
280 | + }, | ||
281 | + { | ||
282 | + Index: 5, | ||
283 | + Name: "操作时间", | ||
284 | + SQLName: "log_time", //"created_at", | ||
285 | + SQLType: String.ToString(), | ||
286 | + Flag: MainTableField, | ||
287 | + }, | ||
288 | + { | ||
289 | + Index: 6, | ||
290 | + Name: "操作人", | ||
291 | + SQLName: "operator_name", | ||
292 | + SQLType: String.ToString(), | ||
293 | + Flag: MainTableField, | ||
294 | + }, | ||
295 | + }, | ||
296 | + }, | ||
210 | } | 297 | } |
211 | 298 | ||
212 | type DBTable int | 299 | type DBTable int |
@@ -217,7 +304,7 @@ func (t DBTable) ToInt() int { | @@ -217,7 +304,7 @@ func (t DBTable) ToInt() int { | ||
217 | 304 | ||
218 | const ( | 305 | const ( |
219 | DBTableTableOperateLog DBTable = 1 | 306 | DBTableTableOperateLog DBTable = 1 |
220 | - DBTableBusinessLog DBTable = 2 | 307 | + DBTableQuerySetLog DBTable = 2 |
221 | ) | 308 | ) |
222 | 309 | ||
223 | const ( | 310 | const ( |
@@ -336,3 +423,15 @@ var MapActionExtractColumn = map[string]Action{ | @@ -336,3 +423,15 @@ var MapActionExtractColumn = map[string]Action{ | ||
336 | Desc: "按数值提取", Name: "by-number", | 423 | Desc: "按数值提取", Name: "by-number", |
337 | }, | 424 | }, |
338 | } | 425 | } |
426 | + | ||
427 | +const ( | ||
428 | + StatusOn = 1 | ||
429 | + StatusOff = 2 | ||
430 | +) | ||
431 | + | ||
432 | +const ( | ||
433 | + ModuleAll = ModuleDigitalCenter | ModuleQuerySetCenter | ModuleCalculateCenter | ||
434 | + ModuleDigitalCenter = 1 | ||
435 | + ModuleQuerySetCenter = 2 | ||
436 | + ModuleCalculateCenter = 4 | ||
437 | +) |
@@ -31,6 +31,10 @@ func (l LogEntry) Context() *Context { | @@ -31,6 +31,10 @@ func (l LogEntry) Context() *Context { | ||
31 | return l.ctx | 31 | return l.ctx |
32 | } | 32 | } |
33 | 33 | ||
34 | +func (l LogEntry) OperateType() string { | ||
35 | + return l.OperationType | ||
36 | +} | ||
37 | + | ||
34 | func NewLogEntry(fileOrTableName string, objectType string, operationType OperationType, ctx *Context) LogEntry { | 38 | func NewLogEntry(fileOrTableName string, objectType string, operationType OperationType, ctx *Context) LogEntry { |
35 | return LogEntry{ | 39 | return LogEntry{ |
36 | ObjectName: fileOrTableName, | 40 | ObjectName: fileOrTableName, |
pkg/domain/query_set.go
0 → 100644
1 | +package domain | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + "github.com/google/uuid" | ||
6 | + "github.com/zeromicro/go-zero/core/collection" | ||
7 | + "sort" | ||
8 | + "time" | ||
9 | +) | ||
10 | + | ||
11 | +// 查询集合 | ||
12 | +type QuerySet struct { | ||
13 | + // 查询集合ID | ||
14 | + QuerySetId int `json:"querySetId"` | ||
15 | + // Schema:方案 SubProcess:子过程 | ||
16 | + Type string `json:"type"` | ||
17 | + // 标识 分组:Group 子过程/方案:Set | ||
18 | + Flag string `json:"flag"` | ||
19 | + // 名称 | ||
20 | + Name string `json:"name"` | ||
21 | + // 拼音(排序使用) | ||
22 | + PinName string `json:"pinName"` | ||
23 | + // 父级ID | ||
24 | + ParentId int `json:"parentId"` | ||
25 | + // 状态 1:启用 2:关闭 (子过程默认启用) | ||
26 | + Status int `json:"status"` | ||
27 | + // 查询集合信息 | ||
28 | + QuerySetInfo *QuerySetInfo `json:"querySetInfo"` | ||
29 | + // 查询组件 | ||
30 | + QueryComponents []*QueryComponent `json:"queryComponents"` | ||
31 | + // 排序 | ||
32 | + Sort int `json:"sort"` | ||
33 | + // 创建时间 | ||
34 | + CreatedAt time.Time `json:"createdAt"` | ||
35 | + // 更新时间 | ||
36 | + UpdatedAt time.Time `json:"updatedAt"` | ||
37 | + // 删除时间 | ||
38 | + DeletedAt time.Time `json:"deletedAt"` | ||
39 | + // 扩展 | ||
40 | + Context *Context `json:"context"` | ||
41 | +} | ||
42 | + | ||
43 | +type QuerySetRepository interface { | ||
44 | + Save(querySet *QuerySet) (*QuerySet, error) | ||
45 | + Remove(querySet *QuerySet) (*QuerySet, error) | ||
46 | + FindOne(queryOptions map[string]interface{}) (*QuerySet, error) | ||
47 | + Find(queryOptions map[string]interface{}) (int64, []*QuerySet, error) | ||
48 | +} | ||
49 | + | ||
50 | +func (querySet *QuerySet) Identify() interface{} { | ||
51 | + if querySet.QuerySetId == 0 { | ||
52 | + return nil | ||
53 | + } | ||
54 | + return querySet.QuerySetId | ||
55 | +} | ||
56 | + | ||
57 | +func (querySet *QuerySet) Update(queryComponents []*QueryComponent, tableId int) error { | ||
58 | + for i := range queryComponents { | ||
59 | + if len(queryComponents[i].Id) == 0 { | ||
60 | + uuid, _ := uuid.NewUUID() | ||
61 | + queryComponents[i].Id = uuid.String() | ||
62 | + } | ||
63 | + for j := range queryComponents[i].Conditions { | ||
64 | + if len(queryComponents[i].Conditions[j].Id) == 0 { | ||
65 | + uuid, _ := uuid.NewUUID() | ||
66 | + queryComponents[i].Conditions[j].Id = uuid.String() | ||
67 | + } | ||
68 | + } | ||
69 | + for j := range queryComponents[i].Selects { | ||
70 | + if len(queryComponents[i].Selects[j].Id) == 0 { | ||
71 | + uuid, _ := uuid.NewUUID() | ||
72 | + queryComponents[i].Selects[j].Id = uuid.String() | ||
73 | + } | ||
74 | + } | ||
75 | + } | ||
76 | + querySet.QueryComponents = queryComponents | ||
77 | + if querySet.QuerySetInfo.BindTableId == 0 { | ||
78 | + querySet.QuerySetInfo.BindTableId = tableId | ||
79 | + } | ||
80 | + querySet.UpdatedAt = time.Now() | ||
81 | + return nil | ||
82 | +} | ||
83 | + | ||
84 | +func ValidQuerySetType(t string) error { | ||
85 | + if t == SchemaTable.ToString() || t == SubProcessTable.ToString() { | ||
86 | + return nil | ||
87 | + } | ||
88 | + return fmt.Errorf("类型有误") | ||
89 | +} | ||
90 | + | ||
91 | +func ValidQuerySetFlag(t string) error { | ||
92 | + if t == FlagGroup || t == FlagSet { | ||
93 | + return nil | ||
94 | + } | ||
95 | + return fmt.Errorf("标识有误") | ||
96 | +} | ||
97 | + | ||
98 | +func (querySet *QuerySet) GetDependencyTables(queryComponents []*QueryComponent) []int { | ||
99 | + set := collection.NewSet() | ||
100 | + for i := range queryComponents { | ||
101 | + for _, c := range queryComponents[i].Conditions { | ||
102 | + for _, f := range c.FieldLeft.TableFields { | ||
103 | + set.AddInt(f.TableId) | ||
104 | + } | ||
105 | + for _, f := range c.FieldRight.TableFields { | ||
106 | + set.AddInt(f.TableId) | ||
107 | + } | ||
108 | + } | ||
109 | + for _, s := range queryComponents[i].Selects { | ||
110 | + for _, f := range s.FieldLeft.TableFields { | ||
111 | + set.AddInt(f.TableId) | ||
112 | + } | ||
113 | + for _, f := range s.FieldRight.TableFields { | ||
114 | + set.AddInt(f.TableId) | ||
115 | + } | ||
116 | + } | ||
117 | + } | ||
118 | + res := set.KeysInt() | ||
119 | + sort.Ints(res) | ||
120 | + return res | ||
121 | +} |
pkg/domain/query_set_components.go
0 → 100644
1 | +package domain | ||
2 | + | ||
3 | +var ( | ||
4 | + SchemaTable TableType = "Schema" | ||
5 | + SubProcessTable TableType = "SubProcess" | ||
6 | +) | ||
7 | + | ||
8 | +var ( | ||
9 | + FlagGroup = "Group" | ||
10 | + FlagSet = "Set" | ||
11 | +) | ||
12 | + | ||
13 | +var ( | ||
14 | + TableSplit SelectExprType = "TableSplit" //拆分 | ||
15 | + SplitAssign SelectExprType = "SplitAssign" //拆分赋值 | ||
16 | + NormalAssign SelectExprType = "NormalAssign" //正常赋值 | ||
17 | +) | ||
18 | + | ||
19 | +type SelectExprType string | ||
20 | + | ||
21 | +type QueryComponent struct { | ||
22 | + Id string `json:"id"` | ||
23 | + MasterTable QueryComponentTable `json:"masterTable"` | ||
24 | + Conditions []ConditionExpr `json:"conditions"` | ||
25 | + JoinTables []QueryComponentTable `json:"-"` //joinTables | ||
26 | + Selects []SelectExprGroup `json:"selects"` | ||
27 | + SelectFromTables []QueryComponentTable `json:"-"` //selectTables | ||
28 | + Description string `json:"description"` | ||
29 | +} | ||
30 | +type ConditionExpr struct { // 条件表达式 | ||
31 | + Id string `json:"id"` | ||
32 | + FieldLeft FieldExpr `json:"fieldLeft"` | ||
33 | + FieldRight FieldExpr `json:"fieldRight"` | ||
34 | + OperatorSymbol string `json:"operatorSymbol"` | ||
35 | + AndOr string `json:"andOr"` // and or | ||
36 | +} | ||
37 | + | ||
38 | +type SelectExpr struct { // 查询表达式 | ||
39 | + Id string `json:"id"` | ||
40 | + FieldLeft FieldExpr `json:"fieldLeft"` | ||
41 | + FieldRight FieldExpr `json:"fieldRight"` // has value when type is equal to 1 | ||
42 | + Type string `json:"type"` // 1.拆分 2.拆方赋值 3.正常赋值 | ||
43 | + //SubGroup []SelectExpr `json:"subGroup,omitempty"` | ||
44 | +} | ||
45 | +type SelectExprGroup struct { // 查询表达式 | ||
46 | + SelectExpr | ||
47 | + SubSelects []SelectExpr `json:"subSelects,omitempty"` | ||
48 | +} | ||
49 | + | ||
50 | +type FieldExpr struct { | ||
51 | + //LabelColumns []LabelColumn `json:"labelColumns"` | ||
52 | + TableFields []TableField `json:"tableFields"` | ||
53 | + //ExprHuman string `json:"exprHuman"` | ||
54 | + ExprSql string `json:"exprSql"` | ||
55 | +} | ||
56 | + | ||
57 | +type LabelColumn struct { | ||
58 | + Column TableField `json:"column,omitempty"` | ||
59 | + LabelExpr string `json:"labelExpr"` | ||
60 | +} | ||
61 | + | ||
62 | +type TableField struct { | ||
63 | + TableId int `json:"tableId"` | ||
64 | + TableName string `json:"tableName"` | ||
65 | + TableSqlName string `json:"tableSqlName"` | ||
66 | + FieldName string `json:"fieldName"` | ||
67 | + FieldSqlName string `json:"fieldSqlName"` | ||
68 | +} | ||
69 | + | ||
70 | +type QueryComponentTable struct { | ||
71 | + // 表Id | ||
72 | + TableId int `json:"tableId"` | ||
73 | + // 表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表 | ||
74 | + TableType string `json:"tableType"` | ||
75 | + // 名称 | ||
76 | + Name string `json:"name"` | ||
77 | + // 对应数据库名称 | ||
78 | + SQLName string `json:"sqlName"` | ||
79 | + // 父级ID | ||
80 | + ParentId int `json:"parentId"` | ||
81 | + // 所有列 | ||
82 | + Fields []*Field `json:"fields"` | ||
83 | +} | ||
84 | + | ||
85 | +type Join struct { | ||
86 | + TableId int | ||
87 | + TableName string | ||
88 | + TableSqlName string | ||
89 | + Conditions []ConditionExpr | ||
90 | + On SelectExpr | ||
91 | +} | ||
92 | + | ||
93 | +func NewQueryComponentTable(t *Table) QueryComponentTable { | ||
94 | + return QueryComponentTable{ | ||
95 | + TableId: t.TableId, | ||
96 | + TableType: t.TableType, | ||
97 | + Name: t.Name, | ||
98 | + SQLName: t.SQLName, | ||
99 | + ParentId: t.ParentId, | ||
100 | + Fields: t.Fields(false), | ||
101 | + } | ||
102 | +} | ||
103 | + | ||
104 | +func ConditionsToMapById(items []*ConditionExpr) map[string]*ConditionExpr { | ||
105 | + var res = make(map[string]*ConditionExpr) | ||
106 | + for i := range items { | ||
107 | + res[items[i].Id] = items[i] | ||
108 | + } | ||
109 | + return res | ||
110 | +} | ||
111 | + | ||
112 | +func SelectsToMapById(items []*SelectExprGroup) map[string]*SelectExprGroup { | ||
113 | + var res = make(map[string]*SelectExprGroup) | ||
114 | + for i := range items { | ||
115 | + res[items[i].Id] = items[i] | ||
116 | + } | ||
117 | + return res | ||
118 | +} |
pkg/domain/query_set_components_test.go
0 → 100644
1 | +package domain | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/google/gofuzz" | ||
5 | + "github.com/linmadan/egglib-go/utils/json" | ||
6 | + "log" | ||
7 | + "testing" | ||
8 | +) | ||
9 | + | ||
10 | +func TestMockComponents(t *testing.T) { | ||
11 | + f := fuzz.New() | ||
12 | + var components QueryComponent | ||
13 | + f.Fuzz(&components) | ||
14 | + d := json.MarshalToString(components) | ||
15 | + log.Println(d) | ||
16 | +} |
pkg/domain/query_set_info.go
0 → 100644
@@ -40,6 +40,8 @@ type Table struct { | @@ -40,6 +40,8 @@ type Table struct { | ||
40 | RowCount int `json:"rowCount,omitempty"` | 40 | RowCount int `json:"rowCount,omitempty"` |
41 | // 扩展 | 41 | // 扩展 |
42 | Context *Context `json:"context"` | 42 | Context *Context `json:"context"` |
43 | + // 表信息 | ||
44 | + TableInfo *TableInfo `json:"tableInfo"` | ||
43 | } | 45 | } |
44 | 46 | ||
45 | type TableRepository interface { | 47 | type TableRepository interface { |
@@ -67,6 +69,11 @@ func (table *Table) WithContext(ctx *Context) *Table { | @@ -67,6 +69,11 @@ func (table *Table) WithContext(ctx *Context) *Table { | ||
67 | return table | 69 | return table |
68 | } | 70 | } |
69 | 71 | ||
72 | +func (table *Table) WithPrefix(prefix string) *Table { | ||
73 | + table.SQLName = fmt.Sprintf("%v_%v", prefix, table.SQLName) | ||
74 | + return table | ||
75 | +} | ||
76 | + | ||
70 | func (table *Table) WithParentId(parentId int) *Table { | 77 | func (table *Table) WithParentId(parentId int) *Table { |
71 | table.ParentId = parentId | 78 | table.ParentId = parentId |
72 | return table | 79 | return table |
pkg/domain/table_info.go
0 → 100644
1 | +package domain | ||
2 | + | ||
3 | +type TableInfo struct { | ||
4 | + // 应用于模块 1:数控中心 2:拆解模块 4:计算模块 | ||
5 | + ApplyOnModule int `json:"module"` | ||
6 | + // 依赖关联的表 | ||
7 | + DependencyTables []int `json:"dependencyTables"` | ||
8 | +} | ||
9 | + | ||
10 | +func (t *TableInfo) SetApplyOn(applyOn int) *TableInfo { | ||
11 | + t.ApplyOnModule = applyOn | ||
12 | + return t | ||
13 | +} | ||
14 | + | ||
15 | +func (t *TableInfo) SetDependencyTables(tableIds []int) *TableInfo { | ||
16 | + t.DependencyTables = tableIds | ||
17 | + return t | ||
18 | +} | ||
19 | + | ||
20 | +func NewTableInfo() *TableInfo { | ||
21 | + return &TableInfo{ | ||
22 | + ApplyOnModule: 0, | ||
23 | + DependencyTables: make([]int, 0), | ||
24 | + } | ||
25 | +} |
pkg/infrastructure/dao/query_set.go
0 → 100644
1 | +package dao | ||
2 | + | ||
3 | +import pgTransaction "github.com/linmadan/egglib-go/transaction/pg" | ||
4 | + | ||
5 | +func QuerySetCurrentSort(ptr *pgTransaction.TransactionContext, t string, parentId int) (int, error) { | ||
6 | + sql := "select max(sort) sort from metadata.query_sets where type =? and parent_id = ?" | ||
7 | + var result struct { | ||
8 | + Sort int | ||
9 | + } | ||
10 | + if _, err := ptr.PgTx.Query(&result, sql, t, parentId); err != nil { | ||
11 | + return 0, err | ||
12 | + } | ||
13 | + return result.Sort + 1, nil | ||
14 | +} |
@@ -145,6 +145,7 @@ func NewTable(tableType domain.TableType, fileName string, dataFields []*domain. | @@ -145,6 +145,7 @@ func NewTable(tableType domain.TableType, fileName string, dataFields []*domain. | ||
145 | table.CreatedAt = time.Now() | 145 | table.CreatedAt = time.Now() |
146 | table.UpdatedAt = time.Now() | 146 | table.UpdatedAt = time.Now() |
147 | table.RowCount = rowCount | 147 | table.RowCount = rowCount |
148 | + table.TableInfo = domain.NewTableInfo() | ||
148 | return table | 149 | return table |
149 | } | 150 | } |
150 | 151 |
@@ -32,6 +32,7 @@ func FastLog(transactionContext *pgTransaction.TransactionContext, logType domai | @@ -32,6 +32,7 @@ func FastLog(transactionContext *pgTransaction.TransactionContext, logType domai | ||
32 | func (ptr *PGLogService) Log(logType domain.LogType, sourceId int, logEntry Log) error { | 32 | func (ptr *PGLogService) Log(logType domain.LogType, sourceId int, logEntry Log) error { |
33 | logRepository, _ := repository.NewLogRepository(ptr.transactionContext) | 33 | logRepository, _ := repository.NewLogRepository(ptr.transactionContext) |
34 | entry := logEntry.Entry() | 34 | entry := logEntry.Entry() |
35 | + entry.OperationType = logEntry.OperateType() | ||
35 | log := &domain.Log{ | 36 | log := &domain.Log{ |
36 | LogType: logType.ToString(), | 37 | LogType: logType.ToString(), |
37 | SourceId: sourceId, | 38 | SourceId: sourceId, |
@@ -45,6 +46,9 @@ func (ptr *PGLogService) Log(logType domain.LogType, sourceId int, logEntry Log) | @@ -45,6 +46,9 @@ func (ptr *PGLogService) Log(logType domain.LogType, sourceId int, logEntry Log) | ||
45 | Context: logEntry.Context(), | 46 | Context: logEntry.Context(), |
46 | LogTime: entry.LogTime, | 47 | LogTime: entry.LogTime, |
47 | } | 48 | } |
49 | + if entry.OperationType == domain.UnKnown.ToString() { | ||
50 | + return nil | ||
51 | + } | ||
48 | 52 | ||
49 | if v, ok := logEntry.Context().GetValue(domain.ContextWithLogLevel); ok { | 53 | if v, ok := logEntry.Context().GetValue(domain.ContextWithLogLevel); ok { |
50 | log.Entry.Level = string(v.(domain.LogLevel)) | 54 | log.Entry.Level = string(v.(domain.LogLevel)) |
@@ -64,6 +68,7 @@ type Log interface { | @@ -64,6 +68,7 @@ type Log interface { | ||
64 | Content() string | 68 | Content() string |
65 | Entry() domain.LogEntry | 69 | Entry() domain.LogEntry |
66 | Context() *domain.Context | 70 | Context() *domain.Context |
71 | + OperateType() string | ||
67 | } | 72 | } |
68 | 73 | ||
69 | var _ Log = (*FileUploadSuccessLog)(nil) | 74 | var _ Log = (*FileUploadSuccessLog)(nil) |
@@ -317,3 +322,77 @@ func (l *ExcelTableEditLog) Content() string { | @@ -317,3 +322,77 @@ func (l *ExcelTableEditLog) Content() string { | ||
317 | msg := fmt.Sprintf("%v:%v", l.OperateName, strings.Join(fieldsName, "、")) | 322 | msg := fmt.Sprintf("%v:%v", l.OperateName, strings.Join(fieldsName, "、")) |
318 | return msg | 323 | return msg |
319 | } | 324 | } |
325 | + | ||
326 | +/* *********************************************拆解模块************************************************** */ | ||
327 | + | ||
328 | +type CreateQuerySetLog struct { | ||
329 | + domain.LogEntry | ||
330 | + Qs *domain.QuerySet | ||
331 | +} | ||
332 | + | ||
333 | +func (l *CreateQuerySetLog) OperateType() string { | ||
334 | + if l.Qs.Type == domain.SchemaTable.ToString() && l.Qs.Flag == domain.FlagSet { | ||
335 | + return domain.CreateSchema.ToString() | ||
336 | + } | ||
337 | + if l.Qs.Type == domain.SubProcessTable.ToString() && l.Qs.Flag == domain.FlagSet { | ||
338 | + return domain.CreateSubProcess.ToString() | ||
339 | + } | ||
340 | + return domain.UnKnown.ToString() | ||
341 | +} | ||
342 | + | ||
343 | +func (l *CreateQuerySetLog) Content() string { | ||
344 | + return "新增成功" | ||
345 | +} | ||
346 | + | ||
347 | +type RenameQuerySetLog struct { | ||
348 | + domain.LogEntry | ||
349 | + OldName string | ||
350 | + NewName string | ||
351 | +} | ||
352 | + | ||
353 | +func (l *RenameQuerySetLog) OperateType() string { | ||
354 | + return domain.RenameQuerySet.ToString() | ||
355 | +} | ||
356 | + | ||
357 | +func (l *RenameQuerySetLog) Content() string { | ||
358 | + return fmt.Sprintf(`"%s"重命名为"%v"`, l.OldName, l.NewName) | ||
359 | +} | ||
360 | + | ||
361 | +type DeleteQuerySetLog struct { | ||
362 | + domain.LogEntry | ||
363 | + DeleteList []*domain.QuerySet | ||
364 | +} | ||
365 | + | ||
366 | +func (l *DeleteQuerySetLog) OperateType() string { | ||
367 | + if len(l.DeleteList) == 0 { | ||
368 | + return domain.UnKnown.ToString() | ||
369 | + } | ||
370 | + return domain.DeleteQuerySet.ToString() | ||
371 | +} | ||
372 | + | ||
373 | +func (l *DeleteQuerySetLog) Content() string { | ||
374 | + names := make([]string, 0) | ||
375 | + for i := range l.DeleteList { | ||
376 | + names = append(names, "\""+l.DeleteList[i].Name+"\"") | ||
377 | + } | ||
378 | + t := domain.EnumsDescription(domain.ObjectTypeMap, l.DeleteList[0].Type) | ||
379 | + if l.DeleteList[0].Flag == domain.FlagGroup { | ||
380 | + t += "分组" | ||
381 | + } | ||
382 | + return fmt.Sprintf(`%s%s删除成功`, t, strings.Join(names, "、")) | ||
383 | +} | ||
384 | + | ||
385 | +type CopyQuerySetLog struct { | ||
386 | + domain.LogEntry | ||
387 | + From *domain.QuerySet | ||
388 | + To *domain.QuerySet | ||
389 | +} | ||
390 | + | ||
391 | +func (l *CopyQuerySetLog) OperateType() string { | ||
392 | + return domain.CopyQuerySet.ToString() | ||
393 | +} | ||
394 | + | ||
395 | +func (l *CopyQuerySetLog) Content() string { | ||
396 | + return fmt.Sprintf(`%s"%s"复制为%s"%s""`, domain.EnumsDescription(domain.ObjectTypeMap, l.From.Type), l.From.Name, | ||
397 | + domain.EnumsDescription(domain.ObjectTypeMap, l.To.Type), l.To.Name) | ||
398 | +} |
1 | +package domainService | ||
2 | + | ||
3 | +import ( | ||
4 | + "fmt" | ||
5 | + pgTransaction "github.com/linmadan/egglib-go/transaction/pg" | ||
6 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
7 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/dao" | ||
8 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository" | ||
9 | + "strings" | ||
10 | + "time" | ||
11 | +) | ||
12 | + | ||
13 | +var ( | ||
14 | + ErrQuerySetNameExists = fmt.Errorf("已存在") | ||
15 | + ErrQuerySetParentNotExists = fmt.Errorf("父级不存在") | ||
16 | + ErrQuerySetInvalidType = fmt.Errorf("查询集合的类型有误") | ||
17 | +) | ||
18 | + | ||
19 | +type QuerySetService struct { | ||
20 | + transactionContext *pgTransaction.TransactionContext | ||
21 | +} | ||
22 | + | ||
23 | +func NewQuerySetService(transactionContext *pgTransaction.TransactionContext) (*QuerySetService, error) { | ||
24 | + if transactionContext == nil { | ||
25 | + return nil, fmt.Errorf("transactionContext参数不能为nil") | ||
26 | + } else { | ||
27 | + return &QuerySetService{ | ||
28 | + transactionContext: transactionContext, | ||
29 | + }, nil | ||
30 | + } | ||
31 | +} | ||
32 | + | ||
33 | +func (ptr *QuerySetService) Create(ctx *domain.Context, qs *domain.QuerySet) error { | ||
34 | + newQuerySet := &domain.QuerySet{ | ||
35 | + Type: qs.Type, | ||
36 | + Flag: qs.Flag, | ||
37 | + Name: qs.Name, | ||
38 | + ParentId: qs.ParentId, | ||
39 | + PinName: pin(qs.Name), | ||
40 | + Status: domain.StatusOn, | ||
41 | + QuerySetInfo: &domain.QuerySetInfo{}, | ||
42 | + QueryComponents: make([]*domain.QueryComponent, 0), | ||
43 | + CreatedAt: time.Now(), | ||
44 | + UpdatedAt: time.Now(), | ||
45 | + Context: ctx, | ||
46 | + } | ||
47 | + | ||
48 | + querySetRepository, err := repository.NewQuerySetRepository(ptr.transactionContext) | ||
49 | + // check parent | ||
50 | + options := map[string]interface{}{ | ||
51 | + "type": qs.Type, | ||
52 | + "flag": qs.Flag, | ||
53 | + "name": qs.Name, | ||
54 | + } | ||
55 | + if qs.ParentId > 0 { | ||
56 | + parent, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": qs.ParentId}) | ||
57 | + if err != nil { | ||
58 | + return ErrQuerySetParentNotExists | ||
59 | + } | ||
60 | + if parent.Type != qs.Type { | ||
61 | + return ErrQuerySetInvalidType | ||
62 | + } | ||
63 | + options["parentId"] = qs.ParentId | ||
64 | + } | ||
65 | + // check duplicate name | ||
66 | + if found, foundErr := querySetRepository.FindOne(options); foundErr == nil && found != nil && found.Name == qs.Name { | ||
67 | + return ErrQuerySetNameExists | ||
68 | + } | ||
69 | + // current sort | ||
70 | + newQuerySet.Sort, err = dao.QuerySetCurrentSort(ptr.transactionContext, qs.Type, qs.ParentId) | ||
71 | + if err != nil { | ||
72 | + return err | ||
73 | + } | ||
74 | + if newQuerySet, err = querySetRepository.Save(newQuerySet); err != nil { | ||
75 | + return err | ||
76 | + } | ||
77 | + | ||
78 | + // 日志 | ||
79 | + if err = FastLog(ptr.transactionContext, domain.QuerySetLog, newQuerySet.QuerySetId, &CreateQuerySetLog{ | ||
80 | + LogEntry: domain.NewLogEntry(newQuerySet.Name, qs.Type, domain.UnKnown, ctx), | ||
81 | + Qs: newQuerySet, | ||
82 | + }); err != nil { | ||
83 | + return err | ||
84 | + } | ||
85 | + return nil | ||
86 | +} | ||
87 | + | ||
88 | +func (ptr *QuerySetService) Update(ctx *domain.Context, querySetId int, queryComponents []*domain.QueryComponent) error { | ||
89 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
90 | + qs, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
91 | + if err != nil { | ||
92 | + return err | ||
93 | + } | ||
94 | + // 调用底层的组装sql | ||
95 | + | ||
96 | + // 生成Table | ||
97 | + masterTable := queryComponents[0].MasterTable | ||
98 | + table, err := ptr.CreateOrReFreshQuerySetTable(ctx, qs, masterTable, queryComponents) | ||
99 | + if err != nil { | ||
100 | + return err | ||
101 | + } | ||
102 | + // 生成日志 | ||
103 | + if err = ptr.UpdateQuerySetLog(ctx, qs, queryComponents); err != nil { | ||
104 | + return err | ||
105 | + } | ||
106 | + // 保存 | ||
107 | + qs.Update(queryComponents, table.TableId) | ||
108 | + _, err = querySetRepository.Save(qs) | ||
109 | + if err != nil { | ||
110 | + return err | ||
111 | + } | ||
112 | + return nil | ||
113 | +} | ||
114 | + | ||
115 | +func (ptr *QuerySetService) UpdateQuerySetLog(ctx *domain.Context, querySet *domain.QuerySet, queryComponents []*domain.QueryComponent) error { | ||
116 | + return nil | ||
117 | +} | ||
118 | + | ||
119 | +func (ptr *QuerySetService) CreateOrReFreshQuerySetTable(ctx *domain.Context, querySet *domain.QuerySet, masterTable domain.QueryComponentTable, queryComponents []*domain.QueryComponent) (*domain.Table, error) { | ||
120 | + var ( | ||
121 | + err error | ||
122 | + foundMasterTable *domain.Table | ||
123 | + ) | ||
124 | + tableRepository, _ := repository.NewTableRepository(ptr.transactionContext) | ||
125 | + foundMasterTable, err = tableRepository.FindOne(map[string]interface{}{"context": ctx, "tableId": masterTable.TableId}) | ||
126 | + if err != nil { | ||
127 | + return nil, err | ||
128 | + } | ||
129 | + masterTable = domain.NewQueryComponentTable(foundMasterTable) | ||
130 | + var table *domain.Table = NewTable(domain.TableType(querySet.Type), querySet.Name, masterTable.Fields, 0).WithContext(ctx).WithPrefix(strings.ToLower(querySet.Type)) | ||
131 | + if querySet.QuerySetInfo.BindTableId > 0 { | ||
132 | + table, err = tableRepository.FindOne(map[string]interface{}{"context": ctx, "tableId": querySet.QuerySetInfo.BindTableId}) | ||
133 | + if err != nil { | ||
134 | + return nil, err | ||
135 | + } | ||
136 | + table.DataFields = masterTable.Fields | ||
137 | + table.UpdatedAt = time.Now() | ||
138 | + } | ||
139 | + table.TableInfo.ApplyOnModule = domain.ModuleAll | ||
140 | + table.TableInfo.DependencyTables = querySet.GetDependencyTables(queryComponents) | ||
141 | + table, err = tableRepository.Save(table) | ||
142 | + if err != nil { | ||
143 | + return nil, err | ||
144 | + } | ||
145 | + return table, nil | ||
146 | +} | ||
147 | + | ||
148 | +func (ptr *QuerySetService) Rename(ctx *domain.Context, querySetId int, name string) error { | ||
149 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
150 | + qs, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
151 | + if err != nil { | ||
152 | + return err | ||
153 | + } | ||
154 | + if qs.Name == name { | ||
155 | + return nil | ||
156 | + } | ||
157 | + var oldName = qs.Name | ||
158 | + // check duplicate name | ||
159 | + if found, foundErr := querySetRepository.FindOne(map[string]interface{}{"context": ctx, "type": qs.Type, "parentId": qs.ParentId, "name": name}); foundErr == nil && found != nil { | ||
160 | + return ErrQuerySetNameExists | ||
161 | + } | ||
162 | + qs.Name = name | ||
163 | + _, err = querySetRepository.Save(qs) | ||
164 | + if err != nil { | ||
165 | + return err | ||
166 | + } | ||
167 | + // 日志 | ||
168 | + if err = FastLog(ptr.transactionContext, domain.QuerySetLog, qs.QuerySetId, &RenameQuerySetLog{ | ||
169 | + LogEntry: domain.NewLogEntry(qs.Name, qs.Type, domain.UnKnown, ctx), | ||
170 | + NewName: name, | ||
171 | + OldName: oldName, | ||
172 | + }); err != nil { | ||
173 | + return err | ||
174 | + } | ||
175 | + return nil | ||
176 | +} | ||
177 | + | ||
178 | +func (ptr *QuerySetService) ChangeStatus(ctx *domain.Context, querySetId int, status int) error { | ||
179 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
180 | + qs, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
181 | + if err != nil { | ||
182 | + return err | ||
183 | + } | ||
184 | + if qs.Status == status { | ||
185 | + return nil | ||
186 | + } | ||
187 | + if qs.Type != domain.SchemaTable.ToString() { | ||
188 | + return fmt.Errorf("方案才可以修改状态") | ||
189 | + } | ||
190 | + qs.Status = status | ||
191 | + _, err = querySetRepository.Save(qs) | ||
192 | + if err != nil { | ||
193 | + return err | ||
194 | + } | ||
195 | + return nil | ||
196 | +} | ||
197 | + | ||
198 | +func (ptr *QuerySetService) Copy(ctx *domain.Context, querySetId int, t string, groupId int, name string) error { | ||
199 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
200 | + qs, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
201 | + if err != nil { | ||
202 | + return err | ||
203 | + } | ||
204 | + | ||
205 | + copy := copyQuerySet(qs, t, groupId, name) | ||
206 | + copy.Sort, err = dao.QuerySetCurrentSort(ptr.transactionContext, copy.Type, copy.ParentId) | ||
207 | + if err != nil { | ||
208 | + return err | ||
209 | + } | ||
210 | + // check duplicate name | ||
211 | + options := map[string]interface{}{ | ||
212 | + "type": t, | ||
213 | + "flag": qs.Flag, | ||
214 | + "name": name, | ||
215 | + "parentId": groupId, | ||
216 | + } | ||
217 | + if found, foundErr := querySetRepository.FindOne(options); foundErr == nil && found != nil && found.Name == name { | ||
218 | + return ErrQuerySetNameExists | ||
219 | + } | ||
220 | + // TODO:create-table | ||
221 | + if copy.QuerySetInfo.BindTableId != 0 { | ||
222 | + tableRepository, _ := repository.NewTableRepository(ptr.transactionContext) | ||
223 | + table, err := tableRepository.FindOne(map[string]interface{}{"tableId": copy.QuerySetInfo.BindTableId}) | ||
224 | + if err != nil { | ||
225 | + return err | ||
226 | + } | ||
227 | + NewTable(domain.TableType(t), name, table.DataFields, 0).WithContext(ctx) | ||
228 | + } | ||
229 | + _, err = querySetRepository.Save(copy) | ||
230 | + if err != nil { | ||
231 | + return err | ||
232 | + } | ||
233 | + return nil | ||
234 | +} | ||
235 | + | ||
236 | +func copyQuerySet(qs *domain.QuerySet, t string, groupId int, name string) *domain.QuerySet { | ||
237 | + var res = &domain.QuerySet{ | ||
238 | + Type: t, | ||
239 | + Flag: qs.Flag, | ||
240 | + Name: name, | ||
241 | + PinName: pin(name), | ||
242 | + ParentId: groupId, | ||
243 | + Status: qs.Status, | ||
244 | + QuerySetInfo: qs.QuerySetInfo, | ||
245 | + QueryComponents: qs.QueryComponents, | ||
246 | + Sort: 0, | ||
247 | + CreatedAt: time.Now(), | ||
248 | + UpdatedAt: time.Now(), | ||
249 | + Context: qs.Context, | ||
250 | + } | ||
251 | + return res | ||
252 | +} | ||
253 | + | ||
254 | +func (ptr *QuerySetService) Delete(ctx *domain.Context, querySetId int) error { | ||
255 | + querySets, err := ptr.GetAllChild(ctx, querySetId, true, false) | ||
256 | + if err != nil { | ||
257 | + return err | ||
258 | + } | ||
259 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
260 | + for i := range querySets { | ||
261 | + if _, err := querySetRepository.Remove(querySets[i]); err != nil { | ||
262 | + return err | ||
263 | + } | ||
264 | + } | ||
265 | + // 日志 | ||
266 | + if len(querySets) > 0 { | ||
267 | + qs := querySets[0] | ||
268 | + if err = FastLog(ptr.transactionContext, domain.QuerySetLog, querySetId, &DeleteQuerySetLog{ | ||
269 | + LogEntry: domain.NewLogEntry(qs.Name, qs.Type, domain.UnKnown, ctx), | ||
270 | + DeleteList: querySets, | ||
271 | + }); err != nil { | ||
272 | + return err | ||
273 | + } | ||
274 | + } | ||
275 | + | ||
276 | + return nil | ||
277 | +} | ||
278 | + | ||
279 | +func (ptr *QuerySetService) Move(ctx *domain.Context, querySetId int, parentId int, sort int) error { | ||
280 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
281 | + qs, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
282 | + if err != nil { | ||
283 | + return err | ||
284 | + } | ||
285 | + | ||
286 | + // check parent | ||
287 | + options := map[string]interface{}{ | ||
288 | + "type": qs.Type, | ||
289 | + "flag": qs.Flag, | ||
290 | + "name": qs.Name, | ||
291 | + "parentId": parentId, | ||
292 | + } | ||
293 | + if parentId > 0 && qs.ParentId != parentId { | ||
294 | + parent, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": parentId}) | ||
295 | + if err != nil { | ||
296 | + return ErrQuerySetParentNotExists | ||
297 | + } | ||
298 | + if parent.Type != qs.Type { | ||
299 | + return ErrQuerySetInvalidType | ||
300 | + } | ||
301 | + // check duplicate name | ||
302 | + if found, foundErr := querySetRepository.FindOne(options); foundErr == nil && found != nil && found.Name == qs.Name { | ||
303 | + return ErrQuerySetNameExists | ||
304 | + } | ||
305 | + } | ||
306 | + | ||
307 | + querySets, err := ptr.GetAllChild(ctx, parentId, false, true) | ||
308 | + if err != nil { | ||
309 | + return err | ||
310 | + } | ||
311 | + newSortSet := make([]*domain.QuerySet, 0) | ||
312 | + for i := 0; i < len(querySets); i++ { | ||
313 | + if querySets[i].QuerySetId == qs.QuerySetId { | ||
314 | + continue | ||
315 | + } | ||
316 | + newSortSet = append(newSortSet, querySets[i]) | ||
317 | + } | ||
318 | + // 移动分组 | ||
319 | + qs.Sort = sort | ||
320 | + qs.ParentId = parentId | ||
321 | + newSortSet = insertQuerySetsByIndex(newSortSet, qs, sort) | ||
322 | + | ||
323 | + for i := 0; i < len(newSortSet); i++ { | ||
324 | + currentSort := i + 1 | ||
325 | + if newSortSet[i].Sort == currentSort && newSortSet[i].QuerySetId != querySetId { | ||
326 | + continue | ||
327 | + } | ||
328 | + newSortSet[i].Sort = currentSort | ||
329 | + if _, err := querySetRepository.Save(newSortSet[i]); err != nil { | ||
330 | + return err | ||
331 | + } | ||
332 | + } | ||
333 | + return nil | ||
334 | +} | ||
335 | + | ||
336 | +func insertQuerySetsByIndex(list []*domain.QuerySet, item *domain.QuerySet, index int) []*domain.QuerySet { | ||
337 | + if len(list) == 0 { | ||
338 | + return []*domain.QuerySet{item} | ||
339 | + } | ||
340 | + if len(list) < index { | ||
341 | + return append(list, item) | ||
342 | + } | ||
343 | + var res = make([]*domain.QuerySet, 0) | ||
344 | + for i := range list { | ||
345 | + if i+1 == index { | ||
346 | + res = append(res, item) | ||
347 | + } | ||
348 | + res = append(res, list[i]) | ||
349 | + } | ||
350 | + return res | ||
351 | +} | ||
352 | + | ||
353 | +func (ptr *QuerySetService) DependencyGraph(ctx *domain.Context, querySetId int) (interface{}, error) { | ||
354 | + tableRepository, _ := repository.NewTableRepository(ptr.transactionContext) | ||
355 | + _, tables, err := tableRepository.Find(map[string]interface{}{"context": ctx, "tableTypes": []string{domain.SchemaTable.ToString(), domain.SubProcessTable.ToString()}}) | ||
356 | + dependencies := make([]dependency, 0) | ||
357 | + if err != nil { | ||
358 | + return dependencies, err | ||
359 | + } | ||
360 | + if len(tables) == 0 { | ||
361 | + return dependencies, nil | ||
362 | + } | ||
363 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
364 | + querySet, err := querySetRepository.FindOne(map[string]interface{}{"context": ctx, "querySetId": querySetId}) | ||
365 | + if err != nil { | ||
366 | + return dependencies, err | ||
367 | + } | ||
368 | + if querySet.QuerySetInfo.BindTableId == 0 { | ||
369 | + return dependencies, nil | ||
370 | + } | ||
371 | + dependencies = makeDependencyGraph(querySet.QuerySetInfo.BindTableId, tables) | ||
372 | + return dependencies, nil | ||
373 | +} | ||
374 | + | ||
375 | +func makeDependencyGraph(bindTableId int, tables []*domain.Table) []dependency { | ||
376 | + dependencies := make([]dependency, 0) | ||
377 | + tableMap := make(map[int]*domain.Table) | ||
378 | + graph := make(map[int][]int, 0) | ||
379 | + for i := range tables { | ||
380 | + tableMap[tables[i].TableId] = tables[i] | ||
381 | + graph[tables[i].TableId] = tables[i].TableInfo.DependencyTables | ||
382 | + } | ||
383 | + // parent depend | ||
384 | + dependTables := []int{bindTableId} | ||
385 | + | ||
386 | + foundDependency := make(map[string]bool, 0) | ||
387 | + for { | ||
388 | + if len(dependTables) == 0 { | ||
389 | + break | ||
390 | + } | ||
391 | + parent := dependTables[0] | ||
392 | + parentTable, ok := tableMap[parent] | ||
393 | + if !ok { | ||
394 | + continue | ||
395 | + } | ||
396 | + for _, dependChildId := range parentTable.TableInfo.DependencyTables { | ||
397 | + dependChild, ok := tableMap[dependChildId] | ||
398 | + if !ok { | ||
399 | + continue | ||
400 | + } | ||
401 | + depend := NewDependency(parentTable.TableId, dependChild) | ||
402 | + if _, ok := foundDependency[depend.String()]; !ok { | ||
403 | + dependencies = append(dependencies, depend) | ||
404 | + } | ||
405 | + } | ||
406 | + dependTables = dependTables[1:] | ||
407 | + } | ||
408 | + | ||
409 | + // dependToChild | ||
410 | + return dependencies | ||
411 | +} | ||
412 | + | ||
413 | +func dependParents(tables []*domain.Table, tableMap map[int]*domain.Table, bindTableId int) []int { | ||
414 | + foundDependTable := make(map[int]bool) | ||
415 | + traceStack := []int{bindTableId} | ||
416 | + res := []int{bindTableId} | ||
417 | + for { | ||
418 | + if len(traceStack) == 0 { | ||
419 | + break | ||
420 | + } | ||
421 | + last := traceStack[0] | ||
422 | + traceStack = traceStack[1:] | ||
423 | + table := tableMap[last] | ||
424 | + if table == nil { | ||
425 | + continue | ||
426 | + } | ||
427 | + // for | ||
428 | + if _, ok := foundDependTable[last]; !ok { | ||
429 | + foundDependTable[last] = true | ||
430 | + } | ||
431 | + } | ||
432 | + return res | ||
433 | +} | ||
434 | + | ||
435 | +func NewDependency(parentId int, child *domain.Table) dependency { | ||
436 | + return dependency{ | ||
437 | + Id: parentId, | ||
438 | + } | ||
439 | +} | ||
440 | + | ||
441 | +type dependency struct { | ||
442 | + // 标识 | ||
443 | + Id int `json:"id"` | ||
444 | + // 表类型 MainTable:主表 SideTable:副表 SubTable:分表 ExcelTable:Excel表 | ||
445 | + Type string `json:"type"` | ||
446 | + // 名称 | ||
447 | + Name string `json:"name"` | ||
448 | + // 依赖的表 | ||
449 | + DependChildId int `json:"dependChildId"` | ||
450 | +} | ||
451 | + | ||
452 | +func (d dependency) String() string { | ||
453 | + return fmt.Sprintf("%d-%d", d.Id, d.DependChildId) | ||
454 | +} | ||
455 | + | ||
456 | +func (ptr *QuerySetService) GetAllChild(ctx *domain.Context, querySetId int, includeSelf bool, onlyNextLevel bool) ([]*domain.QuerySet, error) { | ||
457 | + var result = make([]*domain.QuerySet, 0) | ||
458 | + var m = make(map[int]*domain.QuerySet) | ||
459 | + var parentIds = []int{querySetId} | ||
460 | + querySetRepository, _ := repository.NewQuerySetRepository(ptr.transactionContext) | ||
461 | + if includeSelf { | ||
462 | + self, err := querySetRepository.FindOne(map[string]interface{}{"querySetId": querySetId}) | ||
463 | + if err != nil { | ||
464 | + return nil, err | ||
465 | + } | ||
466 | + m[self.QuerySetId] = self | ||
467 | + result = append(result, self) | ||
468 | + } | ||
469 | + for { | ||
470 | + if len(parentIds) == 0 { | ||
471 | + break | ||
472 | + } | ||
473 | + _, querySet, err := querySetRepository.Find(map[string]interface{}{"inParentIds": parentIds}) | ||
474 | + if err != nil { | ||
475 | + return nil, err | ||
476 | + } | ||
477 | + parentIds = make([]int, 0) | ||
478 | + for _, item := range querySet { | ||
479 | + item := item | ||
480 | + if _, ok := m[item.QuerySetId]; ok { | ||
481 | + continue | ||
482 | + } | ||
483 | + m[item.QuerySetId] = item | ||
484 | + result = append(result, item) | ||
485 | + parentIds = append(parentIds, item.QuerySetId) | ||
486 | + } | ||
487 | + if onlyNextLevel { | ||
488 | + break | ||
489 | + } | ||
490 | + } | ||
491 | + return result, nil | ||
492 | +} |
@@ -35,6 +35,7 @@ func Init() { | @@ -35,6 +35,7 @@ func Init() { | ||
35 | (*models.Table)(nil), | 35 | (*models.Table)(nil), |
36 | (*models.Log)(nil), | 36 | (*models.Log)(nil), |
37 | (*models.MappingRule)(nil), | 37 | (*models.MappingRule)(nil), |
38 | + (*models.QuerySet)(nil), | ||
38 | } { | 39 | } { |
39 | err := DB.Model(model).CreateTable(&orm.CreateTableOptions{ | 40 | err := DB.Model(model).CreateTable(&orm.CreateTableOptions{ |
40 | Temp: false, | 41 | Temp: false, |
pkg/infrastructure/pg/models/query_set.go
0 → 100644
1 | +package models | ||
2 | + | ||
3 | +import ( | ||
4 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
5 | + "time" | ||
6 | +) | ||
7 | + | ||
8 | +type QuerySet struct { | ||
9 | + tableName string `comment:"查询集合" pg:"metadata.query_sets"` | ||
10 | + // 查询集合ID | ||
11 | + QuerySetId int `comment:"查询集合ID" pg:"pk:query_set_id"` | ||
12 | + // Schema:方案 SubProcess:子过程 | ||
13 | + Type string `comment:"Schema:方案 SubProcess:子过程"` | ||
14 | + // 标识 分组:group 子过程/方案:query-set | ||
15 | + Flag string `comment:"标识 1:主表字段 2:手动添加"` | ||
16 | + // 名称 | ||
17 | + Name string `comment:"名称"` | ||
18 | + // 拼音(排序使用) | ||
19 | + PinName string `comment:"拼音(排序使用)"` | ||
20 | + // 父级ID | ||
21 | + ParentId int `comment:"父级ID"` | ||
22 | + // 状态 1:启用 2:关闭 (子过程默认启用) | ||
23 | + Status int `comment:"状态 1:启用 2:关闭 (子过程默认启用)"` | ||
24 | + // 查询集合信息 | ||
25 | + QuerySetInfo *domain.QuerySetInfo `comment:"查询集合信息"` | ||
26 | + // 查询组件 | ||
27 | + QueryComponents []*domain.QueryComponent `comment:"查询组件"` | ||
28 | + // 排序 | ||
29 | + Sort int `comment:"排序"` | ||
30 | + // 创建时间 | ||
31 | + CreatedAt time.Time `comment:"创建时间"` | ||
32 | + // 更新时间 | ||
33 | + UpdatedAt time.Time `comment:"更新时间"` | ||
34 | + // 删除时间 | ||
35 | + DeletedAt time.Time `pg:",soft_delete" comment:"删除时间"` | ||
36 | + // 扩展 | ||
37 | + Context *domain.Context `comment:"扩展"` | ||
38 | +} |
@@ -36,5 +36,7 @@ type Table struct { | @@ -36,5 +36,7 @@ type Table struct { | ||
36 | // 行数 | 36 | // 行数 |
37 | RowCount int `comment:"行数"` | 37 | RowCount int `comment:"行数"` |
38 | // 扩展 | 38 | // 扩展 |
39 | - Context *domain.Context `json:"context"` | 39 | + Context *domain.Context `comment:"扩展"` |
40 | + // 表信息 | ||
41 | + TableInfo *domain.TableInfo `comment:"表信息"` | ||
40 | } | 42 | } |
pkg/infrastructure/pg/transform/query_set.go
0 → 100644
1 | +package transform | ||
2 | + | ||
3 | +import ( | ||
4 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/models" | ||
6 | +) | ||
7 | + | ||
8 | +func TransformToQuerySetDomainModelFromPgModels(querySetModel *models.QuerySet) (*domain.QuerySet, error) { | ||
9 | + return &domain.QuerySet{ | ||
10 | + QuerySetId: querySetModel.QuerySetId, | ||
11 | + Type: querySetModel.Type, | ||
12 | + Flag: querySetModel.Flag, | ||
13 | + Name: querySetModel.Name, | ||
14 | + PinName: querySetModel.PinName, | ||
15 | + ParentId: querySetModel.ParentId, | ||
16 | + Status: querySetModel.Status, | ||
17 | + QuerySetInfo: querySetModel.QuerySetInfo, | ||
18 | + QueryComponents: querySetModel.QueryComponents, | ||
19 | + Sort: querySetModel.Sort, | ||
20 | + CreatedAt: querySetModel.CreatedAt, | ||
21 | + UpdatedAt: querySetModel.UpdatedAt, | ||
22 | + DeletedAt: querySetModel.DeletedAt, | ||
23 | + Context: querySetModel.Context, | ||
24 | + }, nil | ||
25 | +} |
@@ -26,5 +26,6 @@ func TransformToTableDomainModelFromPgModels(tableModel *models.Table) (*domain. | @@ -26,5 +26,6 @@ func TransformToTableDomainModelFromPgModels(tableModel *models.Table) (*domain. | ||
26 | Version: tableModel.Version, | 26 | Version: tableModel.Version, |
27 | RowCount: tableModel.RowCount, | 27 | RowCount: tableModel.RowCount, |
28 | Context: tableModel.Context, | 28 | Context: tableModel.Context, |
29 | + TableInfo: tableModel.TableInfo, | ||
29 | }, nil | 30 | }, nil |
30 | } | 31 | } |
1 | +package repository | ||
2 | + | ||
3 | +import ( | ||
4 | + "errors" | ||
5 | + "fmt" | ||
6 | + "github.com/go-pg/pg/v10" | ||
7 | + | ||
8 | + "github.com/linmadan/egglib-go/persistent/pg/sqlbuilder" | ||
9 | + pgTransaction "github.com/linmadan/egglib-go/transaction/pg" | ||
10 | + "github.com/linmadan/egglib-go/utils/snowflake" | ||
11 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain" | ||
12 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/models" | ||
13 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/transform" | ||
14 | +) | ||
15 | + | ||
16 | +type QuerySetRepository struct { | ||
17 | + transactionContext *pgTransaction.TransactionContext | ||
18 | +} | ||
19 | + | ||
20 | +func (repository *QuerySetRepository) nextIdentify() (int64, error) { | ||
21 | + IdWorker, err := snowflake.NewIdWorker(1) | ||
22 | + if err != nil { | ||
23 | + return 0, err | ||
24 | + } | ||
25 | + id, err := IdWorker.NextId() | ||
26 | + return id, err | ||
27 | +} | ||
28 | +func (repository *QuerySetRepository) Save(querySet *domain.QuerySet) (*domain.QuerySet, error) { | ||
29 | + sqlBuildFields := []string{ | ||
30 | + "query_set_id", | ||
31 | + "type", | ||
32 | + "flag", | ||
33 | + "name", | ||
34 | + "pin_name", | ||
35 | + "parent_id", | ||
36 | + "status", | ||
37 | + "query_set_info", | ||
38 | + "query_components", | ||
39 | + "sort", | ||
40 | + "created_at", | ||
41 | + "updated_at", | ||
42 | + "context", | ||
43 | + } | ||
44 | + insertFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "query_set_id", "deleted_at")) | ||
45 | + insertPlaceHoldersSnippet := sqlbuilder.SqlPlaceHoldersSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "query_set_id", "deleted_at")) | ||
46 | + returningFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlBuildFields) | ||
47 | + updateFields := sqlbuilder.RemoveSqlFields(sqlBuildFields, "query_set_id") | ||
48 | + updateFieldsSnippet := sqlbuilder.SqlUpdateFieldsSnippet(updateFields) | ||
49 | + tx := repository.transactionContext.PgTx | ||
50 | + if querySet.Identify() == nil { | ||
51 | + if _, err := tx.QueryOne( | ||
52 | + pg.Scan( | ||
53 | + &querySet.QuerySetId, | ||
54 | + &querySet.Type, | ||
55 | + &querySet.Flag, | ||
56 | + &querySet.Name, | ||
57 | + &querySet.PinName, | ||
58 | + &querySet.ParentId, | ||
59 | + &querySet.Status, | ||
60 | + &querySet.QuerySetInfo, | ||
61 | + &querySet.QueryComponents, | ||
62 | + &querySet.Sort, | ||
63 | + &querySet.CreatedAt, | ||
64 | + &querySet.UpdatedAt, | ||
65 | + &querySet.Context, | ||
66 | + ), | ||
67 | + fmt.Sprintf("INSERT INTO metadata.query_sets (%s) VALUES (%s) RETURNING %s", insertFieldsSnippet, insertPlaceHoldersSnippet, returningFieldsSnippet), | ||
68 | + querySet.Type, | ||
69 | + querySet.Flag, | ||
70 | + querySet.Name, | ||
71 | + querySet.PinName, | ||
72 | + querySet.ParentId, | ||
73 | + querySet.Status, | ||
74 | + querySet.QuerySetInfo, | ||
75 | + querySet.QueryComponents, | ||
76 | + querySet.Sort, | ||
77 | + querySet.CreatedAt, | ||
78 | + querySet.UpdatedAt, | ||
79 | + querySet.Context, | ||
80 | + ); err != nil { | ||
81 | + return querySet, err | ||
82 | + } | ||
83 | + } else { | ||
84 | + if _, err := tx.QueryOne( | ||
85 | + pg.Scan( | ||
86 | + &querySet.QuerySetId, | ||
87 | + &querySet.Type, | ||
88 | + &querySet.Flag, | ||
89 | + &querySet.Name, | ||
90 | + &querySet.PinName, | ||
91 | + &querySet.ParentId, | ||
92 | + &querySet.Status, | ||
93 | + &querySet.QuerySetInfo, | ||
94 | + &querySet.QueryComponents, | ||
95 | + &querySet.Sort, | ||
96 | + &querySet.CreatedAt, | ||
97 | + &querySet.UpdatedAt, | ||
98 | + &querySet.Context, | ||
99 | + ), | ||
100 | + fmt.Sprintf("UPDATE metadata.query_sets SET %s WHERE query_set_id=? RETURNING %s", updateFieldsSnippet, returningFieldsSnippet), | ||
101 | + querySet.Type, | ||
102 | + querySet.Flag, | ||
103 | + querySet.Name, | ||
104 | + querySet.PinName, | ||
105 | + querySet.ParentId, | ||
106 | + querySet.Status, | ||
107 | + querySet.QuerySetInfo, | ||
108 | + querySet.QueryComponents, | ||
109 | + querySet.Sort, | ||
110 | + querySet.CreatedAt, | ||
111 | + querySet.UpdatedAt, | ||
112 | + querySet.Context, | ||
113 | + querySet.Identify(), | ||
114 | + ); err != nil { | ||
115 | + return querySet, err | ||
116 | + } | ||
117 | + } | ||
118 | + return querySet, nil | ||
119 | +} | ||
120 | +func (repository *QuerySetRepository) Remove(querySet *domain.QuerySet) (*domain.QuerySet, error) { | ||
121 | + tx := repository.transactionContext.PgTx | ||
122 | + querySetModel := new(models.QuerySet) | ||
123 | + querySetModel.QuerySetId = querySet.Identify().(int) | ||
124 | + if _, err := tx.Model(querySetModel).WherePK().Delete(); err != nil { | ||
125 | + return querySet, err | ||
126 | + } | ||
127 | + return querySet, nil | ||
128 | +} | ||
129 | +func (repository *QuerySetRepository) FindOne(queryOptions map[string]interface{}) (*domain.QuerySet, error) { | ||
130 | + tx := repository.transactionContext.PgTx | ||
131 | + querySetModel := new(models.QuerySet) | ||
132 | + query := sqlbuilder.BuildQuery(tx.Model(querySetModel), queryOptions) | ||
133 | + WhereContext(query, queryOptions) | ||
134 | + query.SetWhereByQueryOption("query_set_id = ?", "querySetId") | ||
135 | + query.SetWhereByQueryOption("type = ?", "type") | ||
136 | + query.SetWhereByQueryOption("flag = ?", "flag") | ||
137 | + query.SetWhereByQueryOption("parent_id = ?", "parentId") | ||
138 | + query.SetWhereByQueryOption("name = ?", "name") | ||
139 | + if err := query.First(); err != nil { | ||
140 | + if errors.Is(err, pg.ErrNoRows) { | ||
141 | + return nil, domain.ErrorNotFound | ||
142 | + } else { | ||
143 | + return nil, err | ||
144 | + } | ||
145 | + } | ||
146 | + if querySetModel.QuerySetId == 0 { | ||
147 | + return nil, nil | ||
148 | + } else { | ||
149 | + return transform.TransformToQuerySetDomainModelFromPgModels(querySetModel) | ||
150 | + } | ||
151 | +} | ||
152 | +func (repository *QuerySetRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.QuerySet, error) { | ||
153 | + tx := repository.transactionContext.PgTx | ||
154 | + var querySetModels []*models.QuerySet | ||
155 | + querySets := make([]*domain.QuerySet, 0) | ||
156 | + query := sqlbuilder.BuildQuery(tx.Model(&querySetModels), queryOptions) | ||
157 | + WhereContext(query, queryOptions) | ||
158 | + query.SetWhereByQueryOption("type = ?", "type") | ||
159 | + query.SetWhereByQueryOption("flag = ?", "flag") | ||
160 | + query.SetWhereByQueryOption(fmt.Sprintf("name like '%%%v%%'", queryOptions["matchName"]), "matchName") | ||
161 | + if v, ok := queryOptions["inParentIds"]; ok && len(v.([]int)) > 0 { | ||
162 | + query.Where("parent_id in (?)", pg.In(v)) | ||
163 | + } | ||
164 | + if v, ok := queryOptions["sortByName"]; ok && len(v.(string)) > 0 { | ||
165 | + query.SetOrderDirect("pin_name", v.(string)) | ||
166 | + } else if v, ok := queryOptions["sortByTime"]; ok && len(v.(string)) > 0 { | ||
167 | + query.SetOrderDirect("created_at", v.(string)) | ||
168 | + } else { | ||
169 | + query.SetOrderDirect("parent_id", "ASC") | ||
170 | + query.SetOrderDirect("sort", "ASC") | ||
171 | + } | ||
172 | + if count, err := query.SelectAndCount(); err != nil { | ||
173 | + return 0, querySets, err | ||
174 | + } else { | ||
175 | + for _, querySetModel := range querySetModels { | ||
176 | + if querySet, err := transform.TransformToQuerySetDomainModelFromPgModels(querySetModel); err != nil { | ||
177 | + return 0, querySets, err | ||
178 | + } else { | ||
179 | + querySets = append(querySets, querySet) | ||
180 | + } | ||
181 | + } | ||
182 | + return int64(count), querySets, nil | ||
183 | + } | ||
184 | +} | ||
185 | +func NewQuerySetRepository(transactionContext *pgTransaction.TransactionContext) (*QuerySetRepository, error) { | ||
186 | + if transactionContext == nil { | ||
187 | + return nil, fmt.Errorf("transactionContext参数不能为nil") | ||
188 | + } else { | ||
189 | + return &QuerySetRepository{ | ||
190 | + transactionContext: transactionContext, | ||
191 | + }, nil | ||
192 | + } | ||
193 | +} |
@@ -32,6 +32,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | @@ -32,6 +32,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | ||
32 | "version", | 32 | "version", |
33 | "row_count", | 33 | "row_count", |
34 | "context", | 34 | "context", |
35 | + "table_info", | ||
35 | } | 36 | } |
36 | insertFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "table_id", "deleted_at")) | 37 | insertFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "table_id", "deleted_at")) |
37 | insertPlaceHoldersSnippet := sqlbuilder.SqlPlaceHoldersSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "table_id", "deleted_at")) | 38 | insertPlaceHoldersSnippet := sqlbuilder.SqlPlaceHoldersSnippet(sqlbuilder.RemoveSqlFields(sqlBuildFields, "table_id", "deleted_at")) |
@@ -57,6 +58,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | @@ -57,6 +58,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | ||
57 | &table.Version, | 58 | &table.Version, |
58 | &table.RowCount, | 59 | &table.RowCount, |
59 | &table.Context, | 60 | &table.Context, |
61 | + &table.TableInfo, | ||
60 | ), | 62 | ), |
61 | fmt.Sprintf("INSERT INTO metadata.tables (%s) VALUES (%s) RETURNING %s", insertFieldsSnippet, insertPlaceHoldersSnippet, returningFieldsSnippet), | 63 | fmt.Sprintf("INSERT INTO metadata.tables (%s) VALUES (%s) RETURNING %s", insertFieldsSnippet, insertPlaceHoldersSnippet, returningFieldsSnippet), |
62 | table.TableType, | 64 | table.TableType, |
@@ -72,6 +74,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | @@ -72,6 +74,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | ||
72 | table.Version, | 74 | table.Version, |
73 | table.RowCount, | 75 | table.RowCount, |
74 | table.Context, | 76 | table.Context, |
77 | + table.TableInfo, | ||
75 | ); err != nil { | 78 | ); err != nil { |
76 | return table, err | 79 | return table, err |
77 | } | 80 | } |
@@ -95,6 +98,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | @@ -95,6 +98,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | ||
95 | &table.Version, | 98 | &table.Version, |
96 | &table.RowCount, | 99 | &table.RowCount, |
97 | &table.Context, | 100 | &table.Context, |
101 | + &table.TableInfo, | ||
98 | ), | 102 | ), |
99 | fmt.Sprintf("UPDATE metadata.tables SET %s WHERE table_id=? and version=? RETURNING %s", updateFieldsSnippet, returningFieldsSnippet), | 103 | fmt.Sprintf("UPDATE metadata.tables SET %s WHERE table_id=? and version=? RETURNING %s", updateFieldsSnippet, returningFieldsSnippet), |
100 | table.TableType, | 104 | table.TableType, |
@@ -110,6 +114,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | @@ -110,6 +114,7 @@ func (repository *TableRepository) Save(table *domain.Table) (*domain.Table, err | ||
110 | table.Version, | 114 | table.Version, |
111 | table.RowCount, | 115 | table.RowCount, |
112 | table.Context, | 116 | table.Context, |
117 | + table.TableInfo, | ||
113 | table.Identify(), | 118 | table.Identify(), |
114 | oldVersion, | 119 | oldVersion, |
115 | ); err != nil { | 120 | ); err != nil { |
@@ -164,6 +169,9 @@ func (repository *TableRepository) Find(queryOptions map[string]interface{}) (in | @@ -164,6 +169,9 @@ func (repository *TableRepository) Find(queryOptions map[string]interface{}) (in | ||
164 | if v, ok := queryOptions["tableTypes"]; ok && len(v.([]string)) > 0 { | 169 | if v, ok := queryOptions["tableTypes"]; ok && len(v.([]string)) > 0 { |
165 | query.Where(`table_type in (?)`, pg.In(v.([]string))) | 170 | query.Where(`table_type in (?)`, pg.In(v.([]string))) |
166 | } | 171 | } |
172 | + if v, ok := queryOptions["module"]; ok && v.(int) > 0 { | ||
173 | + query.Where(`(cast(table_info->>'module' as integer) & ?) >0`, v) | ||
174 | + } | ||
167 | 175 | ||
168 | //query.SetOffsetAndLimit(20) | 176 | //query.SetOffsetAndLimit(20) |
169 | query.SetOrderDirect("table_id", "DESC") | 177 | query.SetOrderDirect("table_id", "DESC") |
@@ -86,19 +86,20 @@ func (o *QueryOptions) SetDefaultOrder() *QueryOptions { | @@ -86,19 +86,20 @@ func (o *QueryOptions) SetDefaultOrder() *QueryOptions { | ||
86 | 86 | ||
87 | type Condition struct { | 87 | type Condition struct { |
88 | domain.Condition | 88 | domain.Condition |
89 | - Distinct bool | 89 | + Distinct bool |
90 | + DisableFormat bool | ||
90 | } | 91 | } |
91 | 92 | ||
92 | -func (c Condition) SetWhere(q *gorm.DB) { | 93 | +func (c Condition) SetWhere(params QueryOptions, q *gorm.DB) { |
93 | if len(c.Like) > 0 { | 94 | if len(c.Like) > 0 { |
94 | - q.Where(fmt.Sprintf("%v like '%%%v%%'", FormatIfNull(c.Field), c.Like)) | 95 | + q.Where(fmt.Sprintf("%v like '%%%v%%'", c.FormatIfNull(params, c.Field), c.Like)) |
95 | } | 96 | } |
96 | if len(c.In) > 0 { | 97 | if len(c.In) > 0 { |
97 | - q.Where(fmt.Sprintf("%v in %v", FormatIfNull(c.Field), c.InArgs(c.In))) | 98 | + q.Where(fmt.Sprintf("%v in %v", c.FormatIfNull(params, c.Field), c.InArgs(c.In))) |
98 | } | 99 | } |
99 | if len(c.Ex) > 0 { | 100 | if len(c.Ex) > 0 { |
100 | in := c.InArgs(c.Ex) | 101 | in := c.InArgs(c.Ex) |
101 | - q.Where(fmt.Sprintf("%v not in %v", FormatIfNull(c.Field), in)) | 102 | + q.Where(fmt.Sprintf("%v not in %v", c.FormatIfNull(params, c.Field), in)) |
102 | } | 103 | } |
103 | if len(c.Range) > 0 { | 104 | if len(c.Range) > 0 { |
104 | for _, item := range c.Range { | 105 | for _, item := range c.Range { |
@@ -115,7 +116,7 @@ func (c Condition) SetWhere(q *gorm.DB) { | @@ -115,7 +116,7 @@ func (c Condition) SetWhere(q *gorm.DB) { | ||
115 | continue | 116 | continue |
116 | } | 117 | } |
117 | q.Where(fmt.Sprintf("%s %s %s", | 118 | q.Where(fmt.Sprintf("%s %s %s", |
118 | - FormatIfNull(c.Field), | 119 | + c.FormatIfNull(params, c.Field), |
119 | opVal, | 120 | opVal, |
120 | c.formatByOp(item.Op, val), | 121 | c.formatByOp(item.Op, val), |
121 | )) | 122 | )) |
@@ -129,7 +130,10 @@ func (c Condition) SetWhere(q *gorm.DB) { | @@ -129,7 +130,10 @@ func (c Condition) SetWhere(q *gorm.DB) { | ||
129 | } | 130 | } |
130 | } | 131 | } |
131 | 132 | ||
132 | -func FormatIfNull(f *domain.Field) string { | 133 | +func (c Condition) FormatIfNull(params QueryOptions, f *domain.Field) string { |
134 | + if params.Table != nil && params.Table.TableType == domain.ObjectDBTable { | ||
135 | + return f.SQLName | ||
136 | + } | ||
133 | if domain.SQLType(f.SQLType).IsString() { | 137 | if domain.SQLType(f.SQLType).IsString() { |
134 | return fmt.Sprintf("ifnull(%s,'')", f.SQLName) | 138 | return fmt.Sprintf("ifnull(%s,'')", f.SQLName) |
135 | } | 139 | } |
@@ -254,7 +258,7 @@ func queryWithoutLimitOffset(query *gorm.DB, params QueryOptions) { | @@ -254,7 +258,7 @@ func queryWithoutLimitOffset(query *gorm.DB, params QueryOptions) { | ||
254 | if w.Field.Flag == domain.ManualField { | 258 | if w.Field.Flag == domain.ManualField { |
255 | continue | 259 | continue |
256 | } | 260 | } |
257 | - w.SetWhere(query) | 261 | + w.SetWhere(params, query) |
258 | } | 262 | } |
259 | } | 263 | } |
260 | } | 264 | } |
@@ -80,6 +80,17 @@ func (controller *LogController) TableOperateLog() { | @@ -80,6 +80,17 @@ func (controller *LogController) TableOperateLog() { | ||
80 | ResponseGrid(controller.BaseController, total, data, err) | 80 | ResponseGrid(controller.BaseController, total, data, err) |
81 | } | 81 | } |
82 | 82 | ||
83 | +func (controller *LogController) QuerySetLog() { | ||
84 | + logService := service.NewLogService(nil) | ||
85 | + cmd := &command.SearchLogCommand{} | ||
86 | + controller.Unmarshal(cmd) | ||
87 | + cmd.LogType = domain.QuerySetLog.ToString() | ||
88 | + cmd.SortByLogId = "DESC" | ||
89 | + cmd.Context = ParseContext(controller.BaseController) | ||
90 | + total, data, err := logService.SearchLog(cmd) | ||
91 | + ResponseGrid(controller.BaseController, total, data, err) | ||
92 | +} | ||
93 | + | ||
83 | func (controller *LogController) VerifiedStepLog() { | 94 | func (controller *LogController) VerifiedStepLog() { |
84 | logService := service.NewLogService(nil) | 95 | logService := service.NewLogService(nil) |
85 | cmd := &command.SearchLogCommand{} | 96 | cmd := &command.SearchLogCommand{} |
1 | +package controllers | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/linmadan/egglib-go/web/beego" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/command" | ||
6 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/query" | ||
7 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/querySet/service" | ||
8 | +) | ||
9 | + | ||
10 | +type QuerySetController struct { | ||
11 | + beego.BaseController | ||
12 | +} | ||
13 | + | ||
14 | +func (controller *QuerySetController) CreateQuerySet() { | ||
15 | + querySetService := service.NewQuerySetService(nil) | ||
16 | + createQuerySetCommand := &command.CreateQuerySetCommand{} | ||
17 | + Must(controller.Unmarshal(createQuerySetCommand)) | ||
18 | + data, err := querySetService.CreateQuerySet(ParseContext(controller.BaseController), createQuerySetCommand) | ||
19 | + controller.Response(data, err) | ||
20 | +} | ||
21 | + | ||
22 | +func (controller *QuerySetController) UpdateQuerySet() { | ||
23 | + querySetService := service.NewQuerySetService(nil) | ||
24 | + updateQuerySetCommand := &command.UpdateQuerySetCommand{} | ||
25 | + controller.Unmarshal(updateQuerySetCommand) | ||
26 | + Id, _ := controller.GetInt(":querySetId") | ||
27 | + updateQuerySetCommand.QuerySetId = Id | ||
28 | + data, err := querySetService.UpdateQuerySet(ParseContext(controller.BaseController), updateQuerySetCommand) | ||
29 | + controller.Response(data, err) | ||
30 | +} | ||
31 | + | ||
32 | +func (controller *QuerySetController) GetQuerySet() { | ||
33 | + querySetService := service.NewQuerySetService(nil) | ||
34 | + getQuerySetQuery := &query.GetQuerySetQuery{} | ||
35 | + Id, _ := controller.GetInt(":querySetId") | ||
36 | + getQuerySetQuery.QuerySetId = Id | ||
37 | + data, err := querySetService.GetQuerySet(ParseContext(controller.BaseController), getQuerySetQuery) | ||
38 | + controller.Response(data, err) | ||
39 | +} | ||
40 | + | ||
41 | +func (controller *QuerySetController) RemoveQuerySet() { | ||
42 | + querySetService := service.NewQuerySetService(nil) | ||
43 | + removeQuerySetCommand := &command.RemoveQuerySetCommand{} | ||
44 | + controller.Unmarshal(removeQuerySetCommand) | ||
45 | + Id, _ := controller.GetInt(":querySetId") | ||
46 | + removeQuerySetCommand.QuerySetId = Id | ||
47 | + data, err := querySetService.RemoveQuerySet(ParseContext(controller.BaseController), removeQuerySetCommand) | ||
48 | + controller.Response(data, err) | ||
49 | +} | ||
50 | + | ||
51 | +func (controller *QuerySetController) ListQuerySet() { | ||
52 | + querySetService := service.NewQuerySetService(nil) | ||
53 | + listQuerySetQuery := &query.ListQuerySetQuery{} | ||
54 | + offset, _ := controller.GetInt("offset") | ||
55 | + listQuerySetQuery.Offset = offset | ||
56 | + limit, _ := controller.GetInt("limit") | ||
57 | + listQuerySetQuery.Limit = limit | ||
58 | + data, err := querySetService.ListQuerySet(ParseContext(controller.BaseController), listQuerySetQuery) | ||
59 | + controller.Response(data, err) | ||
60 | +} | ||
61 | + | ||
62 | +func (controller *QuerySetController) ChangeStatus() { | ||
63 | + querySetService := service.NewQuerySetService(nil) | ||
64 | + changeStatusCommand := &command.ChangeStatusCommand{} | ||
65 | + Must(controller.Unmarshal(changeStatusCommand)) | ||
66 | + data, err := querySetService.ChangeStatus(ParseContext(controller.BaseController), changeStatusCommand) | ||
67 | + controller.Response(data, err) | ||
68 | +} | ||
69 | + | ||
70 | +func (controller *QuerySetController) Copy() { | ||
71 | + querySetService := service.NewQuerySetService(nil) | ||
72 | + copyCommand := &command.CopyCommand{} | ||
73 | + Must(controller.Unmarshal(copyCommand)) | ||
74 | + data, err := querySetService.Copy(ParseContext(controller.BaseController), copyCommand) | ||
75 | + controller.Response(data, err) | ||
76 | +} | ||
77 | + | ||
78 | +func (controller *QuerySetController) DependencyGraph() { | ||
79 | + querySetService := service.NewQuerySetService(nil) | ||
80 | + dependencyGraphQuery := &query.DependencyGraphQuery{} | ||
81 | + Must(controller.Unmarshal(dependencyGraphQuery)) | ||
82 | + data, err := querySetService.DependencyGraph(ParseContext(controller.BaseController), dependencyGraphQuery) | ||
83 | + controller.Response(data, err) | ||
84 | +} | ||
85 | + | ||
86 | +func (controller *QuerySetController) Move() { | ||
87 | + querySetService := service.NewQuerySetService(nil) | ||
88 | + moveCommand := &command.MoveCommand{} | ||
89 | + Must(controller.Unmarshal(moveCommand)) | ||
90 | + data, err := querySetService.Move(ParseContext(controller.BaseController), moveCommand) | ||
91 | + controller.Response(data, err) | ||
92 | +} | ||
93 | + | ||
94 | +func (controller *QuerySetController) Rename() { | ||
95 | + querySetService := service.NewQuerySetService(nil) | ||
96 | + renameCommand := &command.RenameCommand{} | ||
97 | + Must(controller.Unmarshal(renameCommand)) | ||
98 | + data, err := querySetService.Rename(ParseContext(controller.BaseController), renameCommand) | ||
99 | + controller.Response(data, err) | ||
100 | +} | ||
101 | + | ||
102 | +func (controller *QuerySetController) SearchQuerySet() { | ||
103 | + querySetService := service.NewQuerySetService(nil) | ||
104 | + searchQuerySetQuery := &query.SearchQuerySetQuery{} | ||
105 | + Must(controller.Unmarshal(searchQuerySetQuery)) | ||
106 | + data, err := querySetService.SearchQuerySet(ParseContext(controller.BaseController), searchQuerySetQuery) | ||
107 | + controller.Response(data, err) | ||
108 | +} |
@@ -135,6 +135,20 @@ func (controller *TableController) SearchSubTableList() { | @@ -135,6 +135,20 @@ func (controller *TableController) SearchSubTableList() { | ||
135 | controller.Response(data, err) | 135 | controller.Response(data, err) |
136 | } | 136 | } |
137 | 137 | ||
138 | +func (controller *TableController) SearchQuerySetTables() { | ||
139 | + tableService := service.NewTableService(nil) | ||
140 | + cmd := &query.SearchTableQuery{} | ||
141 | + Must(controller.Unmarshal(cmd)) | ||
142 | + if len(cmd.TableTypes) == 0 { | ||
143 | + cmd.TableTypes = []string{domain.MainTable.ToString(), domain.SideTable.ToString(), domain.SubTable.ToString(), domain.SubProcessTable.ToString()} | ||
144 | + } | ||
145 | + cmd.Module = domain.ModuleQuerySetCenter | domain.ModuleCalculateCenter | ||
146 | + cmd.ReturnDetailStructInfo = true | ||
147 | + cmd.Context = ParseContext(controller.BaseController) | ||
148 | + data, err := tableService.Search(cmd) | ||
149 | + controller.Response(data, err) | ||
150 | +} | ||
151 | + | ||
138 | func (controller *TableController) UpdateTableStruct() { | 152 | func (controller *TableController) UpdateTableStruct() { |
139 | tableService := service.NewTableService(nil) | 153 | tableService := service.NewTableService(nil) |
140 | cmd := &command.UpdateTableStructCommand{} | 154 | cmd := &command.UpdateTableStructCommand{} |
@@ -153,6 +167,22 @@ func (controller *TableController) AddTableStruct() { | @@ -153,6 +167,22 @@ func (controller *TableController) AddTableStruct() { | ||
153 | controller.Response(data, err) | 167 | controller.Response(data, err) |
154 | } | 168 | } |
155 | 169 | ||
170 | +func (controller *TableController) ApplyOn() { | ||
171 | + tableService := service.NewTableService(nil) | ||
172 | + cmd := &command.ApplyOnCommand{} | ||
173 | + Must(controller.Unmarshal(cmd)) | ||
174 | + data, err := tableService.ApplyOn(ParseContext(controller.BaseController), cmd) | ||
175 | + controller.Response(data, err) | ||
176 | +} | ||
177 | + | ||
178 | +func (controller *TableController) ValidExprSql() { | ||
179 | + tableService := service.NewTableService(nil) | ||
180 | + cmd := &command.ValidExprSqlCommand{} | ||
181 | + Must(controller.Unmarshal(cmd)) | ||
182 | + data, err := tableService.ValidExprSql(ParseContext(controller.BaseController), cmd) | ||
183 | + controller.Response(data, err) | ||
184 | +} | ||
185 | + | ||
156 | func (controller *TableController) ExportDataTable() { | 186 | func (controller *TableController) ExportDataTable() { |
157 | tableService := service.NewTableService(nil) | 187 | tableService := service.NewTableService(nil) |
158 | cmd := &command.TablePreviewCommand{} | 188 | cmd := &command.TablePreviewCommand{} |
@@ -14,4 +14,5 @@ func init() { | @@ -14,4 +14,5 @@ func init() { | ||
14 | web.Router("/data/logs/search", &controllers.LogController{}, "Post:SearchLog") | 14 | web.Router("/data/logs/search", &controllers.LogController{}, "Post:SearchLog") |
15 | web.Router("/data/logs/table-operate-Log", &controllers.LogController{}, "Post:TableOperateLog") | 15 | web.Router("/data/logs/table-operate-Log", &controllers.LogController{}, "Post:TableOperateLog") |
16 | web.Router("/data/logs/verified-step-Log", &controllers.LogController{}, "Post:VerifiedStepLog") | 16 | web.Router("/data/logs/verified-step-Log", &controllers.LogController{}, "Post:VerifiedStepLog") |
17 | + web.Router("/data/logs/query-set-log", &controllers.LogController{}, "Post:QuerySetLog") | ||
17 | } | 18 | } |
pkg/port/beego/routers/query_set_router.go
0 → 100644
1 | +package routers | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/beego/beego/v2/server/web" | ||
5 | + "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/port/beego/controllers" | ||
6 | +) | ||
7 | + | ||
8 | +func init() { | ||
9 | + web.Router("/data/query-sets/", &controllers.QuerySetController{}, "Post:CreateQuerySet") | ||
10 | + web.Router("/data/query-sets/:querySetId", &controllers.QuerySetController{}, "Put:UpdateQuerySet") | ||
11 | + web.Router("/data/query-sets/:querySetId", &controllers.QuerySetController{}, "Get:GetQuerySet") | ||
12 | + web.Router("/data/query-sets/:querySetId", &controllers.QuerySetController{}, "Delete:RemoveQuerySet") | ||
13 | + web.Router("/data/query-sets/", &controllers.QuerySetController{}, "Get:ListQuerySet") | ||
14 | + | ||
15 | + web.Router("/data/query-sets/change-status", &controllers.QuerySetController{}, "Post:ChangeStatus") | ||
16 | + web.Router("/data/query-sets/copy", &controllers.QuerySetController{}, "Post:Copy") | ||
17 | + web.Router("/data/query-sets/dependency-graph", &controllers.QuerySetController{}, "Post:DependencyGraph") | ||
18 | + web.Router("/data/query-sets/move", &controllers.QuerySetController{}, "Post:Move") | ||
19 | + web.Router("/data/query-sets/rename", &controllers.QuerySetController{}, "Post:Rename") | ||
20 | + web.Router("/data/query-sets/search", &controllers.QuerySetController{}, "Post:SearchQuerySet") | ||
21 | +} |
@@ -14,8 +14,11 @@ func init() { | @@ -14,8 +14,11 @@ func init() { | ||
14 | web.Router("/data/tables/", &controllers.TableController{}, "Get:ListTable") | 14 | web.Router("/data/tables/", &controllers.TableController{}, "Get:ListTable") |
15 | web.Router("/data/tables/search", &controllers.TableController{}, "Post:Search") | 15 | web.Router("/data/tables/search", &controllers.TableController{}, "Post:Search") |
16 | web.Router("/data/tables/relation-graph", &controllers.TableController{}, "Post:RelationGraph") | 16 | web.Router("/data/tables/relation-graph", &controllers.TableController{}, "Post:RelationGraph") |
17 | + web.Router("/data/tables/apply-on", &controllers.TableController{}, "Post:ApplyOn") | ||
18 | + web.Router("/data/tables/valid-expr-sql", &controllers.TableController{}, "Post:ValidExprSql") | ||
17 | web.Router("/data/tables/search-appended-list", &controllers.TableController{}, "Post:SearchAppendedList") | 19 | web.Router("/data/tables/search-appended-list", &controllers.TableController{}, "Post:SearchAppendedList") |
18 | web.Router("/data/tables/search-sub-table-list", &controllers.TableController{}, "Post:SearchSubTableList") | 20 | web.Router("/data/tables/search-sub-table-list", &controllers.TableController{}, "Post:SearchSubTableList") |
21 | + web.Router("/data/tables/search-query-set-tables", &controllers.TableController{}, "Post:SearchQuerySetTables") | ||
19 | 22 | ||
20 | //web.Router("/data/tables/split-data-table", &controllers.TableController{}, "Post:SplitDataTable") | 23 | //web.Router("/data/tables/split-data-table", &controllers.TableController{}, "Post:SplitDataTable") |
21 | //web.Router("/data/tables/batch-edit-sub-table", &controllers.TableController{}, "Post:BatchEditSubTable") | 24 | //web.Router("/data/tables/batch-edit-sub-table", &controllers.TableController{}, "Post:BatchEditSubTable") |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("修改状态", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("修改状态", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "querySetId": "int", | ||
28 | + "status": "int", | ||
29 | + } | ||
30 | + httpExpect.POST("/query-sets/change-status"). | ||
31 | + WithJSON(body). | ||
32 | + Expect(). | ||
33 | + Status(http.StatusOK). | ||
34 | + JSON(). | ||
35 | + Object(). | ||
36 | + ContainsKey("code").ValueEqual("code", 0). | ||
37 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
38 | + ContainsKey("data").Value("data").Object() | ||
39 | + }) | ||
40 | + }) | ||
41 | + }) | ||
42 | + AfterEach(func() { | ||
43 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
44 | + Expect(err).NotTo(HaveOccurred()) | ||
45 | + }) | ||
46 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("移动", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("移动", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "flag": "int", | ||
28 | + "parentId": "int64", | ||
29 | + "name": "string", | ||
30 | + "querySetId": "int", | ||
31 | + } | ||
32 | + httpExpect.POST("/query-sets/copy"). | ||
33 | + WithJSON(body). | ||
34 | + Expect(). | ||
35 | + Status(http.StatusOK). | ||
36 | + JSON(). | ||
37 | + Object(). | ||
38 | + ContainsKey("code").ValueEqual("code", 0). | ||
39 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
40 | + ContainsKey("data").Value("data").Object() | ||
41 | + }) | ||
42 | + }) | ||
43 | + }) | ||
44 | + AfterEach(func() { | ||
45 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
46 | + Expect(err).NotTo(HaveOccurred()) | ||
47 | + }) | ||
48 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "net/http" | ||
5 | + | ||
6 | + "github.com/gavv/httpexpect" | ||
7 | + . "github.com/onsi/ginkgo" | ||
8 | + . "github.com/onsi/gomega" | ||
9 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
10 | +) | ||
11 | + | ||
12 | +var _ = Describe("创建查询集合服务", func() { | ||
13 | + Describe("提交数据创建查询集合服务", func() { | ||
14 | + Context("提交正确的新查询集合数据", func() { | ||
15 | + It("返回查询集合数据", func() { | ||
16 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
17 | + body := map[string]interface{}{ | ||
18 | + "type": "string", | ||
19 | + "flag": "int", | ||
20 | + "name": "string", | ||
21 | + "parentId": "int64", | ||
22 | + } | ||
23 | + httpExpect.POST("/query-sets/"). | ||
24 | + WithJSON(body). | ||
25 | + Expect(). | ||
26 | + Status(http.StatusOK). | ||
27 | + JSON(). | ||
28 | + Object(). | ||
29 | + ContainsKey("code").ValueEqual("code", 0). | ||
30 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
31 | + ContainsKey("data").Value("data").Object(). | ||
32 | + ContainsKey("querySetId").ValueNotEqual("querySetId", BeZero()) | ||
33 | + }) | ||
34 | + }) | ||
35 | + }) | ||
36 | + AfterEach(func() { | ||
37 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
38 | + Expect(err).NotTo(HaveOccurred()) | ||
39 | + }) | ||
40 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("依赖关系图", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("依赖关系图", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "querySetId": "int", | ||
28 | + } | ||
29 | + httpExpect.POST("/query-sets/dependency-ggraph"). | ||
30 | + WithJSON(body). | ||
31 | + Expect(). | ||
32 | + Status(http.StatusOK). | ||
33 | + JSON(). | ||
34 | + Object(). | ||
35 | + ContainsKey("code").ValueEqual("code", 0). | ||
36 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
37 | + ContainsKey("data").Value("data").Object() | ||
38 | + }) | ||
39 | + }) | ||
40 | + }) | ||
41 | + AfterEach(func() { | ||
42 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
43 | + Expect(err).NotTo(HaveOccurred()) | ||
44 | + }) | ||
45 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("返回查询集合服务", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("根据querySetId参数返回查询集合", func() { | ||
23 | + Context("传入有效的querySetId", func() { | ||
24 | + It("返回查询集合数据", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + httpExpect.GET("/query-sets/{Id}"). | ||
27 | + Expect(). | ||
28 | + Status(http.StatusOK). | ||
29 | + JSON(). | ||
30 | + Object(). | ||
31 | + ContainsKey("code").ValueEqual("code", 0). | ||
32 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
33 | + ContainsKey("data").Value("data").Object() | ||
34 | + }) | ||
35 | + }) | ||
36 | + }) | ||
37 | + AfterEach(func() { | ||
38 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
39 | + Expect(err).NotTo(HaveOccurred()) | ||
40 | + }) | ||
41 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("返回查询集合服务列表", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("根据参数返回查询集合列表", func() { | ||
23 | + Context("传入有效的参数", func() { | ||
24 | + It("返回查询集合数据列表", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + httpExpect.GET("/query-sets/"). | ||
27 | + WithQuery("offset", "int"). | ||
28 | + WithQuery("limit", "int"). | ||
29 | + Expect(). | ||
30 | + Status(http.StatusOK). | ||
31 | + JSON(). | ||
32 | + Object(). | ||
33 | + ContainsKey("code").ValueEqual("code", 0). | ||
34 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
35 | + ContainsKey("data").Value("data").Object(). | ||
36 | + ContainsKey("count").ValueEqual("count", 1). | ||
37 | + ContainsKey("querySets").Value("querySets").Array() | ||
38 | + }) | ||
39 | + }) | ||
40 | + }) | ||
41 | + AfterEach(func() { | ||
42 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
43 | + Expect(err).NotTo(HaveOccurred()) | ||
44 | + }) | ||
45 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("移动", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("移动", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "querySetId": "int", | ||
28 | + "parentId": "int64", | ||
29 | + } | ||
30 | + httpExpect.POST("/query-sets/move"). | ||
31 | + WithJSON(body). | ||
32 | + Expect(). | ||
33 | + Status(http.StatusOK). | ||
34 | + JSON(). | ||
35 | + Object(). | ||
36 | + ContainsKey("code").ValueEqual("code", 0). | ||
37 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
38 | + ContainsKey("data").Value("data").Object() | ||
39 | + }) | ||
40 | + }) | ||
41 | + }) | ||
42 | + AfterEach(func() { | ||
43 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
44 | + Expect(err).NotTo(HaveOccurred()) | ||
45 | + }) | ||
46 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "net/http" | ||
5 | + "net/http/httptest" | ||
6 | + "testing" | ||
7 | + | ||
8 | + "github.com/beego/beego/v2/server/web" | ||
9 | + . "github.com/onsi/ginkgo" | ||
10 | + . "github.com/onsi/gomega" | ||
11 | + _ "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application" | ||
12 | + _ "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
13 | + _ "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/port/beego" | ||
14 | +) | ||
15 | + | ||
16 | +func TestQuerySet(t *testing.T) { | ||
17 | + RegisterFailHandler(Fail) | ||
18 | + RunSpecs(t, "Beego Port QuerySet Correlations Test Case Suite") | ||
19 | +} | ||
20 | + | ||
21 | +var handler http.Handler | ||
22 | +var server *httptest.Server | ||
23 | + | ||
24 | +var _ = BeforeSuite(func() { | ||
25 | + handler = web.BeeApp.Handlers | ||
26 | + server = httptest.NewServer(handler) | ||
27 | +}) | ||
28 | + | ||
29 | +var _ = AfterSuite(func() { | ||
30 | + server.Close() | ||
31 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("移除查询集合服务", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("根据参数移除查询集合服务", func() { | ||
23 | + Context("传入有效的querySetId", func() { | ||
24 | + It("返回被移除查询集合的数据", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + httpExpect.DELETE("/query-sets/{Id}"). | ||
27 | + Expect(). | ||
28 | + Status(http.StatusOK). | ||
29 | + JSON(). | ||
30 | + Object(). | ||
31 | + ContainsKey("code").ValueEqual("code", 0). | ||
32 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
33 | + ContainsKey("data").Value("data").Object() | ||
34 | + }) | ||
35 | + }) | ||
36 | + }) | ||
37 | + AfterEach(func() { | ||
38 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
39 | + Expect(err).NotTo(HaveOccurred()) | ||
40 | + }) | ||
41 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("重命名", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("重命名", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "querySetId": "int", | ||
28 | + "name": "string", | ||
29 | + } | ||
30 | + httpExpect.POST("/query-sets/rename"). | ||
31 | + WithJSON(body). | ||
32 | + Expect(). | ||
33 | + Status(http.StatusOK). | ||
34 | + JSON(). | ||
35 | + Object(). | ||
36 | + ContainsKey("code").ValueEqual("code", 0). | ||
37 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
38 | + ContainsKey("data").Value("data").Object() | ||
39 | + }) | ||
40 | + }) | ||
41 | + }) | ||
42 | + AfterEach(func() { | ||
43 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
44 | + Expect(err).NotTo(HaveOccurred()) | ||
45 | + }) | ||
46 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("返回查询集合服务列表", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("返回查询集合服务列表", func() { | ||
23 | + Context("", func() { | ||
24 | + It("", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "offset": "int", | ||
28 | + "limit": "int", | ||
29 | + } | ||
30 | + httpExpect.POST("/query-sets/search"). | ||
31 | + WithJSON(body). | ||
32 | + Expect(). | ||
33 | + Status(http.StatusOK). | ||
34 | + JSON(). | ||
35 | + Object(). | ||
36 | + ContainsKey("code").ValueEqual("code", 0). | ||
37 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
38 | + ContainsKey("data").Value("data").Object() | ||
39 | + }) | ||
40 | + }) | ||
41 | + }) | ||
42 | + AfterEach(func() { | ||
43 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
44 | + Expect(err).NotTo(HaveOccurred()) | ||
45 | + }) | ||
46 | +}) |
1 | +package query_set | ||
2 | + | ||
3 | +import ( | ||
4 | + "github.com/go-pg/pg/v10" | ||
5 | + "net/http" | ||
6 | + | ||
7 | + "github.com/gavv/httpexpect" | ||
8 | + . "github.com/onsi/ginkgo" | ||
9 | + . "github.com/onsi/gomega" | ||
10 | + pG "gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg" | ||
11 | +) | ||
12 | + | ||
13 | +var _ = Describe("更新查询集合服务", func() { | ||
14 | + var querySetId int64 | ||
15 | + BeforeEach(func() { | ||
16 | + _, err := pG.DB.QueryOne( | ||
17 | + pg.Scan(&querySetId), | ||
18 | + "INSERT INTO query_sets (query_set_id, type, flag, name, pin_name, parent_id, status, query_set_info, query_components, sort, created_at, updated_at, deleted_at, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING query_set_id", | ||
19 | + "testQuerySetId", "testType", "testFlag", "testName", "testPinName", "testParentId", "testStatus", "testQuerySetInfo", "testQueryComponents", "testSort", "testCreatedAt", "testUpdatedAt", "testDeletedAt", "testContext") | ||
20 | + Expect(err).NotTo(HaveOccurred()) | ||
21 | + }) | ||
22 | + Describe("提交数据更新查询集合服务", func() { | ||
23 | + Context("提交正确的查询集合数据", func() { | ||
24 | + It("返回更新后的查询集合数据", func() { | ||
25 | + httpExpect := httpexpect.New(GinkgoT(), server.URL) | ||
26 | + body := map[string]interface{}{ | ||
27 | + "querySetId": "int", | ||
28 | + } | ||
29 | + httpExpect.PUT("/query-sets/{Id}"). | ||
30 | + WithJSON(body). | ||
31 | + Expect(). | ||
32 | + Status(http.StatusOK). | ||
33 | + JSON(). | ||
34 | + Object(). | ||
35 | + ContainsKey("code").ValueEqual("code", 0). | ||
36 | + ContainsKey("msg").ValueEqual("msg", "ok"). | ||
37 | + ContainsKey("data").Value("data").Object(). | ||
38 | + ContainsKey("querySetId").ValueEqual("querySetId", querySetId) | ||
39 | + }) | ||
40 | + }) | ||
41 | + }) | ||
42 | + AfterEach(func() { | ||
43 | + _, err := pG.DB.Exec("DELETE FROM query_sets WHERE true") | ||
44 | + Expect(err).NotTo(HaveOccurred()) | ||
45 | + }) | ||
46 | +}) |
-
请 注册 或 登录 后发表评论