Convert release.go from XORM to GORM

Co-authored-by: unknwon <2946214+unknwon@users.noreply.github.com>

internal/database/release.go

@@ -6,12 +6,11 @@ import (
 	"strings"
 	"time"
 
-	log "unknwon.dev/clog/v2"
-	"xorm.io/xorm"
-
 	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"
+	"gorm.io/gorm"
+	log "unknwon.dev/clog/v2"
 
 	"gogs.io/gogs/internal/errutil"
 	"gogs.io/gogs/internal/process"
@@ -21,40 +20,39 @@ import (
 type Release struct {
 	ID               int64
 	RepoID           int64
-	Repo             *Repository `xorm:"-" json:"-" gorm:"-"`
+	Repo             *Repository `gorm:"-" json:"-"`
 	PublisherID      int64
-	Publisher        *User `xorm:"-" json:"-" gorm:"-"`
+	Publisher        *User   `gorm:"-" json:"-"`
 	TagName          string
 	LowerTagName     string
 	Target           string
 	Title            string
-	Sha1             string `xorm:"VARCHAR(40)"`
+	Sha1             string `gorm:"type:varchar(40)"`
 	NumCommits       int64
-	NumCommitsBehind int64  `xorm:"-" json:"-" gorm:"-"`
-	Note             string `xorm:"TEXT"`
-	IsDraft          bool   `xorm:"NOT NULL DEFAULT false"`
+	NumCommitsBehind int64  `gorm:"-" json:"-"`
+	Note             string `gorm:"type:text"`
+	IsDraft          bool   `gorm:"not null;default:false"`
 	IsPrerelease     bool
 
-	Created     time.Time `xorm:"-" json:"-" gorm:"-"`
+	Created     time.Time `gorm:"-" json:"-"`
 	CreatedUnix int64
 
-	Attachments []*Attachment `xorm:"-" json:"-" gorm:"-"`
+	Attachments []*Attachment `gorm:"-" json:"-"`
 }
 
-func (r *Release) BeforeInsert() {
+func (r *Release) BeforeCreate(tx *gorm.DB) error {
 	if r.CreatedUnix == 0 {
-		r.CreatedUnix = time.Now().Unix()
+		r.CreatedUnix = tx.NowFunc().Unix()
 	}
+	return nil
 }
 
-func (r *Release) AfterSet(colName string, _ xorm.Cell) {
-	switch colName {
-	case "created_unix":
-		r.Created = time.Unix(r.CreatedUnix, 0).Local()
-	}
+func (r *Release) AfterFind(tx *gorm.DB) error {
+	r.Created = time.Unix(r.CreatedUnix, 0).Local()
+	return nil
 }
 
-func (r *Release) loadAttributes(e Engine) (err error) {
+func (r *Release) loadAttributes(e *gorm.DB) (err error) {
 	if r.Repo == nil {
 		r.Repo, err = getRepositoryByID(e, r.RepoID)
 		if err != nil {
@@ -85,7 +83,7 @@ func (r *Release) loadAttributes(e Engine) (err error) {
 }
 
 func (r *Release) LoadAttributes() error {
-	return r.loadAttributes(x)
+	return r.loadAttributes(db)
 }
 
 // This method assumes some fields assigned with values:
@@ -110,7 +108,9 @@ func IsReleaseExist(repoID int64, tagName string) (bool, error) {
 		return false, nil
 	}
 
-	return x.Get(&Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)})
+	var count int64
+	err := db.Model(&Release{}).Where("repo_id = ? AND lower_tag_name = ?", repoID, strings.ToLower(tagName)).Count(&count).Error
+	return count > 0, err
 }
 
 func createTag(gitRepo *git.Repository, r *Release) error {
@@ -171,24 +171,21 @@ func NewRelease(gitRepo *git.Repository, r *Release, uuids []string) error {
 	}
 	r.LowerTagName = strings.ToLower(r.TagName)
 
-	sess := x.NewSession()
-	defer sess.Close()
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-
-	if _, err = sess.Insert(r); err != nil {
-		return errors.Newf("insert: %v", err)
-	}
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(r).Error; err != nil {
+			return errors.Newf("insert: %v", err)
+		}
 
-	if len(uuids) > 0 {
-		if _, err = sess.In("uuid", uuids).Cols("release_id").Update(&Attachment{ReleaseID: r.ID}); err != nil {
-			return errors.Newf("link attachments: %v", err)
+		if len(uuids) > 0 {
+			if err := tx.Model(&Attachment{}).Where("uuid IN ?", uuids).Update("release_id", r.ID).Error; err != nil {
+				return errors.Newf("link attachments: %v", err)
+			}
 		}
-	}
 
-	if err = sess.Commit(); err != nil {
-		return errors.Newf("commit: %v", err)
+		return nil
+	})
+	if err != nil {
+		return err
 	}
 
 	// Only send webhook when actually published, skip drafts
@@ -231,8 +228,8 @@ func GetRelease(repoID int64, tagName string) (*Release, error) {
 		return nil, ErrReleaseNotExist{args: map[string]any{"tag": tagName}}
 	}
 
-	r := &Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)}
-	if _, err = x.Get(r); err != nil {
+	r := &Release{}
+	if err = db.Where("repo_id = ? AND lower_tag_name = ?", repoID, strings.ToLower(tagName)).First(r).Error; err != nil {
 		return nil, errors.Newf("get: %v", err)
 	}
 
@@ -242,11 +239,12 @@ func GetRelease(repoID int64, tagName string) (*Release, error) {
 // GetReleaseByID returns release with given ID.
 func GetReleaseByID(id int64) (*Release, error) {
 	r := new(Release)
-	has, err := x.Id(id).Get(r)
+	err := db.Where("id = ?", id).First(r).Error
 	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrReleaseNotExist{args: map[string]any{"releaseID": id}}
+		}
 		return nil, err
-	} else if !has {
-		return nil, ErrReleaseNotExist{args: map[string]any{"releaseID": id}}
 	}
 
 	return r, r.LoadAttributes()
@@ -256,24 +254,24 @@ func GetReleaseByID(id int64) (*Release, error) {
 // If matches is not empty, only published releases in matches will be returned.
 // In any case, drafts won't be returned by this function.
 func GetPublishedReleasesByRepoID(repoID int64, matches ...string) ([]*Release, error) {
-	sess := x.Where("repo_id = ?", repoID).And("is_draft = ?", false).Desc("created_unix")
+	query := db.Where("repo_id = ? AND is_draft = ?", repoID, false).Order("created_unix DESC")
 	if len(matches) > 0 {
-		sess.In("tag_name", matches)
+		query = query.Where("tag_name IN ?", matches)
 	}
 	releases := make([]*Release, 0, 5)
-	return releases, sess.Find(&releases, new(Release))
+	return releases, query.Find(&releases).Error
 }
 
 // GetReleasesByRepoID returns a list of all releases (including drafts) of given repository.
 func GetReleasesByRepoID(repoID int64) ([]*Release, error) {
 	releases := make([]*Release, 0)
-	return releases, x.Where("repo_id = ?", repoID).Find(&releases)
+	return releases, db.Where("repo_id = ?", repoID).Find(&releases).Error
 }
 
 // GetDraftReleasesByRepoID returns all draft releases of repository.
 func GetDraftReleasesByRepoID(repoID int64) ([]*Release, error) {
 	releases := make([]*Release, 0)
-	return releases, x.Where("repo_id = ?", repoID).And("is_draft = ?", true).Find(&releases)
+	return releases, db.Where("repo_id = ? AND is_draft = ?", repoID, true).Find(&releases).Error
 }
 
 type ReleaseSorter struct {
@@ -310,28 +308,26 @@ func UpdateRelease(doer *User, gitRepo *git.Repository, r *Release, isPublish bo
 
 	r.PublisherID = doer.ID
 
-	sess := x.NewSession()
-	defer sess.Close()
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-	if _, err = sess.ID(r.ID).AllCols().Update(r); err != nil {
-		return errors.Newf("Update: %v", err)
-	}
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Model(r).Where("id = ?", r.ID).Updates(r).Error; err != nil {
+			return errors.Newf("Update: %v", err)
+		}
 
-	// Unlink all current attachments and link back later if still valid
-	if _, err = sess.Exec("UPDATE attachment SET release_id = 0 WHERE release_id = ?", r.ID); err != nil {
-		return errors.Newf("unlink current attachments: %v", err)
-	}
+		// Unlink all current attachments and link back later if still valid
+		if err := tx.Exec("UPDATE attachment SET release_id = 0 WHERE release_id = ?", r.ID).Error; err != nil {
+			return errors.Newf("unlink current attachments: %v", err)
+		}
 
-	if len(uuids) > 0 {
-		if _, err = sess.In("uuid", uuids).Cols("release_id").Update(&Attachment{ReleaseID: r.ID}); err != nil {
-			return errors.Newf("link attachments: %v", err)
+		if len(uuids) > 0 {
+			if err := tx.Model(&Attachment{}).Where("uuid IN ?", uuids).Update("release_id", r.ID).Error; err != nil {
+				return errors.Newf("link attachments: %v", err)
+			}
 		}
-	}
 
-	if err = sess.Commit(); err != nil {
-		return errors.Newf("commit: %v", err)
+		return nil
+	})
+	if err != nil {
+		return err
 	}
 
 	if !isPublish {
@@ -366,7 +362,7 @@ func DeleteReleaseOfRepoByID(repoID, id int64) error {
 		return errors.Newf("git tag -d: %v - %s", err, stderr)
 	}
 
-	if _, err = x.Id(rel.ID).Delete(new(Release)); err != nil {
+	if err = db.Where("id = ?", rel.ID).Delete(new(Release)).Error; err != nil {
 		return errors.Newf("delete: %v", err)
 	}