feat: update gitea vendor

package/gitea/source/services/projects/issue.go

@@ -9,12 +9,13 @@ import (
 	"slices"
 	"strings"
 
-	"code.gitea.io/gitea/models/db"
-	issues_model "code.gitea.io/gitea/models/issues"
-	project_model "code.gitea.io/gitea/models/project"
-	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/container"
-	"code.gitea.io/gitea/modules/optional"
+	"gitea.dev/models/db"
+	issues_model "gitea.dev/models/issues"
+	project_model "gitea.dev/models/project"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/optional"
+
+	"xorm.io/builder"
 )
 
 // MoveIssuesOnProjectColumn moves or keeps issues in a column and sorts them inside that column
@@ -59,11 +60,13 @@ func MoveIssuesOnProjectColumn(ctx context.Context, doer *user_model.User, colum
 				continue
 			}
 
-			projectColumnID, err := curIssue.ProjectColumnID(ctx)
+			projectColumnMap, err := curIssue.ProjectColumnMap(ctx)
 			if err != nil {
 				return err
 			}
 
+			projectColumnID := projectColumnMap[column.ProjectID]
+
 			if projectColumnID != column.ID {
 				// add timeline to issue
 				if _, err := issues_model.CreateComment(ctx, &issues_model.CreateCommentOptions{
@@ -80,7 +83,16 @@ func MoveIssuesOnProjectColumn(ctx context.Context, doer *user_model.User, colum
 				}
 			}
 
-			_, err = db.Exec(ctx, "UPDATE `project_issue` SET project_board_id=?, sorting=? WHERE issue_id=?", column.ID, sorting, issueID)
+			// Update the column and sorting for this specific issue in this specific project.
+			// IMPORTANT: The WHERE clause must include both issue_id AND project_id to ensure
+			// that moving an issue's column in one project doesn't affect its column in other
+			// projects when the issue is assigned to multiple projects.
+			_, err = db.GetEngine(ctx).Table("project_issue").
+				Where("issue_id = ? AND project_id = ?", issueID, column.ProjectID).
+				Update(map[string]any{
+					"project_board_id": column.ID,
+					"sorting":          sorting,
+				})
 			if err != nil {
 				return err
 			}
@@ -89,35 +101,22 @@ func MoveIssuesOnProjectColumn(ctx context.Context, doer *user_model.User, colum
 	})
 }
 
-func LoadIssuesAssigneesForProject(ctx context.Context, issuesMap map[int64]issues_model.IssueList) ([]*user_model.User, error) {
-	var issueList issues_model.IssueList
-	for _, colIssues := range issuesMap {
-		issueList = append(issueList, colIssues...)
-	}
-	err := issueList.LoadAssignees(ctx)
+func LoadIssuesAssigneesForProject(ctx context.Context, projectID int64) (users []*user_model.User, _ error) {
+	sub := builder.Select("distinct issue_assignees.assignee_id").
+		From("project_issue").Join("INNER", "issue_assignees", "project_issue.issue_id=issue_assignees.issue_id").
+		Where(builder.Eq{"project_issue.project_id": projectID})
+	err := db.GetEngine(ctx).Table("`user`").Where(builder.In("id", sub)).Find(&users)
 	if err != nil {
 		return nil, err
 	}
-	users := make([]*user_model.User, 0, len(issueList))
-	usersAdded := container.Set[int64]{}
-	for _, issue := range issueList {
-		for _, assignee := range issue.Assignees {
-			if !usersAdded.Contains(assignee.ID) {
-				usersAdded.Add(assignee.ID)
-				users = append(users, assignee)
-			}
-		}
-	}
-	slices.SortFunc(users, func(a, b *user_model.User) int {
-		return strings.Compare(a.Name, b.Name)
-	})
+	slices.SortFunc(users, func(a, b *user_model.User) int { return strings.Compare(a.Name, b.Name) })
 	return users, nil
 }
 
 // LoadIssuesFromProject load issues assigned to each project column inside the given project
 func LoadIssuesFromProject(ctx context.Context, project *project_model.Project, opts *issues_model.IssuesOptions) (results map[int64]issues_model.IssueList, _ error) {
 	issueList, err := issues_model.Issues(ctx, opts.Copy(func(o *issues_model.IssuesOptions) {
-		o.ProjectID = project.ID
+		o.ProjectIDs = []int64{project.ID}
 		o.SortType = "project-column-sorting"
 	}))
 	if err != nil {
@@ -211,10 +210,10 @@ func LoadIssueNumbersForProject(ctx context.Context, project *project_model.Proj
 
 	// for user or org projects, we need to check access permissions
 	opts := issues_model.IssuesOptions{
-		ProjectID: project.ID,
-		Doer:      doer,
-		AllPublic: doer == nil,
-		Owner:     project.Owner,
+		ProjectIDs: []int64{project.ID},
+		Doer:       doer,
+		AllPublic:  doer == nil,
+		Owner:      project.Owner,
 	}
 
 	var err error

package/gitea/source/services/projects/issue_test.go

@@ -6,16 +6,15 @@ package project
 import (
 	"testing"
 
-	"code.gitea.io/gitea/models/db"
-	issues_model "code.gitea.io/gitea/models/issues"
-	org_model "code.gitea.io/gitea/models/organization"
-	project_model "code.gitea.io/gitea/models/project"
-	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/models/unittest"
-	user_model "code.gitea.io/gitea/models/user"
+	"gitea.dev/models/db"
+	issues_model "gitea.dev/models/issues"
+	org_model "gitea.dev/models/organization"
+	project_model "gitea.dev/models/project"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+	user_model "gitea.dev/models/user"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Projects(t *testing.T) {
@@ -25,6 +24,9 @@ func Test_Projects(t *testing.T) {
 	user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 	org3 := unittest.AssertExistsAndLoadBean(t, &org_model.Organization{ID: 3})
 	user4 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 4})
+	// user15 is on org3's team7 (write access to the public repo32 only), so it can see org3 public repos
+	// but has no access to the private repo3 — a genuine "no permission to the private repo" org member.
+	user15 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 15})
 
 	t.Run("User projects", func(t *testing.T) {
 		pi1 := project_model.ProjectIssue{
@@ -102,28 +104,18 @@ func Test_Projects(t *testing.T) {
 			assert.NoError(t, err)
 		}()
 
-		column1 := project_model.Column{
-			Title:     "column 1",
-			ProjectID: project1.ID,
-		}
-		err = project_model.NewColumn(t.Context(), &column1)
-		assert.NoError(t, err)
-
-		column2 := project_model.Column{
-			Title:     "column 2",
-			ProjectID: project1.ID,
-		}
-		err = project_model.NewColumn(t.Context(), &column2)
+		// Get the default column created by the template (issues will be assigned here)
+		defaultColumn, err := project1.MustDefaultColumn(t.Context())
 		assert.NoError(t, err)
 
 		// issue 6 belongs to private repo 3 under org 3
 		issue6 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 6})
-		err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue6, user2, project1.ID, column1.ID)
+		err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue6, user2, []int64{project1.ID})
 		assert.NoError(t, err)
 
 		// issue 16 belongs to public repo 16 under org 3
 		issue16 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 16})
-		err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue16, user2, project1.ID, column1.ID)
+		err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue16, user2, []int64{project1.ID})
 		assert.NoError(t, err)
 
 		projects, err := db.Find[project_model.Project](t.Context(), project_model.SearchOptions{
@@ -139,8 +131,8 @@ func Test_Projects(t *testing.T) {
 				Doer:  userAdmin,
 			})
 			assert.NoError(t, err)
-			assert.Len(t, columnIssues, 1)             // column1 has 2 issues, 6 will not contains here because 0 issues
-			assert.Len(t, columnIssues[column1.ID], 2) // user2 can visit both issues, one from public repository one from private repository
+			assert.Len(t, columnIssues, 1)                   // default column has 2 issues
+			assert.Len(t, columnIssues[defaultColumn.ID], 2) // admin can visit both issues, one from public repository one from private repository
 		})
 
 		t.Run("Anonymous user", func(t *testing.T) {
@@ -149,17 +141,31 @@ func Test_Projects(t *testing.T) {
 			})
 			assert.NoError(t, err)
 			assert.Len(t, columnIssues, 1)
-			assert.Len(t, columnIssues[column1.ID], 1) // anonymous user can only visit public repo issues
+			assert.Len(t, columnIssues[defaultColumn.ID], 1) // anonymous user can only visit public repo issues
 		})
 
 		t.Run("Authenticated user with no permission to the private repo", func(t *testing.T) {
+			// user2 is on org3's Owners team and has owner access to the private repo3, so it is not a
+			// valid "no permission" subject; user15 has no access to repo3 but can see the public repo32.
+			columnIssues, err := LoadIssuesFromProject(t.Context(), projects[0], &issues_model.IssuesOptions{
+				Owner: org3.AsUser(),
+				Doer:  user15,
+			})
+			assert.NoError(t, err)
+			assert.Len(t, columnIssues, 1)
+			assert.Len(t, columnIssues[defaultColumn.ID], 1) // user15 can only visit public repo issues
+		})
+
+		t.Run("Org owner team member", func(t *testing.T) {
+			// user2 is on org3's Owners team, so it has access to the private repo3 and must see both the
+			// public and the private issue — the owner-team access that team.authorize grants at runtime.
 			columnIssues, err := LoadIssuesFromProject(t.Context(), projects[0], &issues_model.IssuesOptions{
 				Owner: org3.AsUser(),
 				Doer:  user2,
 			})
 			assert.NoError(t, err)
 			assert.Len(t, columnIssues, 1)
-			assert.Len(t, columnIssues[column1.ID], 1) // user4 can only visit public repo issues
+			assert.Len(t, columnIssues[defaultColumn.ID], 2) // owner-team member visits both public and private issues
 		})
 	})
 
@@ -208,18 +214,4 @@ func Test_Projects(t *testing.T) {
 			assert.Len(t, columnIssues[3], 1)
 		})
 	})
-
-	t.Run("LoadIssuesAssigneesForProject", func(t *testing.T) {
-		issuesMap := map[int64]issues_model.IssueList{}
-		issue1 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-		issue6 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 6})
-		issuesMap[1] = issues_model.IssueList{issue1}
-		issuesMap[2] = issues_model.IssueList{issue6}
-		assignees, err := LoadIssuesAssigneesForProject(t.Context(), issuesMap)
-		require.NoError(t, err)
-		require.Len(t, assignees, 3)
-		require.Equal(t, "user1", assignees[0].Name)
-		require.Equal(t, "user10", assignees[1].Name)
-		require.Equal(t, "user2", assignees[2].Name)
-	})
 }

package/gitea/source/services/projects/main_test.go

@@ -6,10 +6,10 @@ package project
 import (
 	"testing"
 
-	"code.gitea.io/gitea/models/unittest"
+	"gitea.dev/models/unittest"
 
-	_ "code.gitea.io/gitea/models/actions"
-	_ "code.gitea.io/gitea/models/activities"
+	_ "gitea.dev/models/actions"
+	_ "gitea.dev/models/activities"
 )
 
 func TestMain(m *testing.M) {