Rename cavage singing func, add import for server

storage-new/dbgen/remote_servers.gen.go

@@ -31,10 +31,39 @@ func newRemoteServer(db *gorm.DB, opts ...gen.DOOption) remoteServer {
 	_remoteServer.UpdatedAt = field.NewTime(tableName, "updated_at")
 	_remoteServer.DeletedAt = field.NewField(tableName, "deleted_at")
 	_remoteServer.ServerType = field.NewField(tableName, "server_type")
+	_remoteServer.SpecificType = field.NewString(tableName, "specific_type")
+	_remoteServer.Version = field.NewString(tableName, "version")
 	_remoteServer.Domain = field.NewString(tableName, "domain")
 	_remoteServer.Name = field.NewString(tableName, "name")
 	_remoteServer.IconId = field.NewField(tableName, "icon_id")
 	_remoteServer.IsSelf = field.NewBool(tableName, "is_self")
+	_remoteServer.Metadata = remoteServerHasManyMetadata{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Metadata", "models.RemoteServerMetadata"),
+		RemoteServer: struct {
+			field.RelationField
+			Icon struct {
+				field.RelationField
+			}
+			Metadata struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Metadata.RemoteServer", "models.RemoteServer"),
+			Icon: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Metadata.RemoteServer.Icon", "models.MediaMetadata"),
+			},
+			Metadata: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Metadata.RemoteServer.Metadata", "models.RemoteServerMetadata"),
+			},
+		},
+	}
+
 	_remoteServer.Icon = remoteServerBelongsToIcon{
 		db: db.Session(&gorm.Session{}),
 
@@ -49,17 +78,21 @@ func newRemoteServer(db *gorm.DB, opts ...gen.DOOption) remoteServer {
 type remoteServer struct {
 	remoteServerDo
 
-	ALL        field.Asterisk
-	ID         field.Uint
-	CreatedAt  field.Time
-	UpdatedAt  field.Time
-	DeletedAt  field.Field
-	ServerType field.Field
-	Domain     field.String
-	Name       field.String
-	IconId     field.Field
-	IsSelf     field.Bool
-	Icon       remoteServerBelongsToIcon
+	ALL          field.Asterisk
+	ID           field.Uint
+	CreatedAt    field.Time
+	UpdatedAt    field.Time
+	DeletedAt    field.Field
+	ServerType   field.Field
+	SpecificType field.String
+	Version      field.String
+	Domain       field.String
+	Name         field.String
+	IconId       field.Field
+	IsSelf       field.Bool
+	Metadata     remoteServerHasManyMetadata
+
+	Icon remoteServerBelongsToIcon
 
 	fieldMap map[string]field.Expr
 }
@@ -81,6 +114,8 @@ func (r *remoteServer) updateTableName(table string) *remoteServer {
 	r.UpdatedAt = field.NewTime(table, "updated_at")
 	r.DeletedAt = field.NewField(table, "deleted_at")
 	r.ServerType = field.NewField(table, "server_type")
+	r.SpecificType = field.NewString(table, "specific_type")
+	r.Version = field.NewString(table, "version")
 	r.Domain = field.NewString(table, "domain")
 	r.Name = field.NewString(table, "name")
 	r.IconId = field.NewField(table, "icon_id")
@@ -101,12 +136,14 @@ func (r *remoteServer) GetFieldByName(fieldName string) (field.OrderExpr, bool)
 }
 
 func (r *remoteServer) fillFieldMap() {
-	r.fieldMap = make(map[string]field.Expr, 10)
+	r.fieldMap = make(map[string]field.Expr, 13)
 	r.fieldMap["id"] = r.ID
 	r.fieldMap["created_at"] = r.CreatedAt
 	r.fieldMap["updated_at"] = r.UpdatedAt
 	r.fieldMap["deleted_at"] = r.DeletedAt
 	r.fieldMap["server_type"] = r.ServerType
+	r.fieldMap["specific_type"] = r.SpecificType
+	r.fieldMap["version"] = r.Version
 	r.fieldMap["domain"] = r.Domain
 	r.fieldMap["name"] = r.Name
 	r.fieldMap["icon_id"] = r.IconId
@@ -124,6 +161,87 @@ func (r remoteServer) replaceDB(db *gorm.DB) remoteServer {
 	return r
 }
 
+type remoteServerHasManyMetadata struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	RemoteServer struct {
+		field.RelationField
+		Icon struct {
+			field.RelationField
+		}
+		Metadata struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a remoteServerHasManyMetadata) Where(conds ...field.Expr) *remoteServerHasManyMetadata {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a remoteServerHasManyMetadata) WithContext(ctx context.Context) *remoteServerHasManyMetadata {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a remoteServerHasManyMetadata) Session(session *gorm.Session) *remoteServerHasManyMetadata {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a remoteServerHasManyMetadata) Model(m *models.RemoteServer) *remoteServerHasManyMetadataTx {
+	return &remoteServerHasManyMetadataTx{a.db.Model(m).Association(a.Name())}
+}
+
+type remoteServerHasManyMetadataTx struct{ tx *gorm.Association }
+
+func (a remoteServerHasManyMetadataTx) Find() (result []*models.RemoteServerMetadata, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a remoteServerHasManyMetadataTx) Append(values ...*models.RemoteServerMetadata) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a remoteServerHasManyMetadataTx) Replace(values ...*models.RemoteServerMetadata) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a remoteServerHasManyMetadataTx) Delete(values ...*models.RemoteServerMetadata) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a remoteServerHasManyMetadataTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a remoteServerHasManyMetadataTx) Count() int64 {
+	return a.tx.Count()
+}
+
 type remoteServerBelongsToIcon struct {
 	db *gorm.DB