mirror of
https://github.com/go-gitea/gitea.git
synced 2024-12-17 13:23:09 +01:00
281 lines
8.1 KiB
Go
281 lines
8.1 KiB
Go
// Copyright 2019 The Gitea 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 repofiles
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"html"
|
|
|
|
"code.gitea.io/gitea/models"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/notification"
|
|
"code.gitea.io/gitea/modules/references"
|
|
"code.gitea.io/gitea/modules/repository"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
)
|
|
|
|
// getIssueFromRef returns the issue referenced by a ref. Returns a nil *Issue
|
|
// if the provided ref references a non-existent issue.
|
|
func getIssueFromRef(repo *models.Repository, index int64) (*models.Issue, error) {
|
|
issue, err := models.GetIssueByIndex(repo.ID, index)
|
|
if err != nil {
|
|
if models.IsErrIssueNotExist(err) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
return issue, nil
|
|
}
|
|
|
|
func changeIssueStatus(repo *models.Repository, issue *models.Issue, doer *models.User, closed bool) error {
|
|
stopTimerIfAvailable := func(doer *models.User, issue *models.Issue) error {
|
|
|
|
if models.StopwatchExists(doer.ID, issue.ID) {
|
|
if err := models.CreateOrStopIssueStopwatch(doer, issue); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
issue.Repo = repo
|
|
comment, err := issue.ChangeStatus(doer, closed)
|
|
if err != nil {
|
|
// Don't return an error when dependencies are open as this would let the push fail
|
|
if models.IsErrDependenciesLeft(err) {
|
|
return stopTimerIfAvailable(doer, issue)
|
|
}
|
|
return err
|
|
}
|
|
|
|
notification.NotifyIssueChangeStatus(doer, issue, comment, closed)
|
|
|
|
return stopTimerIfAvailable(doer, issue)
|
|
}
|
|
|
|
// UpdateIssuesCommit checks if issues are manipulated by commit message.
|
|
func UpdateIssuesCommit(doer *models.User, repo *models.Repository, commits []*repository.PushCommit, branchName string) error {
|
|
// Commits are appended in the reverse order.
|
|
for i := len(commits) - 1; i >= 0; i-- {
|
|
c := commits[i]
|
|
|
|
type markKey struct {
|
|
ID int64
|
|
Action references.XRefAction
|
|
}
|
|
|
|
refMarked := make(map[markKey]bool)
|
|
var refRepo *models.Repository
|
|
var refIssue *models.Issue
|
|
var err error
|
|
for _, ref := range references.FindAllIssueReferences(c.Message) {
|
|
|
|
// issue is from another repo
|
|
if len(ref.Owner) > 0 && len(ref.Name) > 0 {
|
|
refRepo, err = models.GetRepositoryFromMatch(ref.Owner, ref.Name)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
} else {
|
|
refRepo = repo
|
|
}
|
|
if refIssue, err = getIssueFromRef(refRepo, ref.Index); err != nil {
|
|
return err
|
|
}
|
|
if refIssue == nil {
|
|
continue
|
|
}
|
|
|
|
perm, err := models.GetUserRepoPermission(refRepo, doer)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
key := markKey{ID: refIssue.ID, Action: ref.Action}
|
|
if refMarked[key] {
|
|
continue
|
|
}
|
|
refMarked[key] = true
|
|
|
|
// FIXME: this kind of condition is all over the code, it should be consolidated in a single place
|
|
canclose := perm.IsAdmin() || perm.IsOwner() || perm.CanWriteIssuesOrPulls(refIssue.IsPull) || refIssue.PosterID == doer.ID
|
|
cancomment := canclose || perm.CanReadIssuesOrPulls(refIssue.IsPull)
|
|
|
|
// Don't proceed if the user can't comment
|
|
if !cancomment {
|
|
continue
|
|
}
|
|
|
|
message := fmt.Sprintf(`<a href="%s/commit/%s">%s</a>`, repo.Link(), c.Sha1, html.EscapeString(c.Message))
|
|
if err = models.CreateRefComment(doer, refRepo, refIssue, message, c.Sha1); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Only issues can be closed/reopened this way, and user needs the correct permissions
|
|
if refIssue.IsPull || !canclose {
|
|
continue
|
|
}
|
|
|
|
// Only process closing/reopening keywords
|
|
if ref.Action != references.XRefActionCloses && ref.Action != references.XRefActionReopens {
|
|
continue
|
|
}
|
|
|
|
if !repo.CloseIssuesViaCommitInAnyBranch {
|
|
// If the issue was specified to be in a particular branch, don't allow commits in other branches to close it
|
|
if refIssue.Ref != "" {
|
|
if branchName != refIssue.Ref {
|
|
continue
|
|
}
|
|
// Otherwise, only process commits to the default branch
|
|
} else if branchName != repo.DefaultBranch {
|
|
continue
|
|
}
|
|
}
|
|
close := (ref.Action == references.XRefActionCloses)
|
|
if close != refIssue.IsClosed {
|
|
if err := changeIssueStatus(refRepo, refIssue, doer, close); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CommitRepoActionOptions represent options of a new commit action.
|
|
type CommitRepoActionOptions struct {
|
|
PushUpdateOptions
|
|
|
|
RepoOwnerID int64
|
|
Commits *repository.PushCommits
|
|
}
|
|
|
|
// CommitRepoAction adds new commit action to the repository, and prepare
|
|
// corresponding webhooks.
|
|
func CommitRepoAction(optsList ...*CommitRepoActionOptions) error {
|
|
var pusher *models.User
|
|
var repo *models.Repository
|
|
actions := make([]*models.Action, len(optsList))
|
|
|
|
for i, opts := range optsList {
|
|
if pusher == nil || pusher.Name != opts.PusherName {
|
|
var err error
|
|
pusher, err = models.GetUserByName(opts.PusherName)
|
|
if err != nil {
|
|
return fmt.Errorf("GetUserByName [%s]: %v", opts.PusherName, err)
|
|
}
|
|
}
|
|
|
|
if repo == nil || repo.OwnerID != opts.RepoOwnerID || repo.Name != opts.RepoName {
|
|
var err error
|
|
if repo != nil {
|
|
// Change repository empty status and update last updated time.
|
|
if err := models.UpdateRepository(repo, false); err != nil {
|
|
return fmt.Errorf("UpdateRepository: %v", err)
|
|
}
|
|
}
|
|
repo, err = models.GetRepositoryByName(opts.RepoOwnerID, opts.RepoName)
|
|
if err != nil {
|
|
return fmt.Errorf("GetRepositoryByName [owner_id: %d, name: %s]: %v", opts.RepoOwnerID, opts.RepoName, err)
|
|
}
|
|
}
|
|
refName := git.RefEndName(opts.RefFullName)
|
|
|
|
// Change default branch and empty status only if pushed ref is non-empty branch.
|
|
if repo.IsEmpty && opts.IsBranch() && !opts.IsDelRef() {
|
|
repo.DefaultBranch = refName
|
|
repo.IsEmpty = false
|
|
if refName != "master" {
|
|
gitRepo, err := git.OpenRepository(repo.RepoPath())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := gitRepo.SetDefaultBranch(repo.DefaultBranch); err != nil {
|
|
if !git.IsErrUnsupportedVersion(err) {
|
|
gitRepo.Close()
|
|
return err
|
|
}
|
|
}
|
|
gitRepo.Close()
|
|
}
|
|
}
|
|
|
|
opType := models.ActionCommitRepo
|
|
|
|
// Check it's tag push or branch.
|
|
if opts.IsTag() {
|
|
opType = models.ActionPushTag
|
|
if opts.IsDelRef() {
|
|
opType = models.ActionDeleteTag
|
|
}
|
|
opts.Commits = &repository.PushCommits{}
|
|
} else if opts.IsDelRef() {
|
|
opType = models.ActionDeleteBranch
|
|
opts.Commits = &repository.PushCommits{}
|
|
} else {
|
|
// if not the first commit, set the compare URL.
|
|
if !opts.IsNewRef() {
|
|
opts.Commits.CompareURL = repo.ComposeCompareURL(opts.OldCommitID, opts.NewCommitID)
|
|
}
|
|
|
|
if err := UpdateIssuesCommit(pusher, repo, opts.Commits.Commits, refName); err != nil {
|
|
log.Error("updateIssuesCommit: %v", err)
|
|
}
|
|
}
|
|
|
|
if len(opts.Commits.Commits) > setting.UI.FeedMaxCommitNum {
|
|
opts.Commits.Commits = opts.Commits.Commits[:setting.UI.FeedMaxCommitNum]
|
|
}
|
|
|
|
data, err := json.Marshal(opts.Commits)
|
|
if err != nil {
|
|
return fmt.Errorf("Marshal: %v", err)
|
|
}
|
|
|
|
actions[i] = &models.Action{
|
|
ActUserID: pusher.ID,
|
|
ActUser: pusher,
|
|
OpType: opType,
|
|
Content: string(data),
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
RefName: refName,
|
|
IsPrivate: repo.IsPrivate,
|
|
}
|
|
|
|
switch opType {
|
|
case models.ActionCommitRepo: // Push
|
|
if opts.IsNewBranch() {
|
|
notification.NotifyCreateRef(pusher, repo, "branch", opts.RefFullName)
|
|
}
|
|
notification.NotifyPushCommits(pusher, repo, opts.RefFullName, opts.OldCommitID, opts.NewCommitID, opts.Commits)
|
|
case models.ActionDeleteBranch: // Delete Branch
|
|
notification.NotifyDeleteRef(pusher, repo, "branch", opts.RefFullName)
|
|
|
|
case models.ActionPushTag: // Create
|
|
notification.NotifyCreateRef(pusher, repo, "tag", opts.RefFullName)
|
|
|
|
case models.ActionDeleteTag: // Delete Tag
|
|
notification.NotifyDeleteRef(pusher, repo, "tag", opts.RefFullName)
|
|
}
|
|
}
|
|
|
|
if repo != nil {
|
|
// Change repository empty status and update last updated time.
|
|
if err := models.UpdateRepository(repo, false); err != nil {
|
|
return fmt.Errorf("UpdateRepository: %v", err)
|
|
}
|
|
}
|
|
|
|
if err := models.NotifyWatchers(actions...); err != nil {
|
|
return fmt.Errorf("NotifyWatchers: %v", err)
|
|
}
|
|
return nil
|
|
}
|