-
Notifications
You must be signed in to change notification settings - Fork 102
/
model.go
159 lines (135 loc) · 3.82 KB
/
model.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
147
148
149
150
151
152
153
154
155
156
157
158
159
/*
Copyright 2021 The KubeVela Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package model
import (
"encoding/json"
"fmt"
"reflect"
"time"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/klog/v2"
"sigs.k8s.io/yaml"
)
var tableNamePrefix = "vela_"
var registeredModels = map[string]Interface{}
// Interface model interface
type Interface interface {
TableName() string
ShortTableName() string
}
// RegisterModel register model
func RegisterModel(models ...Interface) {
for _, model := range models {
if _, exist := registeredModels[model.TableName()]; exist {
panic(fmt.Errorf("model table name %s conflict", model.TableName()))
}
registeredModels[model.TableName()] = model
}
}
// GetRegisterModels will return the register models
func GetRegisterModels() map[string]Interface {
return registeredModels
}
// JSONStruct json struct, same with runtime.RawExtension
type JSONStruct map[string]interface{}
// NewJSONStruct new json struct from runtime.RawExtension
func NewJSONStruct(raw *runtime.RawExtension) (*JSONStruct, error) {
if raw == nil || raw.Raw == nil {
return nil, nil
}
var data JSONStruct
err := json.Unmarshal(raw.Raw, &data)
if err != nil {
return nil, fmt.Errorf("parse raw data failure %w", err)
}
return &data, nil
}
// NewJSONStructByString new json struct from string
func NewJSONStructByString(source string) (*JSONStruct, error) {
if source == "" {
return nil, nil
}
var data JSONStruct
err := json.Unmarshal([]byte(source), &data)
if err != nil {
return nil, fmt.Errorf("parse raw data failure %w", err)
}
return &data, nil
}
// NewJSONStructByStruct new json struct from struct object
func NewJSONStructByStruct(object interface{}) (*JSONStruct, error) {
if object == nil {
return nil, nil
}
var data JSONStruct
out, err := yaml.Marshal(object)
if err != nil {
return nil, fmt.Errorf("marshal object data failure %w", err)
}
if err := yaml.Unmarshal(out, &data); err != nil {
return nil, fmt.Errorf("unmarshal object data failure %w", err)
}
return &data, nil
}
// JSON Encoded as a JSON string
func (j *JSONStruct) JSON() string {
b, err := json.Marshal(j)
if err != nil {
klog.Errorf("json marshal failure %s", err.Error())
}
return string(b)
}
// Properties return the map
func (j *JSONStruct) Properties() map[string]interface{} {
return *j
}
// RawExtension Encoded as a RawExtension
func (j *JSONStruct) RawExtension() *runtime.RawExtension {
yamlByte, err := yaml.Marshal(j)
if err != nil {
klog.Errorf("yaml marshal failure %s", err.Error())
return nil
}
b, err := yaml.YAMLToJSON(yamlByte)
if err != nil {
klog.Errorf("yaml to json failure %s", err.Error())
return nil
}
if len(b) == 0 || string(b) == "null" {
return nil
}
return &runtime.RawExtension{Raw: b}
}
// BaseModel common model
type BaseModel struct {
CreateTime time.Time `json:"createTime"`
UpdateTime time.Time `json:"updateTime"`
}
// SetCreateTime set create time
func (m *BaseModel) SetCreateTime(time time.Time) {
m.CreateTime = time
}
// SetUpdateTime set update time
func (m *BaseModel) SetUpdateTime(time time.Time) {
m.UpdateTime = time
}
func deepCopy(src interface{}) interface{} {
dst := reflect.New(reflect.TypeOf(src).Elem())
val := reflect.ValueOf(src).Elem()
nVal := dst.Elem()
for i := 0; i < val.NumField(); i++ {
nvField := nVal.Field(i)
nvField.Set(val.Field(i))
}
return dst.Interface()
}