Add a new section named development in issue view sidebar to interact with branch/pr

models/issues/issue_dev_link.go

@@ -0,0 +1,85 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package issues
+
+import (
+	"context"
+	"strconv"
+
+	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/timeutil"
+)
+
+type IssueDevLinkType int
+
+const (
+	IssueDevLinkTypeBranch IssueDevLinkType = iota + 1
+	IssueDevLinkTypePullRequest
+)
+
+type IssueDevLink struct {
+	ID            int64 `xorm:"pk autoincr"`
+	IssueID       int64 `xorm:"INDEX"`
+	LinkType      IssueDevLinkType
+	LinkedRepoID  int64                  `xorm:"INDEX"` // it can link to self repo or other repo
+	LinkIndex     string                 // branch name, pull request number or commit sha
+	CreatedUnix   timeutil.TimeStamp     `xorm:"INDEX created"`
+	Repo          *repo_model.Repository `xorm:"-"` // current repo of issue
+	LinkedRepo    *repo_model.Repository `xorm:"-"`
+	PullRequest   *PullRequest           `xorm:"-"`
+	Branch        *git_model.Branch      `xorm:"-"`
+	DisplayBranch bool                   `xorm:"-"`
+}
+
+func init() {
+	db.RegisterModel(new(IssueDevLink))
+}
+
+func (i *IssueDevLink) BranchFullName() string {
+	if i.Repo.ID == i.LinkedRepo.ID {
+		return i.Branch.Name
+	}
+	return i.LinkedRepo.FullName() + ":" + i.Branch.Name
+}
+
+// IssueDevLinks represents a list of issue development links
+type IssueDevLinks []*IssueDevLink
+
+// FindIssueDevLinksByIssueID returns a list of issue development links by issue ID
+func FindIssueDevLinksByIssueID(ctx context.Context, issueID int64) (IssueDevLinks, error) {
+	links := make(IssueDevLinks, 0, 5)
+	return links, db.GetEngine(ctx).Where("issue_id = ?", issueID).Find(&links)
+}
+
+func FindDevLinksByBranch(ctx context.Context, repoID, linkedRepoID int64, branchName string) (IssueDevLinks, error) {
+	links := make(IssueDevLinks, 0, 5)
+	return links, db.GetEngine(ctx).
+		Join("INNER", "issue", "issue_dev_link.issue_id = issue.id").
+		Where("link_type = ? AND link_index = ? AND linked_repo_id = ?",
+			IssueDevLinkTypeBranch, branchName, linkedRepoID).
+		And("issue.repo_id=?", repoID).
+		Find(&links)
+}
+
+func CreateIssueDevLink(ctx context.Context, link *IssueDevLink) error {
+	_, err := db.GetEngine(ctx).Insert(link)
+	return err
+}
+
+func DeleteIssueDevLinkByBranchName(ctx context.Context, repoID int64, branchName string) error {
+	_, err := db.GetEngine(ctx).
+		Where("linked_repo_id = ? AND link_type = ? AND link_index = ?",
+			repoID, IssueDevLinkTypeBranch, branchName).
+		Delete(new(IssueDevLink))
+	return err
+}
+
+func DeleteIssueDevLinkByPullRequestID(ctx context.Context, pullID int64) error {
+	pullIDStr := strconv.FormatInt(pullID, 10)
+	_, err := db.GetEngine(ctx).Where("link_type = ? AND link_index = ?", IssueDevLinkTypePullRequest, pullIDStr).
+		Delete(new(IssueDevLink))
+	return err
+}

models/issues/issue_update.go

@@ -722,6 +722,10 @@ func DeleteIssuesByRepoID(ctx context.Context, repoID int64) (attachmentPaths []
 			return nil, err
 		}
 
+		if _, err = sess.In("issue_id", issueIDs).Delete(&IssueDevLink{}); err != nil {
+			return nil, err
+		}
+
 		var attachments []*repo_model.Attachment
 		err = sess.In("issue_id", issueIDs).Find(&attachments)
 		if err != nil {

models/migrations/migrations.go

@@ -369,6 +369,7 @@ func prepareMigrationTasks() []*migration {
 		newMigration(309, "Improve Notification table indices", v1_23.ImproveNotificationTableIndices),
 		newMigration(310, "Add Priority to ProtectedBranch", v1_23.AddPriorityToProtectedBranch),
 		newMigration(311, "Add TimeEstimate to Issue table", v1_23.AddTimeEstimateColumnToIssueTable),
+		newMigration(312, "Add table issue_dev_link", v1_23.CreateTableIssueDevLink),
 	}
 	return preparedMigrations
 }

models/migrations/v1_23/v312.go

@@ -0,0 +1,22 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package v1_23 //nolint
+
+import (
+	"code.gitea.io/gitea/modules/timeutil"
+
+	"xorm.io/xorm"
+)
+
+func CreateTableIssueDevLink(x *xorm.Engine) error {
+	type IssueDevLink struct {
+		ID           int64 `xorm:"pk autoincr"`
+		IssueID      int64 `xorm:"INDEX"`
+		LinkType     int
+		LinkedRepoID int64              `xorm:"INDEX"` // it can link to self repo or other repo
+		LinkIndex    string             // branch name, pull request number or commit sha
+		CreatedUnix  timeutil.TimeStamp `xorm:"INDEX created"`
+	}
+	return x.Sync(new(IssueDevLink))
+}

models/repo/repo.go

@@ -597,7 +597,7 @@ func (repo *Repository) IsOwnedBy(userID int64) bool {
 
 // CanCreateBranch returns true if repository meets the requirements for creating new branches.
 func (repo *Repository) CanCreateBranch() bool {
-	return !repo.IsMirror
+	return !repo.IsMirror && !repo.IsArchived
 }
 
 // CanEnablePulls returns true if repository meets the requirements of accepting pulls.

options/locale/locale_en-US.ini

@@ -1641,6 +1641,17 @@ issues.label.filter_sort.alphabetically = Alphabetically
 issues.label.filter_sort.reverse_alphabetically = Reverse alphabetically
 issues.label.filter_sort.by_size = Smallest size
 issues.label.filter_sort.reverse_by_size = Largest size
+issues.development = Development
+issues.maybefixed = May be fixed by %s
+issues.create_branch_from_issue_success = Create branch %s from issue successfully
+issues.create_branch_from_repository = Repository the branch to be created
+issues.base_branch = Base Branch in this repository
+issues.pr.completed = Completed
+issues.pr.conflicted = Merge conflicts
+issues.pr.not_exist_issue = Reference issue does not exist.
+issues.branch.latest = Latest commit %s
+issues.link.created = Created %s
+issues.create_branch_from_issue_error_is_pull = Issue links cannot be created with pull request
 issues.num_participants = %d Participants
 issues.attachment.open_tab = `Click to see "%s" in a new tab`
 issues.attachment.download = `Click to download "%s"`
@@ -2686,6 +2697,7 @@ branch.create_from = from "%s"
 branch.create_success = Branch "%s" has been created.
 branch.branch_already_exists = Branch "%s" already exists in this repository.
 branch.branch_name_conflict = Branch name "%s" conflicts with the already existing branch "%s".
+branch.branch_not_exist = Branch "%s" do not exists in this repository.
 branch.tag_collision = Branch "%s" cannot be created as a tag with same name already exists in the repository.
 branch.deleted_by = Deleted by %s
 branch.restore_success = Branch "%s" has been restored.

routers/private/hook_post_receive.go

@@ -114,6 +114,10 @@ func HookPostReceive(ctx *gitea_context.PrivateContext) {
 					})
 					return
 				}
+
+				if err := issues_model.DeleteIssueDevLinkByBranchName(ctx, repo.ID, update.RefFullName.BranchName()); err != nil {
+					log.Error("Failed to DeleteIssueDevLinkByBranchName: %s/%s %s Error: %v", ownerName, repoName, update.RefFullName.BranchName(), err)
+				}
 			} else {
 				branchesToSync = append(branchesToSync, update)
 

routers/web/repo/compare.go

@@ -847,6 +847,21 @@ func CompareDiff(ctx *context.Context) {
 		ctx.Data["AllowMaintainerEdit"] = false
 	}
 
+	refIssueIndex := ctx.FormInt64("ref_issue_index")
+	if refIssueIndex > 0 {
+		refIssue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, refIssueIndex)
+		if err != nil {
+			ctx.Flash.Warning(ctx.Tr("repo.issues.pr.not_exist_issue"), true)
+		} else {
+			keyword := "Resolve"
+			if len(setting.Repository.PullRequest.CloseKeywords) > 0 {
+				keyword = setting.Repository.PullRequest.CloseKeywords[0]
+			}
+			ctx.Data["TitleQuery"] = fmt.Sprintf("%s %s", keyword, refIssue.Title)
+			ctx.Data["BodyQuery"] = fmt.Sprintf("%s #%d", keyword, refIssueIndex)
+		}
+	}
+
 	ctx.HTML(http.StatusOK, tplCompare)
 }
 

routers/web/repo/issue_dev.go

@@ -0,0 +1,114 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repo
+
+import (
+	"net/http"
+
+	git_model "code.gitea.io/gitea/models/git"
+	issues_model "code.gitea.io/gitea/models/issues"
+	access_model "code.gitea.io/gitea/models/perm/access"
+	repo_model "code.gitea.io/gitea/models/repo"
+	unit_model "code.gitea.io/gitea/models/unit"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/gitrepo"
+	"code.gitea.io/gitea/modules/web"
+	"code.gitea.io/gitea/routers/utils"
+	"code.gitea.io/gitea/services/context"
+	"code.gitea.io/gitea/services/forms"
+	repo_service "code.gitea.io/gitea/services/repository"
+)
+
+func CreateBranchFromIssue(ctx *context.Context) {
+	if ctx.HasError() { // form binding error check
+		ctx.JSONError(ctx.GetErrMsg())
+		return
+	}
+
+	issue := GetActionIssue(ctx)
+	if ctx.Written() {
+		return
+	}
+
+	if issue.IsPull {
+		ctx.Flash.Error(ctx.Tr("repo.issues.create_branch_from_issue_error_is_pull"))
+		ctx.JSONRedirect(issue.Link())
+		return
+	}
+
+	form := web.GetForm(ctx).(*forms.NewBranchForm)
+	repo := ctx.Repo.Repository
+	gitRepo := ctx.Repo.GitRepo
+	// if create branch in a forked repository
+	if form.RepoID > 0 && form.RepoID != repo.ID {
+		var err error
+		repo, err = repo_model.GetRepositoryByID(ctx, form.RepoID)
+		if err != nil {
+			ctx.ServerError("GetRepositoryByID", err)
+			return
+		}
+		gitRepo, err = gitrepo.OpenRepository(ctx, repo)
+		if err != nil {
+			ctx.ServerError("OpenRepository", err)
+			return
+		}
+		defer gitRepo.Close()
+	}
+
+	perm, err := access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
+	if err != nil {
+		ctx.ServerError("GetUserRepoPermission", err)
+		return
+	}
+
+	canCreateBranch := perm.CanWrite(unit_model.TypeCode) && repo.CanCreateBranch()
+	if !canCreateBranch {
+		ctx.Error(http.StatusForbidden, "No permission to create branch in this repository")
+		return
+	}
+
+	if err := repo_service.CreateNewBranch(ctx, ctx.Doer, repo, gitRepo, form.SourceBranchName, form.NewBranchName); err != nil {
+		switch {
+		case git_model.IsErrBranchAlreadyExists(err) || git.IsErrPushOutOfDate(err):
+			ctx.JSONError(ctx.Tr("repo.branch.branch_already_exists", form.NewBranchName))
+		case git_model.IsErrBranchNameConflict(err):
+			e := err.(git_model.ErrBranchNameConflict)
+			ctx.JSONError(ctx.Tr("repo.branch.branch_name_conflict", form.NewBranchName, e.BranchName))
+		case git_model.IsErrBranchNotExist(err):
+			ctx.JSONError(ctx.Tr("repo.branch.branch_not_exist", form.SourceBranchName))
+		case git.IsErrPushRejected(err):
+			e := err.(*git.ErrPushRejected)
+			if len(e.Message) == 0 {
+				ctx.Flash.Error(ctx.Tr("repo.editor.push_rejected_no_message"))
+			} else {
+				flashError, err := ctx.RenderToHTML(tplAlertDetails, map[string]any{
+					"Message": ctx.Tr("repo.editor.push_rejected"),
+					"Summary": ctx.Tr("repo.editor.push_rejected_summary"),
+					"Details": utils.SanitizeFlashErrorString(e.Message),
+				})
+				if err != nil {
+					ctx.ServerError("UpdatePullRequest.HTMLString", err)
+					return
+				}
+				ctx.JSONError(flashError)
+			}
+		default:
+			ctx.ServerError("CreateNewBranch", err)
+		}
+		return
+	}
+
+	if err := issues_model.CreateIssueDevLink(ctx, &issues_model.IssueDevLink{
+		IssueID:      issue.ID,
+		LinkType:     issues_model.IssueDevLinkTypeBranch,
+		LinkedRepoID: repo.ID,
+		LinkIndex:    form.NewBranchName,
+	}); err != nil {
+		ctx.ServerError("CreateIssueDevLink", err)
+		return
+	}
+
+	ctx.Flash.Success(ctx.Tr("repo.issues.create_branch_from_issue_success", form.NewBranchName))
+	ctx.JSONRedirect(issue.Link())
+}

routers/web/repo/issue_view.go

@@ -362,6 +362,7 @@ func ViewIssue(ctx *context.Context) {
 		},
 		prepareIssueViewCommentsAndSidebarParticipants,
 		preparePullViewReviewAndMerge,
+		prepareIssueViewSidebarDevLinks,
 		prepareIssueViewSidebarWatch,
 		prepareIssueViewSidebarTimeTracker,
 		prepareIssueViewSidebarDependency,
@@ -946,3 +947,50 @@ func prepareIssueViewContent(ctx *context.Context, issue *issues_model.Issue) {
 	}
 	ctx.Data["Issue"] = issue
 }
+
+func prepareIssueViewSidebarDevLinks(ctx *context.Context, issue *issues_model.Issue) {
+	if issue.IsPull {
+		return
+	}
+
+	devLinks, err := issue_service.FindIssueDevLinksByIssue(ctx, issue)
+	if err != nil {
+		ctx.ServerError("FindIssueDevLinksByIssue", err)
+		return
+	}
+	ctx.Data["DevLinks"] = devLinks
+	for _, link := range devLinks {
+		if link.LinkType == issues_model.IssueDevLinkTypePullRequest &&
+			!(link.PullRequest.Issue.IsClosed && !link.PullRequest.HasMerged) {
+			ctx.Data["MaybeFixed"] = link.PullRequest
+			break
+		}
+	}
+
+	if !ctx.IsSigned {
+		return
+	}
+
+	// Get all possible repositories for creating branch model dropdown list
+	forkedRepos, err := repo_model.GetForksByUserAndOrgs(ctx, ctx.Doer, ctx.Repo.Repository)
+	if err != nil {
+		ctx.ServerError("GetForksByUserAndOrgs", err)
+		return
+	}
+	allowedRepos := make([]*repo_model.Repository, 0, len(forkedRepos)+1)
+	for _, repo := range append(forkedRepos, ctx.Repo.Repository) {
+		perm, err := access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
+		if err != nil {
+			ctx.ServerError("GetUserRepoPermission", err)
+			return
+		}
+		if perm.CanWrite(unit.TypeCode) {
+			allowedRepos = append(allowedRepos, repo)
+		}
+	}
+
+	ctx.Data["AllowedRepos"] = allowedRepos
+	ctx.Data["ShowCreateBranchLink"] = !ctx.Repo.Repository.IsEmpty &&
+		ctx.Repo.Repository.CanCreateBranch() &&
+		len(allowedRepos) > 0 && !issue.IsClosed
+}

routers/web/web.go

@@ -1240,6 +1240,7 @@ func registerRoutes(m *web.Router) {
 				m.Post("/lock", reqRepoIssuesOrPullsWriter, web.Bind(forms.IssueLockForm{}), repo.LockIssue)
 				m.Post("/unlock", reqRepoIssuesOrPullsWriter, repo.UnlockIssue)
 				m.Post("/delete", reqRepoAdmin, repo.DeleteIssue)
+				m.Post("/create_branch", web.Bind(forms.NewBranchForm{}), repo.CreateBranchFromIssue)
 			}, context.RepoMustNotBeArchived())
 
 			m.Group("/{index}", func() {

services/forms/repo_branch_form.go

@@ -14,9 +14,11 @@ import (
 
 // NewBranchForm form for creating a new branch
 type NewBranchForm struct {
-	NewBranchName string `binding:"Required;MaxSize(100);GitRefName"`
-	CurrentPath   string
-	CreateTag     bool
+	NewBranchName    string `binding:"Required;MaxSize(100);GitRefName"`
+	RepoID           int64
+	SourceBranchName string
+	CurrentPath      string
+	CreateTag        bool
 }
 
 // Validate validates the fields