Allow multiple projects per issue and pull requests

models/issues/issue.go

@@ -74,17 +74,18 @@ type Issue struct {
 	PosterID          int64                  `xorm:"INDEX"`
 	Poster            *user_model.User       `xorm:"-"`
 	OriginalAuthor    string
-	OriginalAuthorID  int64                  `xorm:"index"`
-	Title             string                 `xorm:"name"`
-	Content           string                 `xorm:"LONGTEXT"`
-	RenderedContent   template.HTML          `xorm:"-"`
-	ContentVersion    int                    `xorm:"NOT NULL DEFAULT 0"`
-	Labels            []*Label               `xorm:"-"`
-	isLabelsLoaded    bool                   `xorm:"-"`
-	MilestoneID       int64                  `xorm:"INDEX"`
-	Milestone         *Milestone             `xorm:"-"`
-	isMilestoneLoaded bool                   `xorm:"-"`
-	Project           *project_model.Project `xorm:"-"`
+	OriginalAuthorID  int64                    `xorm:"index"`
+	Title             string                   `xorm:"name"`
+	Content           string                   `xorm:"LONGTEXT"`
+	RenderedContent   template.HTML            `xorm:"-"`
+	ContentVersion    int                      `xorm:"NOT NULL DEFAULT 0"`
+	Labels            []*Label                 `xorm:"-"`
+	isLabelsLoaded    bool                     `xorm:"-"`
+	MilestoneID       int64                    `xorm:"INDEX"`
+	Milestone         *Milestone               `xorm:"-"`
+	isMilestoneLoaded bool                     `xorm:"-"`
+	Projects          []*project_model.Project `xorm:"-"`
+	isProjectsLoaded  bool                     `xorm:"-"`
 	Priority          int
 	AssigneeID        int64            `xorm:"-"`
 	Assignee          *user_model.User `xorm:"-"`
@@ -327,7 +328,7 @@ func (issue *Issue) LoadAttributes(ctx context.Context) (err error) {
 		return err
 	}
 
-	if err = issue.LoadProject(ctx); err != nil {
+	if err = issue.LoadProjects(ctx); err != nil {
 		return err
 	}
 
@@ -377,6 +378,7 @@ func (issue *Issue) ResetAttributesLoaded() {
 	issue.isMilestoneLoaded = false
 	issue.isAttachmentsLoaded = false
 	issue.isAssigneeLoaded = false
+	issue.isProjectsLoaded = false
 }
 
 // GetIsRead load the `IsRead` field of the issue

models/issues/issue_list.go

@@ -185,7 +185,7 @@ func (issues IssueList) LoadMilestones(ctx context.Context) error {
 
 func (issues IssueList) LoadProjects(ctx context.Context) error {
 	issueIDs := issues.getIssueIDs()
-	projectMaps := make(map[int64]*project_model.Project, len(issues))
+	issueProjectMaps := make(map[int64][]*project_model.Project, len(issues))
 	left := len(issueIDs)
 
 	type projectWithIssueID struct {
@@ -207,14 +207,15 @@ func (issues IssueList) LoadProjects(ctx context.Context) error {
 			return err
 		}
 		for _, project := range projects {
-			projectMaps[project.IssueID] = project.Project
+			issueProjectMaps[project.IssueID] = append(issueProjectMaps[project.IssueID], project.Project)
 		}
 		left -= limit
 		issueIDs = issueIDs[limit:]
 	}
 
 	for _, issue := range issues {
-		issue.Project = projectMaps[issue.ID]
+		issue.Projects = issueProjectMaps[issue.ID]
+		issue.isProjectsLoaded = true
 	}
 	return nil
 }

models/issues/issue_list_test.go

@@ -65,10 +65,10 @@ func TestIssueList_LoadAttributes(t *testing.T) {
 		}
 		if issue.ID == int64(1) {
 			assert.Equal(t, int64(400), issue.TotalTrackedTime)
-			assert.NotNil(t, issue.Project)
-			assert.Equal(t, int64(1), issue.Project.ID)
+			assert.NotNil(t, issue.Projects[0])
+			assert.Equal(t, int64(1), issue.Projects[0].ID)
 		} else {
-			assert.Nil(t, issue.Project)
+			assert.Nil(t, issue.Projects)
 		}
 	}
 }

models/issues/issue_project.go

@@ -12,29 +12,34 @@ import (
 	"code.gitea.io/gitea/modules/util"
 )
 
-// LoadProject load the project the issue was assigned to
-func (issue *Issue) LoadProject(ctx context.Context) (err error) {
-	if issue.Project == nil {
-		var p project_model.Project
-		has, err := db.GetEngine(ctx).Table("project").
+// LoadProjects loads all projects the issue is assigned to
+func (issue *Issue) LoadProjects(ctx context.Context) (err error) {
+	if !issue.isProjectsLoaded {
+		err = db.GetEngine(ctx).Table("project").
 			Join("INNER", "project_issue", "project.id=project_issue.project_id").
-			Where("project_issue.issue_id = ?", issue.ID).Get(&p)
-		if err != nil {
-			return err
-		} else if has {
-			issue.Project = &p
+			Where("project_issue.issue_id = ?", issue.ID).Find(&issue.Projects)
+		if err == nil {
+			issue.isProjectsLoaded = true
 		}
 	}
 	return err
 }
 
-func (issue *Issue) projectID(ctx context.Context) int64 {
-	var ip project_model.ProjectIssue
-	has, err := db.GetEngine(ctx).Where("issue_id=?", issue.ID).Get(&ip)
-	if err != nil || !has {
-		return 0
+func (issue *Issue) projectIDs(ctx context.Context) ([]int64, error) {
+	var pis []project_model.ProjectIssue
+	if err := db.GetEngine(ctx).Table("project_issue").Where("issue_id = ?", issue.ID).Cols("project_id").Find(&pis); err != nil {
+		return nil, err
 	}
-	return ip.ProjectID
+
+	if len(pis) == 0 {
+		return []int64{}, nil
+	}
+
+	ids := make([]int64, 0, len(pis))
+	for _, pi := range pis {
+		ids = append(ids, pi.ProjectID)
+	}
+	return ids, nil
 }
 
 // ProjectColumnID return project column id if issue was assigned to one
@@ -68,7 +73,7 @@ func LoadProjectIssueColumnMap(ctx context.Context, projectID, defaultColumnID i
 func LoadIssuesFromColumn(ctx context.Context, b *project_model.Column, opts *IssuesOptions) (IssueList, error) {
 	issueList, err := Issues(ctx, opts.Copy(func(o *IssuesOptions) {
 		o.ProjectColumnID = b.ID
-		o.ProjectID = b.ProjectID
+		o.ProjectIDs = []int64{b.ProjectID}
 		o.SortType = "project-column-sorting"
 	}))
 	if err != nil {
@@ -78,7 +83,7 @@ func LoadIssuesFromColumn(ctx context.Context, b *project_model.Column, opts *Is
 	if b.Default {
 		issues, err := Issues(ctx, opts.Copy(func(o *IssuesOptions) {
 			o.ProjectColumnID = db.NoConditionID
-			o.ProjectID = b.ProjectID
+			o.ProjectIDs = []int64{b.ProjectID}
 			o.SortType = "project-column-sorting"
 		}))
 		if err != nil {
@@ -94,73 +99,103 @@ func LoadIssuesFromColumn(ctx context.Context, b *project_model.Column, opts *Is
 	return issueList, nil
 }
 
-// IssueAssignOrRemoveProject changes the project associated with an issue
-// If newProjectID is 0, the issue is removed from the project
-func IssueAssignOrRemoveProject(ctx context.Context, issue *Issue, doer *user_model.User, newProjectID, newColumnID int64) error {
+// IssueAssignOrRemoveProject updates the projects associated with an issue.
+// It adds projects that are in newProjectIDs but not currently assigned, and removes
+// projects that are currently assigned but not in newProjectIDs. If newProjectIDs is
+// empty or nil, all projects are removed from the issue.
+func IssueAssignOrRemoveProject(ctx context.Context, issue *Issue, doer *user_model.User, newProjectIDs []int64, newColumnID int64) error {
 	return db.WithTx(ctx, func(ctx context.Context) error {
-		oldProjectID := issue.projectID(ctx)
+		oldProjectIDs, err := issue.projectIDs(ctx)
+		if err != nil {
+			return err
+		}
 
 		if err := issue.LoadRepo(ctx); err != nil {
 			return err
 		}
 
-		// Only check if we add a new project and not remove it.
-		if newProjectID > 0 {
-			newProject, err := project_model.GetProjectByID(ctx, newProjectID)
+		projectsToAdd, projectsToRemove := util.DiffSlice(oldProjectIDs, newProjectIDs)
+
+		if len(projectsToRemove) > 0 {
+			if _, err := db.GetEngine(ctx).Where("issue_id=?", issue.ID).In("project_id", projectsToRemove).Delete(&project_model.ProjectIssue{}); err != nil {
+				return err
+			}
+			for _, projectID := range projectsToRemove {
+				if _, err := CreateComment(ctx, &CreateCommentOptions{
+					Type:         CommentTypeProject,
+					Doer:         doer,
+					Repo:         issue.Repo,
+					Issue:        issue,
+					OldProjectID: projectID,
+					ProjectID:    0,
+				}); err != nil {
+					return err
+				}
+			}
+		}
+
+		if len(projectsToAdd) == 0 {
+			return nil
+		}
+
+		pi := make([]*project_model.ProjectIssue, 0, len(projectsToAdd))
+
+		for _, projectID := range projectsToAdd {
+			if projectID == 0 {
+				continue
+			}
+			newProject, err := project_model.GetProjectByID(ctx, projectID)
 			if err != nil {
 				return err
 			}
 			if !newProject.CanBeAccessedByOwnerRepo(issue.Repo.OwnerID, issue.Repo) {
 				return util.NewPermissionDeniedErrorf("issue %d can't be accessed by project %d", issue.ID, newProject.ID)
 			}
-			if newColumnID == 0 {
-				newDefaultColumn, err := newProject.MustDefaultColumn(ctx)
+
+			projectColumnID := newColumnID
+			if projectColumnID == 0 {
+				defaultColumn, err := newProject.MustDefaultColumn(ctx)
 				if err != nil {
 					return err
 				}
-				newColumnID = newDefaultColumn.ID
+				projectColumnID = defaultColumn.ID
 			}
-		}
 
-		if _, err := db.GetEngine(ctx).Where("project_issue.issue_id=?", issue.ID).Delete(&project_model.ProjectIssue{}); err != nil {
-			return err
-		}
+			res := struct {
+				MaxSorting int64
+				IssueCount int64
+			}{}
+			if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as issue_count").Table("project_issue").
+				And("project_id=?", projectID).
+				And("project_board_id=?", projectColumnID).
+				Get(&res); err != nil {
+				return err
+			}
+			newSorting := util.Iif(res.IssueCount > 0, res.MaxSorting+1, 0)
+
+			pi = append(pi, &project_model.ProjectIssue{
+				IssueID:         issue.ID,
+				ProjectID:       projectID,
+				ProjectColumnID: projectColumnID,
+				Sorting:         newSorting,
+			})
 
-		if oldProjectID > 0 || newProjectID > 0 {
 			if _, err := CreateComment(ctx, &CreateCommentOptions{
 				Type:         CommentTypeProject,
 				Doer:         doer,
 				Repo:         issue.Repo,
 				Issue:        issue,
-				OldProjectID: oldProjectID,
-				ProjectID:    newProjectID,
+				OldProjectID: 0,
+				ProjectID:    projectID,
 			}); err != nil {
 				return err
 			}
 		}
-		if newProjectID == 0 {
-			return nil
-		}
-		if newColumnID == 0 {
-			panic("newColumnID must not be zero") // shouldn't happen
-		}
 
-		res := struct {
-			MaxSorting int64
-			IssueCount int64
-		}{}
-		if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as issue_count").Table("project_issue").
-			Where("project_id=?", newProjectID).
-			And("project_board_id=?", newColumnID).
-			Get(&res); err != nil {
-			return err
+		if len(pi) > 0 {
+			return db.Insert(ctx, pi)
 		}
-		newSorting := util.Iif(res.IssueCount > 0, res.MaxSorting+1, 0)
-		return db.Insert(ctx, &project_model.ProjectIssue{
-			IssueID:         issue.ID,
-			ProjectID:       newProjectID,
-			ProjectColumnID: newColumnID,
-			Sorting:         newSorting,
-		})
+
+		return nil
 	})
 }