gitroast/models/release.go

294 lines
7.5 KiB
Go
Raw Normal View History

2014-04-14 05:57:25 +00:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
2015-11-20 07:38:41 +00:00
"fmt"
2014-06-12 21:47:23 +00:00
"sort"
2014-04-14 05:57:25 +00:00
"strings"
"time"
2015-08-24 13:01:23 +00:00
"github.com/go-xorm/xorm"
"code.gitea.io/git"
"code.gitea.io/gitea/modules/process"
2016-12-31 16:51:22 +00:00
"code.gitea.io/gitea/modules/setting"
api "code.gitea.io/sdk/gitea"
2014-04-14 05:57:25 +00:00
)
// Release represents a release of repository.
type Release struct {
ID int64 `xorm:"pk autoincr"`
2017-01-06 15:14:33 +00:00
RepoID int64 `xorm:"INDEX UNIQUE(n)"`
2016-12-31 16:51:22 +00:00
Repo *Repository `xorm:"-"`
2017-01-06 15:14:33 +00:00
PublisherID int64 `xorm:"INDEX"`
Publisher *User `xorm:"-"`
TagName string `xorm:"INDEX UNIQUE(n)"`
2014-04-14 05:57:25 +00:00
LowerTagName string
2014-06-12 13:10:39 +00:00
Target string
2014-06-12 21:47:23 +00:00
Title string
2014-06-12 13:10:39 +00:00
Sha1 string `xorm:"VARCHAR(40)"`
NumCommits int64
NumCommitsBehind int64 `xorm:"-"`
2014-04-14 05:57:25 +00:00
Note string `xorm:"TEXT"`
2014-06-12 21:47:23 +00:00
IsDraft bool `xorm:"NOT NULL DEFAULT false"`
2014-04-14 05:57:25 +00:00
IsPrerelease bool
Created time.Time `xorm:"-"`
2017-01-06 15:14:33 +00:00
CreatedUnix int64 `xorm:"INDEX"`
}
// BeforeInsert is invoked from XORM before inserting an object of this type.
func (r *Release) BeforeInsert() {
if r.CreatedUnix == 0 {
r.CreatedUnix = time.Now().Unix()
}
2014-04-14 05:57:25 +00:00
}
// AfterSet is invoked from XORM after setting the value of a field of this object.
2015-08-24 13:01:23 +00:00
func (r *Release) AfterSet(colName string, _ xorm.Cell) {
switch colName {
case "created_unix":
r.Created = time.Unix(r.CreatedUnix, 0).Local()
2015-08-24 13:01:23 +00:00
}
}
2016-12-31 16:51:22 +00:00
func (r *Release) loadAttributes(e Engine) error {
var err error
if r.Repo == nil {
r.Repo, err = GetRepositoryByID(r.RepoID)
if err != nil {
return err
}
}
if r.Publisher == nil {
r.Publisher, err = GetUserByID(r.PublisherID)
if err != nil {
return err
}
}
return nil
}
// LoadAttributes load repo and publisher attributes for a realease
func (r *Release) LoadAttributes() error {
return r.loadAttributes(x)
}
// APIURL the api url for a release. release must have attributes loaded
func (r *Release) APIURL() string {
return fmt.Sprintf("%sapi/v1/%s/releases/%d",
setting.AppURL, r.Repo.FullName(), r.ID)
}
// ZipURL the zip url for a release. release must have attributes loaded
func (r *Release) ZipURL() string {
return fmt.Sprintf("%s/archive/%s.zip", r.Repo.HTMLURL(), r.TagName)
}
// TarURL the tar.gz url for a release. release must have attributes loaded
func (r *Release) TarURL() string {
return fmt.Sprintf("%s/archive/%s.tar.gz", r.Repo.HTMLURL(), r.TagName)
}
// APIFormat convert a Release to api.Release
func (r *Release) APIFormat() *api.Release {
return &api.Release{
ID: r.ID,
TagName: r.TagName,
Target: r.Target,
Note: r.Note,
URL: r.APIURL(),
TarURL: r.TarURL(),
ZipURL: r.ZipURL(),
IsDraft: r.IsDraft,
IsPrerelease: r.IsPrerelease,
CreatedAt: r.Created,
PublishedAt: r.Created,
Publisher: r.Publisher.APIFormat(),
}
}
2014-04-14 05:57:25 +00:00
// IsReleaseExist returns true if release with given tag name already exists.
2015-11-16 04:52:46 +00:00
func IsReleaseExist(repoID int64, tagName string) (bool, error) {
2014-04-14 05:57:25 +00:00
if len(tagName) == 0 {
return false, nil
}
2015-11-16 04:52:46 +00:00
return x.Get(&Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)})
2014-04-14 05:57:25 +00:00
}
2014-06-12 21:47:23 +00:00
func createTag(gitRepo *git.Repository, rel *Release) error {
// Only actual create when publish.
if !rel.IsDraft {
if !gitRepo.IsTagExist(rel.TagName) {
commit, err := gitRepo.GetBranchCommit(rel.Target)
2014-06-12 21:47:23 +00:00
if err != nil {
return fmt.Errorf("GetBranchCommit: %v", err)
2014-06-12 21:47:23 +00:00
}
// Trim '--' prefix to prevent command line argument vulnerability.
rel.TagName = strings.TrimPrefix(rel.TagName, "--")
2015-11-04 03:49:06 +00:00
if err = gitRepo.CreateTag(rel.TagName, commit.ID.String()); err != nil {
if strings.Contains(err.Error(), "is not a valid tag name") {
return ErrInvalidTagName{rel.TagName}
}
2014-06-12 21:47:23 +00:00
return err
}
} else {
commit, err := gitRepo.GetTagCommit(rel.TagName)
2014-06-12 21:47:23 +00:00
if err != nil {
return fmt.Errorf("GetTagCommit: %v", err)
2014-06-12 21:47:23 +00:00
}
rel.Sha1 = commit.ID.String()
2014-06-12 21:47:23 +00:00
rel.NumCommits, err = commit.CommitsCount()
if err != nil {
return fmt.Errorf("CommitsCount: %v", err)
2014-06-12 21:47:23 +00:00
}
}
}
return nil
}
2014-04-14 05:57:25 +00:00
// CreateRelease creates a new release of repository.
2014-05-10 03:14:24 +00:00
func CreateRelease(gitRepo *git.Repository, rel *Release) error {
2015-11-16 04:52:46 +00:00
isExist, err := IsReleaseExist(rel.RepoID, rel.TagName)
2014-04-14 05:57:25 +00:00
if err != nil {
return err
} else if isExist {
2015-11-16 04:52:46 +00:00
return ErrReleaseAlreadyExist{rel.TagName}
2014-04-14 05:57:25 +00:00
}
2014-06-12 21:47:23 +00:00
if err = createTag(gitRepo, rel); err != nil {
return err
}
rel.LowerTagName = strings.ToLower(rel.TagName)
2014-06-21 04:51:41 +00:00
_, err = x.InsertOne(rel)
2014-06-12 21:47:23 +00:00
return err
}
2014-06-12 13:10:39 +00:00
2014-06-12 21:47:23 +00:00
// GetRelease returns release by given ID.
2015-11-16 04:52:46 +00:00
func GetRelease(repoID int64, tagName string) (*Release, error) {
isExist, err := IsReleaseExist(repoID, tagName)
2014-06-12 21:47:23 +00:00
if err != nil {
return nil, err
} else if !isExist {
2015-11-20 07:38:41 +00:00
return nil, ErrReleaseNotExist{0, tagName}
2014-06-12 21:47:23 +00:00
}
2014-04-14 05:57:25 +00:00
2015-11-16 04:52:46 +00:00
rel := &Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)}
2014-06-21 04:51:41 +00:00
_, err = x.Get(rel)
2014-06-12 21:47:23 +00:00
return rel, err
}
2015-11-20 07:38:41 +00:00
// GetReleaseByID returns release with given ID.
func GetReleaseByID(id int64) (*Release, error) {
rel := new(Release)
2016-11-10 15:16:32 +00:00
has, err := x.
Id(id).
Get(rel)
2015-11-20 07:38:41 +00:00
if err != nil {
return nil, err
} else if !has {
return nil, ErrReleaseNotExist{id, ""}
}
return rel, nil
}
// GetReleasesByRepoID returns a list of releases of repository.
2016-11-04 19:28:07 +00:00
func GetReleasesByRepoID(repoID int64, page, pageSize int) (rels []*Release, err error) {
if page <= 0 {
page = 1
}
2016-11-10 15:16:32 +00:00
err = x.
Desc("created_unix").
Limit(pageSize, (page-1)*pageSize).
Find(&rels, Release{RepoID: repoID})
2014-06-12 21:47:23 +00:00
return rels, err
}
// GetReleasesByRepoIDAndNames returns a list of releases of repository accroding repoID and tagNames.
func GetReleasesByRepoIDAndNames(repoID int64, tagNames []string) (rels []*Release, err error) {
err = x.
Desc("created_unix").
In("tag_name", tagNames).
Find(&rels, Release{RepoID: repoID})
return rels, err
}
type releaseSorter struct {
2014-06-12 21:47:23 +00:00
rels []*Release
}
func (rs *releaseSorter) Len() int {
2014-06-12 21:47:23 +00:00
return len(rs.rels)
}
func (rs *releaseSorter) Less(i, j int) bool {
2014-06-12 21:47:23 +00:00
diffNum := rs.rels[i].NumCommits - rs.rels[j].NumCommits
if diffNum != 0 {
return diffNum > 0
2014-04-14 05:57:25 +00:00
}
2014-06-12 21:47:23 +00:00
return rs.rels[i].Created.After(rs.rels[j].Created)
}
2014-04-14 05:57:25 +00:00
func (rs *releaseSorter) Swap(i, j int) {
2014-06-12 21:47:23 +00:00
rs.rels[i], rs.rels[j] = rs.rels[j], rs.rels[i]
}
// SortReleases sorts releases by number of commits and created time.
func SortReleases(rels []*Release) {
sorter := &releaseSorter{rels: rels}
2014-06-12 21:47:23 +00:00
sort.Sort(sorter)
}
// UpdateRelease updates information of a release.
func UpdateRelease(gitRepo *git.Repository, rel *Release) (err error) {
if err = createTag(gitRepo, rel); err != nil {
return err
}
2015-11-16 04:52:46 +00:00
_, err = x.Id(rel.ID).AllCols().Update(rel)
2014-04-14 05:57:25 +00:00
return err
}
2015-11-20 07:38:41 +00:00
// DeleteReleaseByID deletes a release and corresponding Git tag by given ID.
func DeleteReleaseByID(id int64, u *User, delTag bool) error {
2015-11-20 07:38:41 +00:00
rel, err := GetReleaseByID(id)
if err != nil {
return fmt.Errorf("GetReleaseByID: %v", err)
}
repo, err := GetRepositoryByID(rel.RepoID)
if err != nil {
return fmt.Errorf("GetRepositoryByID: %v", err)
}
has, err := HasAccess(u, repo, AccessModeWrite)
if err != nil {
return fmt.Errorf("HasAccess: %v", err)
} else if !has {
return fmt.Errorf("DeleteReleaseByID: permission denied")
}
if delTag {
_, stderr, err := process.ExecDir(-1, repo.RepoPath(),
fmt.Sprintf("DeleteReleaseByID (git tag -d): %d", rel.ID),
"git", "tag", "-d", rel.TagName)
if err != nil && !strings.Contains(stderr, "not found") {
return fmt.Errorf("git tag -d: %v - %s", err, stderr)
}
2015-11-20 07:38:41 +00:00
}
if _, err = x.Id(rel.ID).Delete(new(Release)); err != nil {
return fmt.Errorf("Delete: %v", err)
}
return nil
}