优化表结构，重构模型，重新实现基于白银网关的提取节点流程

web/queries/proxy.gen.go

@@ -28,19 +28,79 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
 	tableName := _proxy.proxyDo.TableName()
 	_proxy.ALL = field.NewAsterisk(tableName)
 	_proxy.ID = field.NewInt32(tableName, "id")
-	_proxy.Version = field.NewInt32(tableName, "version")
-	_proxy.Name = field.NewString(tableName, "name")
-	_proxy.Host = field.NewString(tableName, "host")
-	_proxy.Secret = field.NewString(tableName, "secret")
-	_proxy.Type = field.NewInt32(tableName, "type")
-	_proxy.Status = field.NewInt32(tableName, "status")
-	_proxy.CreatedAt = field.NewField(tableName, "created_at")
-	_proxy.UpdatedAt = field.NewField(tableName, "updated_at")
+	_proxy.CreatedAt = field.NewTime(tableName, "created_at")
+	_proxy.UpdatedAt = field.NewTime(tableName, "updated_at")
 	_proxy.DeletedAt = field.NewField(tableName, "deleted_at")
-	_proxy.Edges = proxyHasManyEdges{
+	_proxy.Version = field.NewInt32(tableName, "version")
+	_proxy.Mac = field.NewString(tableName, "mac")
+	_proxy.IP = field.NewField(tableName, "ip")
+	_proxy.Secret = field.NewString(tableName, "secret")
+	_proxy.Type = field.NewInt(tableName, "type")
+	_proxy.Status = field.NewInt(tableName, "status")
+	_proxy.Channels = proxyHasManyChannels{
 		db: db.Session(&gorm.Session{}),
 
-		RelationField: field.NewRelation("Edges", "models.Edge"),
+		RelationField: field.NewRelation("Channels", "models.Channel"),
+		User: struct {
+			field.RelationField
+			Admin struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Channels.User", "models.User"),
+			Admin: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.User.Admin", "models.Admin"),
+			},
+		},
+		Resource: struct {
+			field.RelationField
+			User struct {
+				field.RelationField
+			}
+			Short struct {
+				field.RelationField
+			}
+			Long struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Channels.Resource", "models.Resource"),
+			User: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.Resource.User", "models.User"),
+			},
+			Short: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.Resource.Short", "models.ResourceShort"),
+			},
+			Long: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.Resource.Long", "models.ResourceLong"),
+			},
+		},
+		Proxy: struct {
+			field.RelationField
+			Channels struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Channels.Proxy", "models.Proxy"),
+			Channels: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Channels.Proxy.Channels", "models.Channel"),
+			},
+		},
+		Edge: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Channels.Edge", "models.Edge"),
+		},
 	}
 
 	_proxy.fillFieldMap()
@@ -52,17 +112,17 @@ type proxy struct {
 	proxyDo
 
 	ALL       field.Asterisk
-	ID        field.Int32  // 代理服务ID
-	Version   field.Int32  // 代理服务版本
-	Name      field.String // 代理服务名称
-	Host      field.String // 代理服务地址
-	Secret    field.String // 代理服务密钥
-	Type      field.Int32  // 代理服务类型：1-三方，2-自有
-	Status    field.Int32  // 代理服务状态：0-离线，1-在线
-	CreatedAt field.Field  // 创建时间
-	UpdatedAt field.Field  // 更新时间
-	DeletedAt field.Field  // 删除时间
-	Edges     proxyHasManyEdges
+	ID        field.Int32
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+	Version   field.Int32
+	Mac       field.String
+	IP        field.Field
+	Secret    field.String
+	Type      field.Int
+	Status    field.Int
+	Channels  proxyHasManyChannels
 
 	fieldMap map[string]field.Expr
 }
@@ -80,15 +140,15 @@ func (p proxy) As(alias string) *proxy {
 func (p *proxy) updateTableName(table string) *proxy {
 	p.ALL = field.NewAsterisk(table)
 	p.ID = field.NewInt32(table, "id")
-	p.Version = field.NewInt32(table, "version")
-	p.Name = field.NewString(table, "name")
-	p.Host = field.NewString(table, "host")
-	p.Secret = field.NewString(table, "secret")
-	p.Type = field.NewInt32(table, "type")
-	p.Status = field.NewInt32(table, "status")
-	p.CreatedAt = field.NewField(table, "created_at")
-	p.UpdatedAt = field.NewField(table, "updated_at")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
 	p.DeletedAt = field.NewField(table, "deleted_at")
+	p.Version = field.NewInt32(table, "version")
+	p.Mac = field.NewString(table, "mac")
+	p.IP = field.NewField(table, "ip")
+	p.Secret = field.NewString(table, "secret")
+	p.Type = field.NewInt(table, "type")
+	p.Status = field.NewInt(table, "status")
 
 	p.fillFieldMap()
 
@@ -107,38 +167,66 @@ func (p *proxy) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 func (p *proxy) fillFieldMap() {
 	p.fieldMap = make(map[string]field.Expr, 11)
 	p.fieldMap["id"] = p.ID
-	p.fieldMap["version"] = p.Version
-	p.fieldMap["name"] = p.Name
-	p.fieldMap["host"] = p.Host
-	p.fieldMap["secret"] = p.Secret
-	p.fieldMap["type"] = p.Type
-	p.fieldMap["status"] = p.Status
 	p.fieldMap["created_at"] = p.CreatedAt
 	p.fieldMap["updated_at"] = p.UpdatedAt
 	p.fieldMap["deleted_at"] = p.DeletedAt
+	p.fieldMap["version"] = p.Version
+	p.fieldMap["mac"] = p.Mac
+	p.fieldMap["ip"] = p.IP
+	p.fieldMap["secret"] = p.Secret
+	p.fieldMap["type"] = p.Type
+	p.fieldMap["status"] = p.Status
 
 }
 
 func (p proxy) clone(db *gorm.DB) proxy {
 	p.proxyDo.ReplaceConnPool(db.Statement.ConnPool)
-	p.Edges.db = db.Session(&gorm.Session{Initialized: true})
-	p.Edges.db.Statement.ConnPool = db.Statement.ConnPool
+	p.Channels.db = db.Session(&gorm.Session{Initialized: true})
+	p.Channels.db.Statement.ConnPool = db.Statement.ConnPool
 	return p
 }
 
 func (p proxy) replaceDB(db *gorm.DB) proxy {
 	p.proxyDo.ReplaceDB(db)
-	p.Edges.db = db.Session(&gorm.Session{})
+	p.Channels.db = db.Session(&gorm.Session{})
 	return p
 }
 
-type proxyHasManyEdges struct {
+type proxyHasManyChannels struct {
 	db *gorm.DB
 
 	field.RelationField
+
+	User struct {
+		field.RelationField
+		Admin struct {
+			field.RelationField
+		}
+	}
+	Resource struct {
+		field.RelationField
+		User struct {
+			field.RelationField
+		}
+		Short struct {
+			field.RelationField
+		}
+		Long struct {
+			field.RelationField
+		}
+	}
+	Proxy struct {
+		field.RelationField
+		Channels struct {
+			field.RelationField
+		}
+	}
+	Edge struct {
+		field.RelationField
+	}
 }
 
-func (a proxyHasManyEdges) Where(conds ...field.Expr) *proxyHasManyEdges {
+func (a proxyHasManyChannels) Where(conds ...field.Expr) *proxyHasManyChannels {
 	if len(conds) == 0 {
 		return &a
 	}
@@ -151,32 +239,32 @@ func (a proxyHasManyEdges) Where(conds ...field.Expr) *proxyHasManyEdges {
 	return &a
 }
 
-func (a proxyHasManyEdges) WithContext(ctx context.Context) *proxyHasManyEdges {
+func (a proxyHasManyChannels) WithContext(ctx context.Context) *proxyHasManyChannels {
 	a.db = a.db.WithContext(ctx)
 	return &a
 }
 
-func (a proxyHasManyEdges) Session(session *gorm.Session) *proxyHasManyEdges {
+func (a proxyHasManyChannels) Session(session *gorm.Session) *proxyHasManyChannels {
 	a.db = a.db.Session(session)
 	return &a
 }
 
-func (a proxyHasManyEdges) Model(m *models.Proxy) *proxyHasManyEdgesTx {
-	return &proxyHasManyEdgesTx{a.db.Model(m).Association(a.Name())}
+func (a proxyHasManyChannels) Model(m *models.Proxy) *proxyHasManyChannelsTx {
+	return &proxyHasManyChannelsTx{a.db.Model(m).Association(a.Name())}
 }
 
-func (a proxyHasManyEdges) Unscoped() *proxyHasManyEdges {
+func (a proxyHasManyChannels) Unscoped() *proxyHasManyChannels {
 	a.db = a.db.Unscoped()
 	return &a
 }
 
-type proxyHasManyEdgesTx struct{ tx *gorm.Association }
+type proxyHasManyChannelsTx struct{ tx *gorm.Association }
 
-func (a proxyHasManyEdgesTx) Find() (result []*models.Edge, err error) {
+func (a proxyHasManyChannelsTx) Find() (result []*models.Channel, err error) {
 	return result, a.tx.Find(&result)
 }
 
-func (a proxyHasManyEdgesTx) Append(values ...*models.Edge) (err error) {
+func (a proxyHasManyChannelsTx) Append(values ...*models.Channel) (err error) {
 	targetValues := make([]interface{}, len(values))
 	for i, v := range values {
 		targetValues[i] = v
@@ -184,7 +272,7 @@ func (a proxyHasManyEdgesTx) Append(values ...*models.Edge) (err error) {
 	return a.tx.Append(targetValues...)
 }
 
-func (a proxyHasManyEdgesTx) Replace(values ...*models.Edge) (err error) {
+func (a proxyHasManyChannelsTx) Replace(values ...*models.Channel) (err error) {
 	targetValues := make([]interface{}, len(values))
 	for i, v := range values {
 		targetValues[i] = v
@@ -192,7 +280,7 @@ func (a proxyHasManyEdgesTx) Replace(values ...*models.Edge) (err error) {
 	return a.tx.Replace(targetValues...)
 }
 
-func (a proxyHasManyEdgesTx) Delete(values ...*models.Edge) (err error) {
+func (a proxyHasManyChannelsTx) Delete(values ...*models.Channel) (err error) {
 	targetValues := make([]interface{}, len(values))
 	for i, v := range values {
 		targetValues[i] = v
@@ -200,15 +288,15 @@ func (a proxyHasManyEdgesTx) Delete(values ...*models.Edge) (err error) {
 	return a.tx.Delete(targetValues...)
 }
 
-func (a proxyHasManyEdgesTx) Clear() error {
+func (a proxyHasManyChannelsTx) Clear() error {
 	return a.tx.Clear()
 }
 
-func (a proxyHasManyEdgesTx) Count() int64 {
+func (a proxyHasManyChannelsTx) Count() int64 {
 	return a.tx.Count()
 }
 
-func (a proxyHasManyEdgesTx) Unscoped() *proxyHasManyEdgesTx {
+func (a proxyHasManyChannelsTx) Unscoped() *proxyHasManyChannelsTx {
 	a.tx = a.tx.Unscoped()
 	return &a
 }