From aba381e7f8e4def37b56e92c188cb284a0d9bcda Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 24 Jan 2026 01:00:42 +0000 Subject: [PATCH] Migrate webhook.go from XORM to GORM Co-authored-by: unknwon <2946214+unknwon@users.noreply.github.com> --- internal/database/webhook.go | 202 ++++++++++++++++------------------- 1 file changed, 91 insertions(+), 111 deletions(-) diff --git a/internal/database/webhook.go b/internal/database/webhook.go index 250e99b0a..bebd030b4 100644 --- a/internal/database/webhook.go +++ b/internal/database/webhook.go @@ -14,8 +14,8 @@ import ( "github.com/cockroachdb/errors" jsoniter "github.com/json-iterator/go" gouuid "github.com/satori/go.uuid" + "gorm.io/gorm" log "unknwon.dev/clog/v2" - "xorm.io/xorm" api "github.com/gogs/go-gogs-client" @@ -95,45 +95,42 @@ type Webhook struct { ID int64 RepoID int64 OrgID int64 - URL string `xorm:"url TEXT"` + URL string `gorm:"type:text;column:url"` ContentType HookContentType - Secret string `xorm:"TEXT"` - Events string `xorm:"TEXT"` - *HookEvent `xorm:"-"` // LEGACY [1.0]: Cannot ignore JSON (i.e. json:"-") here, it breaks old backup archive - IsSSL bool `xorm:"is_ssl"` + Secret string `gorm:"type:text"` + Events string `gorm:"type:text"` + *HookEvent `gorm:"-"` // LEGACY [1.0]: Cannot ignore JSON (i.e. json:"-") here, it breaks old backup archive + IsSSL bool `gorm:"column:is_ssl"` IsActive bool HookTaskType HookTaskType - Meta string `xorm:"TEXT"` // store hook-specific attributes + Meta string `gorm:"type:text"` // store hook-specific attributes LastStatus HookStatus // Last delivery status - Created time.Time `xorm:"-" json:"-" gorm:"-"` + Created time.Time `gorm:"-" json:"-"` CreatedUnix int64 - Updated time.Time `xorm:"-" json:"-" gorm:"-"` + Updated time.Time `gorm:"-" json:"-"` UpdatedUnix int64 } -func (w *Webhook) BeforeInsert() { - w.CreatedUnix = time.Now().Unix() +func (w *Webhook) BeforeCreate(tx *gorm.DB) error { + w.CreatedUnix = tx.NowFunc().Unix() w.UpdatedUnix = w.CreatedUnix + return nil } -func (w *Webhook) BeforeUpdate() { - w.UpdatedUnix = time.Now().Unix() +func (w *Webhook) BeforeUpdate(tx *gorm.DB) error { + w.UpdatedUnix = tx.NowFunc().Unix() + return nil } -func (w *Webhook) AfterSet(colName string, _ xorm.Cell) { - var err error - switch colName { - case "events": - w.HookEvent = &HookEvent{} - if err = jsoniter.Unmarshal([]byte(w.Events), w.HookEvent); err != nil { - log.Error("Unmarshal [%d]: %v", w.ID, err) - } - case "created_unix": - w.Created = time.Unix(w.CreatedUnix, 0).Local() - case "updated_unix": - w.Updated = time.Unix(w.UpdatedUnix, 0).Local() +func (w *Webhook) AfterFind(tx *gorm.DB) error { + w.HookEvent = &HookEvent{} + if err := jsoniter.Unmarshal([]byte(w.Events), w.HookEvent); err != nil { + log.Error("Unmarshal [%d]: %v", w.ID, err) } + w.Created = time.Unix(w.CreatedUnix, 0).Local() + w.Updated = time.Unix(w.UpdatedUnix, 0).Local() + return nil } func (w *Webhook) SlackMeta() *SlackMeta { @@ -231,8 +228,7 @@ func (w *Webhook) EventsArray() []string { // CreateWebhook creates a new web hook. func CreateWebhook(w *Webhook) error { - _, err := x.Insert(w) - return err + return db.Create(w).Error } var _ errutil.NotFound = (*ErrWebhookNotExist)(nil) @@ -257,11 +253,12 @@ func (ErrWebhookNotExist) NotFound() bool { // getWebhook uses argument bean as query condition, // ID must be specified and do not assign unnecessary fields. func getWebhook(bean *Webhook) (*Webhook, error) { - has, err := x.Get(bean) + err := db.Where(bean).First(bean).Error if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, ErrWebhookNotExist{args: map[string]any{"webhookID": bean.ID}} + } return nil, err - } else if !has { - return nil, ErrWebhookNotExist{args: map[string]any{"webhookID": bean.ID}} } return bean, nil } @@ -292,39 +289,34 @@ func GetWebhookByOrgID(orgID, id int64) (*Webhook, error) { } // getActiveWebhooksByRepoID returns all active webhooks of repository. -func getActiveWebhooksByRepoID(e Engine, repoID int64) ([]*Webhook, error) { +func getActiveWebhooksByRepoID(tx *gorm.DB, repoID int64) ([]*Webhook, error) { webhooks := make([]*Webhook, 0, 5) - return webhooks, e.Where("repo_id = ?", repoID).And("is_active = ?", true).Find(&webhooks) + return webhooks, tx.Where("repo_id = ? AND is_active = ?", repoID, true).Find(&webhooks).Error } // GetWebhooksByRepoID returns all webhooks of a repository. func GetWebhooksByRepoID(repoID int64) ([]*Webhook, error) { webhooks := make([]*Webhook, 0, 5) - return webhooks, x.Find(&webhooks, &Webhook{RepoID: repoID}) + return webhooks, db.Where("repo_id = ?", repoID).Find(&webhooks).Error } // UpdateWebhook updates information of webhook. func UpdateWebhook(w *Webhook) error { - _, err := x.Id(w.ID).AllCols().Update(w) - return err + return db.Model(w).Where("id = ?", w.ID).Updates(w).Error } // deleteWebhook uses argument bean as query condition, // ID must be specified and do not assign unnecessary fields. -func deleteWebhook(bean *Webhook) (err error) { - sess := x.NewSession() - defer sess.Close() - if err = sess.Begin(); err != nil { - return err - } - - if _, err = sess.Delete(bean); err != nil { - return err - } else if _, err = sess.Delete(&HookTask{HookID: bean.ID}); err != nil { - return err - } - - return sess.Commit() +func deleteWebhook(bean *Webhook) error { + return db.Transaction(func(tx *gorm.DB) error { + if err := tx.Delete(bean).Error; err != nil { + return err + } + if err := tx.Where("hook_id = ?", bean.ID).Delete(&HookTask{}).Error; err != nil { + return err + } + return nil + }) } // DeleteWebhookOfRepoByID deletes webhook of repository by given ID. @@ -345,14 +337,14 @@ func DeleteWebhookOfOrgByID(orgID, id int64) error { // GetWebhooksByOrgID returns all webhooks for an organization. func GetWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) { - err = x.Find(&ws, &Webhook{OrgID: orgID}) + err = db.Where("org_id = ?", orgID).Find(&ws).Error return ws, err } // getActiveWebhooksByOrgID returns all active webhooks for an organization. -func getActiveWebhooksByOrgID(e Engine, orgID int64) ([]*Webhook, error) { +func getActiveWebhooksByOrgID(tx *gorm.DB, orgID int64) ([]*Webhook, error) { ws := make([]*Webhook, 0, 3) - return ws, e.Where("org_id=?", orgID).And("is_active=?", true).Find(&ws) + return ws, tx.Where("org_id = ? AND is_active = ?", orgID, true).Find(&ws).Error } // ___ ___ __ ___________ __ @@ -431,64 +423,56 @@ type HookResponse struct { // HookTask represents a hook task. type HookTask struct { ID int64 - RepoID int64 `xorm:"INDEX"` + RepoID int64 `gorm:"index"` HookID int64 UUID string Type HookTaskType - URL string `xorm:"TEXT"` - Signature string `xorm:"TEXT"` - api.Payloader `xorm:"-" json:"-" gorm:"-"` - PayloadContent string `xorm:"TEXT"` + URL string `gorm:"type:text"` + Signature string `gorm:"type:text"` + api.Payloader `gorm:"-" json:"-"` + PayloadContent string `gorm:"type:text"` ContentType HookContentType EventType HookEventType IsSSL bool IsDelivered bool Delivered int64 - DeliveredString string `xorm:"-" json:"-" gorm:"-"` + DeliveredString string `gorm:"-" json:"-"` // History info. IsSucceed bool - RequestContent string `xorm:"TEXT"` - RequestInfo *HookRequest `xorm:"-" json:"-" gorm:"-"` - ResponseContent string `xorm:"TEXT"` - ResponseInfo *HookResponse `xorm:"-" json:"-" gorm:"-"` + RequestContent string `gorm:"type:text"` + RequestInfo *HookRequest `gorm:"-" json:"-"` + ResponseContent string `gorm:"type:text"` + ResponseInfo *HookResponse `gorm:"-" json:"-"` } -func (t *HookTask) BeforeUpdate() { +func (t *HookTask) BeforeUpdate(tx *gorm.DB) error { if t.RequestInfo != nil { t.RequestContent = t.ToJSON(t.RequestInfo) } if t.ResponseInfo != nil { t.ResponseContent = t.ToJSON(t.ResponseInfo) } + return nil } -func (t *HookTask) AfterSet(colName string, _ xorm.Cell) { - var err error - switch colName { - case "delivered": - t.DeliveredString = time.Unix(0, t.Delivered).Format("2006-01-02 15:04:05 MST") - - case "request_content": - if t.RequestContent == "" { - return - } +func (t *HookTask) AfterFind(tx *gorm.DB) error { + t.DeliveredString = time.Unix(0, t.Delivered).Format("2006-01-02 15:04:05 MST") + if t.RequestContent != "" { t.RequestInfo = &HookRequest{} - if err = jsoniter.Unmarshal([]byte(t.RequestContent), t.RequestInfo); err != nil { + if err := jsoniter.Unmarshal([]byte(t.RequestContent), t.RequestInfo); err != nil { log.Error("Unmarshal[%d]: %v", t.ID, err) } + } - case "response_content": - if t.ResponseContent == "" { - return - } - + if t.ResponseContent != "" { t.ResponseInfo = &HookResponse{} - if err = jsoniter.Unmarshal([]byte(t.ResponseContent), t.ResponseInfo); err != nil { + if err := jsoniter.Unmarshal([]byte(t.ResponseContent), t.ResponseInfo); err != nil { log.Error("Unmarshal [%d]: %v", t.ID, err) } } + return nil } func (t *HookTask) ToJSON(v any) string { @@ -502,20 +486,19 @@ func (t *HookTask) ToJSON(v any) string { // HookTasks returns a list of hook tasks by given conditions. func HookTasks(hookID int64, page int) ([]*HookTask, error) { tasks := make([]*HookTask, 0, conf.Webhook.PagingNum) - return tasks, x.Limit(conf.Webhook.PagingNum, (page-1)*conf.Webhook.PagingNum).Where("hook_id=?", hookID).Desc("id").Find(&tasks) + return tasks, db.Where("hook_id = ?", hookID).Order("id DESC").Limit(conf.Webhook.PagingNum).Offset((page - 1) * conf.Webhook.PagingNum).Find(&tasks).Error } // createHookTask creates a new hook task, // it handles conversion from Payload to PayloadContent. -func createHookTask(e Engine, t *HookTask) error { +func createHookTask(tx *gorm.DB, t *HookTask) error { data, err := t.JSONPayload() if err != nil { return err } t.UUID = gouuid.NewV4().String() t.PayloadContent = string(data) - _, err = e.Insert(t) - return err + return tx.Create(t).Error } var _ errutil.NotFound = (*ErrHookTaskNotExist)(nil) @@ -543,23 +526,23 @@ func GetHookTaskOfWebhookByUUID(webhookID int64, uuid string) (*HookTask, error) HookID: webhookID, UUID: uuid, } - has, err := x.Get(hookTask) + err := db.Where("hook_id = ? AND uuid = ?", webhookID, uuid).First(hookTask).Error if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, ErrHookTaskNotExist{args: map[string]any{"webhookID": webhookID, "uuid": uuid}} + } return nil, err - } else if !has { - return nil, ErrHookTaskNotExist{args: map[string]any{"webhookID": webhookID, "uuid": uuid}} } return hookTask, nil } // UpdateHookTask updates information of hook task. func UpdateHookTask(t *HookTask) error { - _, err := x.Id(t.ID).AllCols().Update(t) - return err + return db.Model(t).Where("id = ?", t.ID).Updates(t).Error } // prepareHookTasks adds list of webhooks to task queue. -func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Payloader, webhooks []*Webhook) (err error) { +func prepareHookTasks(tx *gorm.DB, repo *Repository, event HookEventType, p api.Payloader, webhooks []*Webhook) (err error) { if len(webhooks) == 0 { return nil } @@ -633,7 +616,7 @@ func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Pay signature = hex.EncodeToString(sig.Sum(nil)) } - if err = createHookTask(e, &HookTask{ + if err = createHookTask(tx, &HookTask{ RepoID: repo.ID, HookID: w.ID, Type: w.HookTaskType, @@ -655,32 +638,32 @@ func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Pay return nil } -func prepareWebhooks(e Engine, repo *Repository, event HookEventType, p api.Payloader) error { - webhooks, err := getActiveWebhooksByRepoID(e, repo.ID) +func prepareWebhooks(tx *gorm.DB, repo *Repository, event HookEventType, p api.Payloader) error { + webhooks, err := getActiveWebhooksByRepoID(tx, repo.ID) if err != nil { return errors.Newf("getActiveWebhooksByRepoID [%d]: %v", repo.ID, err) } // check if repo belongs to org and append additional webhooks - if repo.mustOwner(e).IsOrganization() { + if repo.mustOwner(tx).IsOrganization() { // get hooks for org - orgws, err := getActiveWebhooksByOrgID(e, repo.OwnerID) + orgws, err := getActiveWebhooksByOrgID(tx, repo.OwnerID) if err != nil { return errors.Newf("getActiveWebhooksByOrgID [%d]: %v", repo.OwnerID, err) } webhooks = append(webhooks, orgws...) } - return prepareHookTasks(e, repo, event, p, webhooks) + return prepareHookTasks(tx, repo, event, p, webhooks) } // PrepareWebhooks adds all active webhooks to task queue. func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) error { // NOTE: To prevent too many cascading changes in a single refactoring PR, we // choose to ignore this function in tests. - if x == nil && testutil.InTest { + if db == nil && testutil.InTest { return nil } - return prepareWebhooks(x, repo, event, p) + return prepareWebhooks(db, repo, event, p) } // TestWebhook adds the test webhook matches the ID to task queue. @@ -689,7 +672,7 @@ func TestWebhook(repo *Repository, event HookEventType, p api.Payloader, webhook if err != nil { return errors.Newf("GetWebhookOfRepoByID [repo_id: %d, id: %d]: %v", repo.ID, webhookID, err) } - return prepareHookTasks(x, repo, event, p, []*Webhook{webhook}) + return prepareHookTasks(db, repo, event, p, []*Webhook{webhook}) } func (t *HookTask) deliver() { @@ -784,18 +767,15 @@ func (t *HookTask) deliver() { // TODO: shoot more hooks at same time. func DeliverHooks() { tasks := make([]*HookTask, 0, 10) - _ = x.Where("is_delivered = ?", false).Iterate(new(HookTask), - func(idx int, bean any) error { - t := bean.(*HookTask) + err := db.Where("is_delivered = ?", false).Find(&tasks).Error + if err != nil { + log.Error("Find undelivered hook tasks: %v", err) + } else { + for _, t := range tasks { t.deliver() - tasks = append(tasks, t) - return nil - }) - - // Update hook task status. - for _, t := range tasks { - if err := UpdateHookTask(t); err != nil { - log.Error("UpdateHookTask [%d]: %v", t.ID, err) + if err := UpdateHookTask(t); err != nil { + log.Error("UpdateHookTask [%d]: %v", t.ID, err) + } } } @@ -805,7 +785,7 @@ func DeliverHooks() { HookQueue.Remove(repoID) tasks = make([]*HookTask, 0, 5) - if err := x.Where("repo_id = ?", repoID).And("is_delivered = ?", false).Find(&tasks); err != nil { + if err := db.Where("repo_id = ? AND is_delivered = ?", repoID, false).Find(&tasks).Error; err != nil { log.Error("Get repository [%s] hook tasks: %v", repoID, err) continue }