2014-04-03 00:43:31 +08:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2018-11-28 19:26:14 +08:00
|
|
|
// Copyright 2018 The Gitea Authors. All rights reserved.
|
2022-11-28 02:20:29 +08:00
|
|
|
// SPDX-License-Identifier: MIT
|
2014-04-03 00:43:31 +08:00
|
|
|
|
|
|
|
package repo
|
|
|
|
|
|
|
|
import (
|
2023-05-10 11:43:55 +08:00
|
|
|
"errors"
|
2016-03-07 03:44:22 +08:00
|
|
|
"fmt"
|
2021-04-05 23:30:52 +08:00
|
|
|
"net/http"
|
2021-03-23 00:09:51 +08:00
|
|
|
"strings"
|
2016-03-07 03:44:22 +08:00
|
|
|
|
2016-11-11 00:24:48 +08:00
|
|
|
"code.gitea.io/gitea/models"
|
2021-09-24 19:32:56 +08:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2022-08-25 10:31:57 +08:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2021-11-10 03:57:58 +08:00
|
|
|
"code.gitea.io/gitea/models/unit"
|
2021-11-24 17:49:20 +08:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2016-11-11 00:24:48 +08:00
|
|
|
"code.gitea.io/gitea/modules/base"
|
|
|
|
"code.gitea.io/gitea/modules/context"
|
2023-05-10 11:43:55 +08:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2016-11-11 00:24:48 +08:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2021-04-20 06:25:08 +08:00
|
|
|
"code.gitea.io/gitea/modules/markup"
|
2017-09-21 13:20:14 +08:00
|
|
|
"code.gitea.io/gitea/modules/markup/markdown"
|
2017-01-15 22:57:00 +08:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2020-10-05 13:49:33 +08:00
|
|
|
"code.gitea.io/gitea/modules/upload"
|
2021-11-17 02:18:25 +08:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2021-01-26 23:36:53 +08:00
|
|
|
"code.gitea.io/gitea/modules/web"
|
2022-12-22 05:06:26 +08:00
|
|
|
"code.gitea.io/gitea/routers/web/feed"
|
2021-04-07 03:44:05 +08:00
|
|
|
"code.gitea.io/gitea/services/forms"
|
2019-09-15 23:28:25 +08:00
|
|
|
releaseservice "code.gitea.io/gitea/services/release"
|
2014-04-03 00:43:31 +08:00
|
|
|
)
|
|
|
|
|
2014-06-23 11:11:12 +08:00
|
|
|
const (
|
2023-04-26 00:29:00 +08:00
|
|
|
tplReleasesList base.TplName = "repo/release/list"
|
|
|
|
tplReleaseNew base.TplName = "repo/release/new"
|
|
|
|
tplTagsList base.TplName = "repo/tag/list"
|
2014-06-23 11:11:12 +08:00
|
|
|
)
|
|
|
|
|
2016-07-27 16:57:32 +08:00
|
|
|
// calReleaseNumCommitsBehind calculates given release has how many commits behind release target.
|
2022-08-25 10:31:57 +08:00
|
|
|
func calReleaseNumCommitsBehind(repoCtx *context.Repository, release *repo_model.Release, countCache map[string]int64) error {
|
2023-05-10 11:43:55 +08:00
|
|
|
target := release.Target
|
|
|
|
if target == "" {
|
|
|
|
target = repoCtx.Repository.DefaultBranch
|
|
|
|
}
|
|
|
|
// Get count if not cached
|
|
|
|
if _, ok := countCache[target]; !ok {
|
|
|
|
commit, err := repoCtx.GitRepo.GetBranchCommit(target)
|
|
|
|
if err != nil {
|
|
|
|
var errNotExist git.ErrNotExist
|
|
|
|
if target == repoCtx.Repository.DefaultBranch || !errors.As(err, &errNotExist) {
|
2022-10-25 03:29:17 +08:00
|
|
|
return fmt.Errorf("GetBranchCommit: %w", err)
|
2016-07-27 16:57:32 +08:00
|
|
|
}
|
2023-05-10 11:43:55 +08:00
|
|
|
// fallback to default branch
|
|
|
|
target = repoCtx.Repository.DefaultBranch
|
|
|
|
commit, err = repoCtx.GitRepo.GetBranchCommit(target)
|
2016-07-27 16:57:32 +08:00
|
|
|
if err != nil {
|
2023-05-10 11:43:55 +08:00
|
|
|
return fmt.Errorf("GetBranchCommit(DefaultBranch): %w", err)
|
2016-07-27 16:57:32 +08:00
|
|
|
}
|
2023-05-10 11:43:55 +08:00
|
|
|
}
|
|
|
|
countCache[target], err = commit.CommitsCount()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("CommitsCount: %w", err)
|
2016-03-07 03:44:22 +08:00
|
|
|
}
|
|
|
|
}
|
2023-05-10 11:43:55 +08:00
|
|
|
release.NumCommitsBehind = countCache[target] - release.NumCommits
|
|
|
|
release.TargetBehind = target
|
2016-03-07 03:44:22 +08:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-11-24 15:04:31 +08:00
|
|
|
// Releases render releases list page
|
2016-03-12 00:56:52 +08:00
|
|
|
func Releases(ctx *context.Context) {
|
2023-04-26 00:29:00 +08:00
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.releases")
|
2020-11-03 07:10:22 +08:00
|
|
|
releasesOrTags(ctx, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TagsList render tags list page
|
|
|
|
func TagsList(ctx *context.Context) {
|
2023-04-26 00:29:00 +08:00
|
|
|
ctx.Data["PageIsTagList"] = true
|
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.tags")
|
2020-11-03 07:10:22 +08:00
|
|
|
releasesOrTags(ctx, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
func releasesOrTags(ctx *context.Context, isTagList bool) {
|
2020-10-22 08:55:25 +08:00
|
|
|
ctx.Data["DefaultBranch"] = ctx.Repo.Repository.DefaultBranch
|
2021-05-04 01:27:48 +08:00
|
|
|
ctx.Data["IsViewBranch"] = false
|
|
|
|
ctx.Data["IsViewTag"] = true
|
|
|
|
// Disable the showCreateNewBranch form in the dropdown on this page.
|
|
|
|
ctx.Data["CanCreateBranch"] = false
|
|
|
|
ctx.Data["HideBranchesInDropdown"] = true
|
2014-11-07 11:06:41 +08:00
|
|
|
|
2021-09-24 19:32:56 +08:00
|
|
|
listOptions := db.ListOptions{
|
2021-09-11 01:30:37 +08:00
|
|
|
Page: ctx.FormInt("page"),
|
|
|
|
PageSize: ctx.FormInt("limit"),
|
|
|
|
}
|
|
|
|
if listOptions.PageSize == 0 {
|
|
|
|
listOptions.PageSize = setting.Repository.Release.DefaultPagingNum
|
|
|
|
}
|
|
|
|
if listOptions.PageSize > setting.API.MaxResponseItems {
|
|
|
|
listOptions.PageSize = setting.API.MaxResponseItems
|
|
|
|
}
|
|
|
|
|
Fix various typos (#20338)
* Fix various typos
Found via `codespell -q 3 -S ./options/locale,./options/license,./public/vendor -L actived,allways,attachements,ba,befores,commiter,pullrequest,pullrequests,readby,splitted,te,unknwon`
Co-authored-by: zeripath <art27@cantab.net>
2022-07-13 05:32:37 +08:00
|
|
|
// TODO(20073) tags are used for compare feature which needs all tags
|
|
|
|
// filtering is done on the client-side atm
|
2022-06-22 01:42:19 +08:00
|
|
|
tagListStart, tagListEnd := 0, 0
|
|
|
|
if isTagList {
|
|
|
|
tagListStart, tagListEnd = listOptions.GetStartEnd()
|
|
|
|
}
|
|
|
|
|
|
|
|
tags, err := ctx.Repo.GitRepo.GetTags(tagListStart, tagListEnd)
|
2021-05-04 01:27:48 +08:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetTags", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["Tags"] = tags
|
|
|
|
|
2021-11-10 03:57:58 +08:00
|
|
|
writeAccess := ctx.Repo.CanWrite(unit.TypeReleases)
|
2019-01-24 02:58:38 +08:00
|
|
|
ctx.Data["CanCreateRelease"] = writeAccess && !ctx.Repo.Repository.IsArchived
|
2018-11-28 19:26:14 +08:00
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
opts := repo_model.FindReleasesOptions{
|
2022-10-03 20:05:53 +08:00
|
|
|
ListOptions: listOptions,
|
|
|
|
}
|
|
|
|
if isTagList {
|
|
|
|
// for the tags list page, show all releases with real tags (having real commit-id),
|
|
|
|
// the drafts should also be included because a real tag might be used as a draft.
|
|
|
|
opts.IncludeDrafts = true
|
|
|
|
opts.IncludeTags = true
|
|
|
|
opts.HasSha1 = util.OptionalBoolTrue
|
|
|
|
} else {
|
|
|
|
// only show draft releases for users who can write, read-only users shouldn't see draft releases.
|
|
|
|
opts.IncludeDrafts = writeAccess
|
2017-06-29 23:11:38 +08:00
|
|
|
}
|
|
|
|
|
2022-11-19 16:12:33 +08:00
|
|
|
releases, err := repo_model.GetReleasesByRepoID(ctx, ctx.Repo.Repository.ID, opts)
|
2014-07-26 14:28:04 +08:00
|
|
|
if err != nil {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetReleasesByRepoID", err)
|
2017-06-28 22:47:00 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-12-10 10:46:31 +08:00
|
|
|
count, err := repo_model.GetReleaseCountByRepoID(ctx, ctx.Repo.Repository.ID, opts)
|
2017-06-28 22:47:00 +08:00
|
|
|
if err != nil {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetReleaseCountByRepoID", err)
|
2014-11-07 11:06:41 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-04-12 17:05:23 +08:00
|
|
|
for _, release := range releases {
|
|
|
|
release.Repo = ctx.Repo.Repository
|
|
|
|
}
|
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
if err = repo_model.GetReleaseAttachments(ctx, releases...); err != nil {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetReleaseAttachments", err)
|
2017-01-15 22:57:00 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-06-03 11:46:56 +08:00
|
|
|
// Temporary cache commits count of used branches to speed up.
|
2015-12-10 09:46:05 +08:00
|
|
|
countCache := make(map[string]int64)
|
2021-11-24 17:49:20 +08:00
|
|
|
cacheUsers := make(map[int64]*user_model.User)
|
2022-03-22 15:03:22 +08:00
|
|
|
if ctx.Doer != nil {
|
|
|
|
cacheUsers[ctx.Doer.ID] = ctx.Doer
|
2017-06-18 11:38:24 +08:00
|
|
|
}
|
2016-12-29 21:21:19 +08:00
|
|
|
var ok bool
|
2016-03-07 03:44:22 +08:00
|
|
|
|
2017-06-03 11:46:56 +08:00
|
|
|
for _, r := range releases {
|
|
|
|
if r.Publisher, ok = cacheUsers[r.PublisherID]; !ok {
|
2022-12-03 10:48:26 +08:00
|
|
|
r.Publisher, err = user_model.GetUserByID(ctx, r.PublisherID)
|
2017-06-03 11:46:56 +08:00
|
|
|
if err != nil {
|
2021-11-24 17:49:20 +08:00
|
|
|
if user_model.IsErrUserNotExist(err) {
|
|
|
|
r.Publisher = user_model.NewGhostUser()
|
2017-06-03 11:46:56 +08:00
|
|
|
} else {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetUserByID", err)
|
2016-03-07 03:44:22 +08:00
|
|
|
return
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
}
|
2017-06-03 11:46:56 +08:00
|
|
|
cacheUsers[r.PublisherID] = r.Publisher
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
2021-05-06 11:12:50 +08:00
|
|
|
|
2021-04-20 06:25:08 +08:00
|
|
|
r.Note, err = markdown.RenderString(&markup.RenderContext{
|
|
|
|
URLPrefix: ctx.Repo.RepoLink,
|
|
|
|
Metas: ctx.Repo.Repository.ComposeMetas(),
|
2021-06-21 06:39:12 +08:00
|
|
|
GitRepo: ctx.Repo.GitRepo,
|
2021-08-29 04:15:56 +08:00
|
|
|
Ctx: ctx,
|
2021-04-20 06:25:08 +08:00
|
|
|
}, r.Note)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("RenderString", err)
|
|
|
|
return
|
|
|
|
}
|
2021-05-06 11:12:50 +08:00
|
|
|
|
|
|
|
if r.IsDraft {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := calReleaseNumCommitsBehind(ctx.Repo, r, countCache); err != nil {
|
|
|
|
ctx.ServerError("calReleaseNumCommitsBehind", err)
|
|
|
|
return
|
|
|
|
}
|
2014-12-11 05:37:54 +08:00
|
|
|
}
|
|
|
|
|
2017-06-29 23:11:38 +08:00
|
|
|
ctx.Data["Releases"] = releases
|
2019-04-20 12:15:19 +08:00
|
|
|
|
2020-01-25 03:00:29 +08:00
|
|
|
pager := context.NewPagination(int(count), opts.PageSize, opts.Page, 5)
|
2019-04-20 12:15:19 +08:00
|
|
|
pager.SetDefaultParams(ctx)
|
|
|
|
ctx.Data["Page"] = pager
|
|
|
|
|
2023-04-26 00:29:00 +08:00
|
|
|
if isTagList {
|
2023-07-05 15:08:16 +08:00
|
|
|
ctx.Data["PageIsViewCode"] = !ctx.Repo.Repository.UnitEnabled(ctx, unit.TypeReleases)
|
2023-04-26 00:29:00 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplTagsList)
|
|
|
|
} else {
|
|
|
|
ctx.HTML(http.StatusOK, tplReleasesList)
|
|
|
|
}
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
|
2022-12-22 05:06:26 +08:00
|
|
|
// ReleasesFeedRSS get feeds for releases in RSS format
|
|
|
|
func ReleasesFeedRSS(ctx *context.Context) {
|
|
|
|
releasesOrTagsFeed(ctx, true, "rss")
|
|
|
|
}
|
|
|
|
|
|
|
|
// TagsListFeedRSS get feeds for tags in RSS format
|
|
|
|
func TagsListFeedRSS(ctx *context.Context) {
|
|
|
|
releasesOrTagsFeed(ctx, false, "rss")
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReleasesFeedAtom get feeds for releases in Atom format
|
|
|
|
func ReleasesFeedAtom(ctx *context.Context) {
|
|
|
|
releasesOrTagsFeed(ctx, true, "atom")
|
|
|
|
}
|
|
|
|
|
|
|
|
// TagsListFeedAtom get feeds for tags in RSS format
|
|
|
|
func TagsListFeedAtom(ctx *context.Context) {
|
|
|
|
releasesOrTagsFeed(ctx, false, "atom")
|
|
|
|
}
|
|
|
|
|
|
|
|
func releasesOrTagsFeed(ctx *context.Context, isReleasesOnly bool, formatType string) {
|
|
|
|
feed.ShowReleaseFeed(ctx, ctx.Repo.Repository, isReleasesOnly, formatType)
|
|
|
|
}
|
|
|
|
|
2020-04-18 22:47:15 +08:00
|
|
|
// SingleRelease renders a single release's page
|
|
|
|
func SingleRelease(ctx *context.Context) {
|
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
2023-03-27 21:41:33 +08:00
|
|
|
ctx.Data["DefaultBranch"] = ctx.Repo.Repository.DefaultBranch
|
2020-04-18 22:47:15 +08:00
|
|
|
|
2021-11-10 03:57:58 +08:00
|
|
|
writeAccess := ctx.Repo.CanWrite(unit.TypeReleases)
|
2020-04-18 22:47:15 +08:00
|
|
|
ctx.Data["CanCreateRelease"] = writeAccess && !ctx.Repo.Repository.IsArchived
|
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
release, err := repo_model.GetRelease(ctx.Repo.Repository.ID, ctx.Params("*"))
|
2020-04-18 22:47:15 +08:00
|
|
|
if err != nil {
|
2022-08-25 10:31:57 +08:00
|
|
|
if repo_model.IsErrReleaseNotExist(err) {
|
2020-07-27 03:00:48 +08:00
|
|
|
ctx.NotFound("GetRelease", err)
|
|
|
|
return
|
|
|
|
}
|
2020-04-18 22:47:15 +08:00
|
|
|
ctx.ServerError("GetReleasesByRepoID", err)
|
|
|
|
return
|
|
|
|
}
|
2023-03-27 21:41:33 +08:00
|
|
|
ctx.Data["PageIsSingleTag"] = release.IsTag
|
|
|
|
if release.IsTag {
|
|
|
|
ctx.Data["Title"] = release.TagName
|
|
|
|
} else {
|
|
|
|
ctx.Data["Title"] = release.Title
|
|
|
|
}
|
2020-04-18 22:47:15 +08:00
|
|
|
|
2023-04-12 17:05:23 +08:00
|
|
|
release.Repo = ctx.Repo.Repository
|
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
err = repo_model.GetReleaseAttachments(ctx, release)
|
2020-04-18 22:47:15 +08:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetReleaseAttachments", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-12-03 10:48:26 +08:00
|
|
|
release.Publisher, err = user_model.GetUserByID(ctx, release.PublisherID)
|
2020-04-18 22:47:15 +08:00
|
|
|
if err != nil {
|
2021-11-24 17:49:20 +08:00
|
|
|
if user_model.IsErrUserNotExist(err) {
|
|
|
|
release.Publisher = user_model.NewGhostUser()
|
2020-04-18 22:47:15 +08:00
|
|
|
} else {
|
|
|
|
ctx.ServerError("GetUserByID", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2021-05-06 11:12:50 +08:00
|
|
|
if !release.IsDraft {
|
|
|
|
if err := calReleaseNumCommitsBehind(ctx.Repo, release, make(map[string]int64)); err != nil {
|
|
|
|
ctx.ServerError("calReleaseNumCommitsBehind", err)
|
|
|
|
return
|
|
|
|
}
|
2020-04-18 22:47:15 +08:00
|
|
|
}
|
2021-04-20 06:25:08 +08:00
|
|
|
release.Note, err = markdown.RenderString(&markup.RenderContext{
|
|
|
|
URLPrefix: ctx.Repo.RepoLink,
|
|
|
|
Metas: ctx.Repo.Repository.ComposeMetas(),
|
2021-06-21 06:39:12 +08:00
|
|
|
GitRepo: ctx.Repo.GitRepo,
|
2021-08-29 04:15:56 +08:00
|
|
|
Ctx: ctx,
|
2021-04-20 06:25:08 +08:00
|
|
|
}, release.Note)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("RenderString", err)
|
|
|
|
return
|
|
|
|
}
|
2020-04-18 22:47:15 +08:00
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
ctx.Data["Releases"] = []*repo_model.Release{release}
|
2023-04-26 00:29:00 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplReleasesList)
|
2020-04-18 22:47:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// LatestRelease redirects to the latest release
|
|
|
|
func LatestRelease(ctx *context.Context) {
|
2022-08-25 10:31:57 +08:00
|
|
|
release, err := repo_model.GetLatestReleaseByRepoID(ctx.Repo.Repository.ID)
|
2020-04-18 22:47:15 +08:00
|
|
|
if err != nil {
|
2022-08-25 10:31:57 +08:00
|
|
|
if repo_model.IsErrReleaseNotExist(err) {
|
2020-04-18 22:47:15 +08:00
|
|
|
ctx.NotFound("LatestRelease", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.ServerError("GetLatestReleaseByRepoID", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 16:12:33 +08:00
|
|
|
if err := release.LoadAttributes(ctx); err != nil {
|
2020-04-18 22:47:15 +08:00
|
|
|
ctx.ServerError("LoadAttributes", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-02-11 14:34:11 +08:00
|
|
|
ctx.Redirect(release.Link())
|
2020-04-18 22:47:15 +08:00
|
|
|
}
|
|
|
|
|
2021-03-23 00:09:51 +08:00
|
|
|
// NewRelease render creating or edit release page
|
2016-03-12 00:56:52 +08:00
|
|
|
func NewRelease(ctx *context.Context) {
|
2014-12-11 05:37:54 +08:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.new_release")
|
2015-11-17 00:16:52 +08:00
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
2014-12-11 05:37:54 +08:00
|
|
|
ctx.Data["tag_target"] = ctx.Repo.Repository.DefaultBranch
|
2021-08-11 08:31:13 +08:00
|
|
|
if tagName := ctx.FormString("tag"); len(tagName) > 0 {
|
2022-08-25 10:31:57 +08:00
|
|
|
rel, err := repo_model.GetRelease(ctx.Repo.Repository.ID, tagName)
|
|
|
|
if err != nil && !repo_model.IsErrReleaseNotExist(err) {
|
2020-11-03 07:10:22 +08:00
|
|
|
ctx.ServerError("GetRelease", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if rel != nil {
|
2021-03-23 00:09:51 +08:00
|
|
|
rel.Repo = ctx.Repo.Repository
|
2022-11-19 16:12:33 +08:00
|
|
|
if err := rel.LoadAttributes(ctx); err != nil {
|
2021-03-23 00:09:51 +08:00
|
|
|
ctx.ServerError("LoadAttributes", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-11-03 07:10:22 +08:00
|
|
|
ctx.Data["tag_name"] = rel.TagName
|
2022-05-10 20:41:37 +08:00
|
|
|
if rel.Target != "" {
|
|
|
|
ctx.Data["tag_target"] = rel.Target
|
|
|
|
}
|
2020-11-03 07:10:22 +08:00
|
|
|
ctx.Data["title"] = rel.Title
|
|
|
|
ctx.Data["content"] = rel.Note
|
2021-03-23 00:09:51 +08:00
|
|
|
ctx.Data["attachments"] = rel.Attachments
|
2020-11-03 07:10:22 +08:00
|
|
|
}
|
|
|
|
}
|
2020-10-05 13:49:33 +08:00
|
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
2023-04-07 08:11:02 +08:00
|
|
|
assigneeUsers, err := repo_model.GetRepoAssignees(ctx, ctx.Repo.Repository)
|
2023-02-02 03:14:40 +08:00
|
|
|
if err != nil {
|
2023-04-07 08:11:02 +08:00
|
|
|
ctx.ServerError("GetRepoAssignees", err)
|
2023-02-02 03:14:40 +08:00
|
|
|
return
|
|
|
|
}
|
2023-04-07 08:11:02 +08:00
|
|
|
ctx.Data["Assignees"] = makeSelfOnTop(ctx, assigneeUsers)
|
2023-02-02 03:14:40 +08:00
|
|
|
|
2020-10-05 13:49:33 +08:00
|
|
|
upload.AddUploadContext(ctx, "release")
|
2021-04-05 23:30:52 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplReleaseNew)
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
|
2016-11-24 15:04:31 +08:00
|
|
|
// NewReleasePost response for creating a release
|
2021-01-26 23:36:53 +08:00
|
|
|
func NewReleasePost(ctx *context.Context) {
|
2021-04-07 03:44:05 +08:00
|
|
|
form := web.GetForm(ctx).(*forms.NewReleaseForm)
|
2014-12-11 05:37:54 +08:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.new_release")
|
2015-11-17 00:16:52 +08:00
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
2014-07-26 14:28:04 +08:00
|
|
|
|
|
|
|
if ctx.HasError() {
|
2021-04-05 23:30:52 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplReleaseNew)
|
2014-07-26 14:28:04 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-11-07 11:06:41 +08:00
|
|
|
if !ctx.Repo.GitRepo.IsBranchExist(form.Target) {
|
2016-11-24 15:04:31 +08:00
|
|
|
ctx.RenderWithErr(ctx.Tr("form.target_branch_not_exist"), tplReleaseNew, &form)
|
2023-04-07 09:44:52 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Title of release cannot be empty
|
|
|
|
if len(form.TagOnly) == 0 && len(form.Title) == 0 {
|
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.release.title_empty"), tplReleaseNew, &form)
|
2014-11-07 11:06:41 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-09-20 13:26:49 +08:00
|
|
|
var attachmentUUIDs []string
|
2020-08-18 12:23:45 +08:00
|
|
|
if setting.Attachment.Enabled {
|
2017-09-20 13:26:49 +08:00
|
|
|
attachmentUUIDs = form.Files
|
2016-08-07 01:02:15 +08:00
|
|
|
}
|
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
rel, err := repo_model.GetRelease(ctx.Repo.Repository.ID, form.TagName)
|
2014-07-26 14:28:04 +08:00
|
|
|
if err != nil {
|
2022-08-25 10:31:57 +08:00
|
|
|
if !repo_model.IsErrReleaseNotExist(err) {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetRelease", err)
|
2017-09-20 13:26:49 +08:00
|
|
|
return
|
|
|
|
}
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2021-03-01 03:57:45 +08:00
|
|
|
msg := ""
|
|
|
|
if len(form.Title) > 0 && form.AddTagMsg {
|
|
|
|
msg = form.Title + "\n\n" + form.Content
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(form.TagOnly) > 0 {
|
2022-03-22 15:03:22 +08:00
|
|
|
if err = releaseservice.CreateNewTag(ctx, ctx.Doer, ctx.Repo.Repository, form.Target, form.TagName, msg); err != nil {
|
2021-03-01 03:57:45 +08:00
|
|
|
if models.IsErrTagAlreadyExists(err) {
|
|
|
|
e := err.(models.ErrTagAlreadyExists)
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.tag_collision", e.TagName))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchNameSubURL())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-06-25 22:28:55 +08:00
|
|
|
if models.IsErrInvalidTagName(err) {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.release.tag_name_invalid"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchNameSubURL())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if models.IsErrProtectedTagName(err) {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.release.tag_name_protected"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchNameSubURL())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-03-01 03:57:45 +08:00
|
|
|
ctx.ServerError("releaseservice.CreateNewTag", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.tag.create_success", form.TagName))
|
2021-11-17 02:18:25 +08:00
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/src/tag/" + util.PathEscapeSegments(form.TagName))
|
2021-03-01 03:57:45 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
rel = &repo_model.Release{
|
2017-09-20 13:26:49 +08:00
|
|
|
RepoID: ctx.Repo.Repository.ID,
|
2021-06-25 22:28:55 +08:00
|
|
|
Repo: ctx.Repo.Repository,
|
2022-03-22 15:03:22 +08:00
|
|
|
PublisherID: ctx.Doer.ID,
|
|
|
|
Publisher: ctx.Doer,
|
2017-09-20 13:26:49 +08:00
|
|
|
Title: form.Title,
|
|
|
|
TagName: form.TagName,
|
|
|
|
Target: form.Target,
|
|
|
|
Note: form.Content,
|
|
|
|
IsDraft: len(form.Draft) > 0,
|
|
|
|
IsPrerelease: form.Prerelease,
|
|
|
|
IsTag: false,
|
|
|
|
}
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2021-03-01 03:57:45 +08:00
|
|
|
if err = releaseservice.CreateRelease(ctx.Repo.GitRepo, rel, attachmentUUIDs, msg); err != nil {
|
2017-09-20 13:26:49 +08:00
|
|
|
ctx.Data["Err_TagName"] = true
|
|
|
|
switch {
|
2022-08-25 10:31:57 +08:00
|
|
|
case repo_model.IsErrReleaseAlreadyExist(err):
|
2017-09-20 13:26:49 +08:00
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_already_exist"), tplReleaseNew, &form)
|
|
|
|
case models.IsErrInvalidTagName(err):
|
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_invalid"), tplReleaseNew, &form)
|
2021-06-25 22:28:55 +08:00
|
|
|
case models.IsErrProtectedTagName(err):
|
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_protected"), tplReleaseNew, &form)
|
2017-09-20 13:26:49 +08:00
|
|
|
default:
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("CreateRelease", err)
|
2017-09-20 13:26:49 +08:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if !rel.IsTag {
|
|
|
|
ctx.Data["Err_TagName"] = true
|
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.release.tag_name_already_exist"), tplReleaseNew, &form)
|
|
|
|
return
|
|
|
|
}
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2017-09-20 13:26:49 +08:00
|
|
|
rel.Title = form.Title
|
|
|
|
rel.Note = form.Content
|
2017-12-08 13:22:02 +08:00
|
|
|
rel.Target = form.Target
|
2017-09-20 13:26:49 +08:00
|
|
|
rel.IsDraft = len(form.Draft) > 0
|
|
|
|
rel.IsPrerelease = form.Prerelease
|
2022-03-22 15:03:22 +08:00
|
|
|
rel.PublisherID = ctx.Doer.ID
|
2017-09-20 13:26:49 +08:00
|
|
|
rel.IsTag = false
|
2017-01-15 22:57:00 +08:00
|
|
|
|
2022-03-22 15:03:22 +08:00
|
|
|
if err = releaseservice.UpdateRelease(ctx.Doer, ctx.Repo.GitRepo, rel, attachmentUUIDs, nil, nil); err != nil {
|
2017-09-20 13:26:49 +08:00
|
|
|
ctx.Data["Err_TagName"] = true
|
2021-03-23 00:09:51 +08:00
|
|
|
ctx.ServerError("UpdateRelease", err)
|
2017-09-20 13:26:49 +08:00
|
|
|
return
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
}
|
2022-03-22 15:03:22 +08:00
|
|
|
log.Trace("Release created: %s/%s:%s", ctx.Doer.LowerName, ctx.Repo.Repository.Name, form.TagName)
|
2014-07-26 14:28:04 +08:00
|
|
|
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/releases")
|
|
|
|
}
|
|
|
|
|
2016-11-24 15:04:31 +08:00
|
|
|
// EditRelease render release edit page
|
2016-03-12 00:56:52 +08:00
|
|
|
func EditRelease(ctx *context.Context) {
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.edit_release")
|
2015-11-17 00:16:52 +08:00
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["PageIsEditRelease"] = true
|
2020-10-05 13:49:33 +08:00
|
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
|
|
|
upload.AddUploadContext(ctx, "release")
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2016-08-12 04:45:42 +08:00
|
|
|
tagName := ctx.Params("*")
|
2022-08-25 10:31:57 +08:00
|
|
|
rel, err := repo_model.GetRelease(ctx.Repo.Repository.ID, tagName)
|
2014-07-26 14:28:04 +08:00
|
|
|
if err != nil {
|
2022-08-25 10:31:57 +08:00
|
|
|
if repo_model.IsErrReleaseNotExist(err) {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.NotFound("GetRelease", err)
|
2014-07-26 14:28:04 +08:00
|
|
|
} else {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetRelease", err)
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
2015-11-20 15:38:41 +08:00
|
|
|
ctx.Data["ID"] = rel.ID
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["tag_name"] = rel.TagName
|
|
|
|
ctx.Data["tag_target"] = rel.Target
|
|
|
|
ctx.Data["title"] = rel.Title
|
|
|
|
ctx.Data["content"] = rel.Note
|
|
|
|
ctx.Data["prerelease"] = rel.IsPrerelease
|
2016-11-15 00:30:22 +08:00
|
|
|
ctx.Data["IsDraft"] = rel.IsDraft
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2021-03-23 00:09:51 +08:00
|
|
|
rel.Repo = ctx.Repo.Repository
|
2022-11-19 16:12:33 +08:00
|
|
|
if err := rel.LoadAttributes(ctx); err != nil {
|
2021-03-23 00:09:51 +08:00
|
|
|
ctx.ServerError("LoadAttributes", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["attachments"] = rel.Attachments
|
|
|
|
|
2023-02-02 03:14:40 +08:00
|
|
|
// Get assignees.
|
2023-04-07 08:11:02 +08:00
|
|
|
assigneeUsers, err := repo_model.GetRepoAssignees(ctx, rel.Repo)
|
2023-02-02 03:14:40 +08:00
|
|
|
if err != nil {
|
2023-04-07 08:11:02 +08:00
|
|
|
ctx.ServerError("GetRepoAssignees", err)
|
2023-02-02 03:14:40 +08:00
|
|
|
return
|
|
|
|
}
|
2023-04-07 08:11:02 +08:00
|
|
|
ctx.Data["Assignees"] = makeSelfOnTop(ctx, assigneeUsers)
|
2023-02-02 03:14:40 +08:00
|
|
|
|
2021-04-05 23:30:52 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplReleaseNew)
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
|
2016-11-24 15:04:31 +08:00
|
|
|
// EditReleasePost response for edit release
|
2021-01-26 23:36:53 +08:00
|
|
|
func EditReleasePost(ctx *context.Context) {
|
2021-04-07 03:44:05 +08:00
|
|
|
form := web.GetForm(ctx).(*forms.EditReleaseForm)
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.release.edit_release")
|
2015-11-17 00:16:52 +08:00
|
|
|
ctx.Data["PageIsReleaseList"] = true
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["PageIsEditRelease"] = true
|
2014-07-26 14:28:04 +08:00
|
|
|
|
2016-08-12 04:45:42 +08:00
|
|
|
tagName := ctx.Params("*")
|
2022-08-25 10:31:57 +08:00
|
|
|
rel, err := repo_model.GetRelease(ctx.Repo.Repository.ID, tagName)
|
2014-07-26 14:28:04 +08:00
|
|
|
if err != nil {
|
2022-08-25 10:31:57 +08:00
|
|
|
if repo_model.IsErrReleaseNotExist(err) {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.NotFound("GetRelease", err)
|
2014-07-26 14:28:04 +08:00
|
|
|
} else {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("GetRelease", err)
|
2014-07-26 14:28:04 +08:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
2017-09-20 13:26:49 +08:00
|
|
|
if rel.IsTag {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.NotFound("GetRelease", err)
|
2017-09-20 13:26:49 +08:00
|
|
|
return
|
|
|
|
}
|
2015-11-16 12:52:46 +08:00
|
|
|
ctx.Data["tag_name"] = rel.TagName
|
|
|
|
ctx.Data["tag_target"] = rel.Target
|
|
|
|
ctx.Data["title"] = rel.Title
|
|
|
|
ctx.Data["content"] = rel.Note
|
|
|
|
ctx.Data["prerelease"] = rel.IsPrerelease
|
2014-07-26 14:28:04 +08:00
|
|
|
|
|
|
|
if ctx.HasError() {
|
2021-04-05 23:30:52 +08:00
|
|
|
ctx.HTML(http.StatusOK, tplReleaseNew)
|
2014-07-26 14:28:04 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-03-23 00:09:51 +08:00
|
|
|
const delPrefix = "attachment-del-"
|
|
|
|
const editPrefix = "attachment-edit-"
|
|
|
|
var addAttachmentUUIDs, delAttachmentUUIDs []string
|
2022-01-21 01:46:10 +08:00
|
|
|
editAttachments := make(map[string]string) // uuid -> new name
|
2020-08-18 12:23:45 +08:00
|
|
|
if setting.Attachment.Enabled {
|
2021-03-23 00:09:51 +08:00
|
|
|
addAttachmentUUIDs = form.Files
|
|
|
|
for k, v := range ctx.Req.Form {
|
|
|
|
if strings.HasPrefix(k, delPrefix) && v[0] == "true" {
|
|
|
|
delAttachmentUUIDs = append(delAttachmentUUIDs, k[len(delPrefix):])
|
|
|
|
} else if strings.HasPrefix(k, editPrefix) {
|
|
|
|
editAttachments[k[len(editPrefix):]] = v[0]
|
|
|
|
}
|
|
|
|
}
|
2017-01-15 22:57:00 +08:00
|
|
|
}
|
|
|
|
|
2014-07-26 14:28:04 +08:00
|
|
|
rel.Title = form.Title
|
|
|
|
rel.Note = form.Content
|
|
|
|
rel.IsDraft = len(form.Draft) > 0
|
|
|
|
rel.IsPrerelease = form.Prerelease
|
2022-03-22 15:03:22 +08:00
|
|
|
if err = releaseservice.UpdateRelease(ctx.Doer, ctx.Repo.GitRepo,
|
2021-03-23 00:09:51 +08:00
|
|
|
rel, addAttachmentUUIDs, delAttachmentUUIDs, editAttachments); err != nil {
|
2018-01-11 05:34:17 +08:00
|
|
|
ctx.ServerError("UpdateRelease", err)
|
2014-07-26 14:28:04 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/releases")
|
|
|
|
}
|
2015-11-20 15:38:41 +08:00
|
|
|
|
Fix various typos (#20338)
* Fix various typos
Found via `codespell -q 3 -S ./options/locale,./options/license,./public/vendor -L actived,allways,attachements,ba,befores,commiter,pullrequest,pullrequests,readby,splitted,te,unknwon`
Co-authored-by: zeripath <art27@cantab.net>
2022-07-13 05:32:37 +08:00
|
|
|
// DeleteRelease deletes a release
|
2016-03-12 00:56:52 +08:00
|
|
|
func DeleteRelease(ctx *context.Context) {
|
2020-11-03 07:10:22 +08:00
|
|
|
deleteReleaseOrTag(ctx, false)
|
|
|
|
}
|
|
|
|
|
Fix various typos (#20338)
* Fix various typos
Found via `codespell -q 3 -S ./options/locale,./options/license,./public/vendor -L actived,allways,attachements,ba,befores,commiter,pullrequest,pullrequests,readby,splitted,te,unknwon`
Co-authored-by: zeripath <art27@cantab.net>
2022-07-13 05:32:37 +08:00
|
|
|
// DeleteTag deletes a tag
|
2020-11-03 07:10:22 +08:00
|
|
|
func DeleteTag(ctx *context.Context) {
|
|
|
|
deleteReleaseOrTag(ctx, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
func deleteReleaseOrTag(ctx *context.Context, isDelTag bool) {
|
2022-03-22 15:03:22 +08:00
|
|
|
if err := releaseservice.DeleteReleaseByID(ctx, ctx.FormInt64("id"), ctx.Doer, isDelTag); err != nil {
|
2022-06-17 04:03:03 +08:00
|
|
|
if models.IsErrProtectedTagName(err) {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.release.tag_name_protected"))
|
|
|
|
} else {
|
|
|
|
ctx.Flash.Error("DeleteReleaseByID: " + err.Error())
|
|
|
|
}
|
2015-11-20 15:38:41 +08:00
|
|
|
} else {
|
2020-11-03 07:10:22 +08:00
|
|
|
if isDelTag {
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.release.deletion_tag_success"))
|
|
|
|
} else {
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.release.deletion_success"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if isDelTag {
|
2023-07-05 11:41:32 +08:00
|
|
|
ctx.JSON(http.StatusOK, map[string]any{
|
2020-11-03 07:10:22 +08:00
|
|
|
"redirect": ctx.Repo.RepoLink + "/tags",
|
|
|
|
})
|
|
|
|
return
|
2015-11-20 15:38:41 +08:00
|
|
|
}
|
|
|
|
|
2023-07-05 11:41:32 +08:00
|
|
|
ctx.JSON(http.StatusOK, map[string]any{
|
2015-11-20 15:38:41 +08:00
|
|
|
"redirect": ctx.Repo.RepoLink + "/releases",
|
|
|
|
})
|
|
|
|
}
|