/
errors.go
146 lines (119 loc) · 4.09 KB
/
errors.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package gormx
import (
"github.com/go-kratos/kratos/v2/errors"
"gorm.io/gorm"
)
const errorAfterName = "error:after"
type GormError struct{}
func NewGormError() gorm.Plugin {
return &GormError{}
}
func (p *GormError) Name() string {
return "__gorm_error"
}
func (p *GormError) Initialize(db *gorm.DB) error {
// 结束后
db.Callback().Create().After("gorm:error_create").Register(errorAfterName, p.after)
db.Callback().Query().After("gorm:error_query").Register(errorAfterName, p.after)
db.Callback().Delete().After("gorm:error_delete").Register(errorAfterName, p.after)
db.Callback().Update().After("gorm:error_update").Register(errorAfterName, p.after)
db.Callback().Row().After("gorm:error_row").Register(errorAfterName, p.after)
db.Callback().Raw().After("gorm:error_raw").Register(errorAfterName, p.after)
return nil
}
func (p *GormError) after(db *gorm.DB) {
if db.Error != nil {
db.Error = WrapGormError(db.Error)
}
}
// WrapGormError 转换错误
func WrapGormError(err error) error {
if err == nil {
return nil
}
if errors.Is(err, gorm.ErrRecordNotFound) {
return GormErrRecordNotFound(err)
}
if errors.Is(err, gorm.ErrInvalidTransaction) {
return ErrInvalidTransaction(err)
}
if errors.Is(err, gorm.ErrNotImplemented) {
return ErrNotImplemented(err)
}
if errors.Is(err, gorm.ErrMissingWhereClause) {
return ErrMissingWhereClause(err)
}
return err
}
//////////////////////////////////////////////////////////////////////////////////////////gorm
// GormErrRecordNotFound 找不到记录
func GormErrRecordNotFound(err error) error {
return errors.InternalServer("GormErrRecordNotFound", err.Error())
}
func IsGormErrRecordNotFound(err error) bool {
se := errors.FromError(err)
return se.Reason == "GormErrRecordNotFound" && se.Code == 500
}
func ErrInvalidTransaction(err error) error {
return errors.InternalServer("ErrInvalidTransaction", err.Error())
}
func IsErrInvalidTransaction(err error) bool {
se := errors.FromError(err)
return se.Reason == "ErrInvalidTransaction" && se.Code == 500
}
// ErrNotImplemented not implemented
func ErrNotImplemented(err error) error {
return errors.InternalServer("ErrNotImplemented", err.Error())
}
// ErrMissingWhereClause missing where clause
func ErrMissingWhereClause(err error) error {
return errors.InternalServer("ErrMissingWhereClause", err.Error())
}
// ErrUnsupportedRelation unsupported relations
func ErrUnsupportedRelation(err error) error {
return errors.InternalServer("ErrUnsupportedRelation", err.Error())
}
// ErrPrimaryKeyRequired primary keys required
func ErrPrimaryKeyRequired(err error) error {
return errors.InternalServer("ErrPrimaryKeyRequired", err.Error())
}
// ErrModelValueRequired model value required
func ErrModelValueRequired(err error) error {
return errors.InternalServer("ErrModelValueRequired", err.Error())
}
// ErrInvalidData unsupported data
func ErrInvalidData(err error) error {
return errors.InternalServer("ErrInvalidData", err.Error())
}
// ErrUnsupportedDriver unsupported driver
func ErrUnsupportedDriver(err error) error {
return errors.InternalServer("ErrUnsupportedDriver", err.Error())
}
// ErrRegistered registered
func ErrRegistered(err error) error {
return errors.InternalServer("ErrRegistered", err.Error())
}
// ErrInvalidField invalid field
func ErrInvalidField(err error) error {
return errors.InternalServer("ErrInvalidField", err.Error())
}
// ErrEmptySlice empty slice found
func ErrEmptySlice(err error) error {
return errors.InternalServer("ErrEmptySlice", err.Error())
}
// ErrDryRunModeUnsupported dry run mode unsupported
func ErrDryRunModeUnsupported(err error) error {
return errors.InternalServer("ErrDryRunModeUnsupported", err.Error())
}
// ErrInvalidDB invalid db
func ErrInvalidDB(err error) error {
return errors.InternalServer("ErrInvalidDB", err.Error())
}
// ErrInvalidValue invalid value
func ErrInvalidValue(err error) error {
return errors.InternalServer("ErrInvalidValue", err.Error())
}
// ErrInvalidValueOfLength invalid values do not match length
func ErrInvalidValueOfLength(err error) error {
return errors.InternalServer("ErrInvalidValueOfLength", err.Error())
}