feat(project): SSE push updates for project board pages (#7)
This commit was merged in pull request #7.
This commit is contained in:
@@ -0,0 +1,324 @@
|
||||
// Copyright 2026 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// Package project_events publishes project board mutations as Server-Sent
|
||||
// Events so other browser tabs viewing the same board can update their DOM
|
||||
// in near real time.
|
||||
//
|
||||
// Each public Publish* helper marshals a typed payload to JSON, wraps it in
|
||||
// an *eventsource.Event whose Name is "project-board.{project_id}", and
|
||||
// fans the event out to every currently connected user that has read
|
||||
// access to the project. All publish helpers are non-blocking: they spawn
|
||||
// a goroutine so request handlers do not stall on slow consumers.
|
||||
package project_events
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strconv"
|
||||
|
||||
access_model "code.gitea.io/gitea/models/perm/access"
|
||||
project_model "code.gitea.io/gitea/models/project"
|
||||
repo_model "code.gitea.io/gitea/models/repo"
|
||||
"code.gitea.io/gitea/models/unit"
|
||||
user_model "code.gitea.io/gitea/models/user"
|
||||
"code.gitea.io/gitea/modules/eventsource"
|
||||
"code.gitea.io/gitea/modules/json"
|
||||
"code.gitea.io/gitea/modules/log"
|
||||
)
|
||||
|
||||
// sessionTagCtxKey is the context key under which the X-Session-Tag value
|
||||
// from the originating HTTP request is stashed. Publishers read it via
|
||||
// SessionTagFromContext to attach to outgoing events so the originating
|
||||
// browser tab can suppress its own echo.
|
||||
type sessionTagCtxKey struct{}
|
||||
|
||||
// WithSessionTag returns ctx decorated with the provided session tag.
|
||||
// Web/API middleware reads the X-Session-Tag header and calls this so
|
||||
// service- and model-layer publishers can pull the tag back out.
|
||||
func WithSessionTag(ctx context.Context, tag string) context.Context {
|
||||
if tag == "" {
|
||||
return ctx
|
||||
}
|
||||
return context.WithValue(ctx, sessionTagCtxKey{}, tag)
|
||||
}
|
||||
|
||||
// SessionTagFromContext returns the session tag previously stored via
|
||||
// WithSessionTag, or "" when none was set.
|
||||
func SessionTagFromContext(ctx context.Context) string {
|
||||
if v, ok := ctx.Value(sessionTagCtxKey{}).(string); ok {
|
||||
return v
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// Event payload structs ------------------------------------------------------
|
||||
|
||||
// CardMoved is emitted when an issue is moved between columns or reordered
|
||||
// within a column.
|
||||
type CardMoved struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
IssueID int64 `json:"issue_id"`
|
||||
FromColumnID int64 `json:"from_column_id"`
|
||||
ToColumnID int64 `json:"to_column_id"`
|
||||
Sorting int64 `json:"sorting"`
|
||||
SessionTag string `json:"session_tag,omitempty"`
|
||||
}
|
||||
|
||||
// CardLinked is emitted when an issue is added to a project's default column.
|
||||
type CardLinked struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
IssueID int64 `json:"issue_id"`
|
||||
ColumnID int64 `json:"column_id"`
|
||||
SessionTag string `json:"session_tag,omitempty"`
|
||||
}
|
||||
|
||||
// CardUnlinked is emitted when an issue is removed from a project.
|
||||
type CardUnlinked struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
IssueID int64 `json:"issue_id"`
|
||||
SessionTag string `json:"session_tag,omitempty"`
|
||||
}
|
||||
|
||||
// ColumnCreated is emitted when a new column is added to a project.
|
||||
type ColumnCreated struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
ColumnID int64 `json:"column_id"`
|
||||
Title string `json:"title"`
|
||||
Color string `json:"color"`
|
||||
Sorting int64 `json:"sorting"`
|
||||
IsDefault bool `json:"is_default"`
|
||||
}
|
||||
|
||||
// ColumnUpdated is emitted when a column's title, color, or sorting changes.
|
||||
type ColumnUpdated struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
ColumnID int64 `json:"column_id"`
|
||||
Title string `json:"title"`
|
||||
Color string `json:"color"`
|
||||
Sorting int64 `json:"sorting"`
|
||||
}
|
||||
|
||||
// ColumnDeleted is emitted when a column is removed from a project.
|
||||
// Deletion implicitly relocates issues to the default column, so the
|
||||
// publisher will also emit one CardMoved per affected issue; the frontend
|
||||
// only needs to drop the column and react to the per-issue moves.
|
||||
type ColumnDeleted struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
ColumnID int64 `json:"column_id"`
|
||||
}
|
||||
|
||||
// ColumnSort is one entry in a ColumnReordered batch.
|
||||
type ColumnSort struct {
|
||||
ColumnID int64 `json:"column_id"`
|
||||
Sorting int64 `json:"sorting"`
|
||||
}
|
||||
|
||||
// ColumnReordered is emitted when columns within a project are dragged into
|
||||
// a new order.
|
||||
type ColumnReordered struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
Columns []ColumnSort `json:"columns"`
|
||||
}
|
||||
|
||||
// ProjectUpdated is emitted when project metadata (title, description,
|
||||
// card type, open/closed state) changes.
|
||||
type ProjectUpdated struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
Title string `json:"title"`
|
||||
Description string `json:"description"`
|
||||
CardType string `json:"card_type"`
|
||||
IsClosed bool `json:"is_closed"`
|
||||
}
|
||||
|
||||
// ProjectDeleted is emitted when a project is deleted.
|
||||
type ProjectDeleted struct {
|
||||
ProjectID int64 `json:"project_id"`
|
||||
}
|
||||
|
||||
// Broadcast plumbing ---------------------------------------------------------
|
||||
|
||||
// broadcastFn is the package-level seam used to send an event to a set of
|
||||
// uids. Tests swap it out to capture calls without touching the real
|
||||
// eventsource manager.
|
||||
var broadcastFn = defaultBroadcast
|
||||
|
||||
func defaultBroadcast(uids []int64, event *eventsource.Event) {
|
||||
mgr := eventsource.GetManager()
|
||||
for _, uid := range uids {
|
||||
mgr.SendMessage(uid, event)
|
||||
}
|
||||
}
|
||||
|
||||
// connectedUIDsLister returns the uid set the broadcast helpers should
|
||||
// consider as candidate recipients. Tests override it to feed a
|
||||
// deterministic list.
|
||||
var connectedUIDsLister = func() []int64 {
|
||||
return eventsource.GetManager().ConnectedUIDs()
|
||||
}
|
||||
|
||||
// projectLookup loads a project by id. Stubbable in tests so the
|
||||
// access-filter logic can be exercised without spinning up a database.
|
||||
var projectLookup = project_model.GetProjectByID
|
||||
|
||||
// projectAccessChecker decides whether the user identified by uid is
|
||||
// allowed to read the given project. Tests stub this to bypass the real
|
||||
// permission system.
|
||||
var projectAccessChecker = canReadProject
|
||||
|
||||
// connectedUIDsWithProjectAccess returns the subset of currently connected
|
||||
// uids that the access checker confirms can read projectID.
|
||||
func connectedUIDsWithProjectAccess(ctx context.Context, projectID int64) []int64 {
|
||||
uids := connectedUIDsLister()
|
||||
if len(uids) == 0 {
|
||||
return nil
|
||||
}
|
||||
project, err := projectLookup(ctx, projectID)
|
||||
if err != nil {
|
||||
log.Debug("project_events: GetProjectByID(%d) failed: %v", projectID, err)
|
||||
return nil
|
||||
}
|
||||
allowed := make([]int64, 0, len(uids))
|
||||
for _, uid := range uids {
|
||||
ok, err := projectAccessChecker(ctx, uid, project)
|
||||
if err != nil {
|
||||
log.Debug("project_events: access check uid=%d project=%d: %v", uid, projectID, err)
|
||||
continue
|
||||
}
|
||||
if ok {
|
||||
allowed = append(allowed, uid)
|
||||
}
|
||||
}
|
||||
return allowed
|
||||
}
|
||||
|
||||
// canReadProject implements the real read-permission check used in
|
||||
// production: repo projects defer to the repo's TypeProjects unit access;
|
||||
// user / org projects fall back to user visibility.
|
||||
func canReadProject(ctx context.Context, uid int64, project *project_model.Project) (bool, error) {
|
||||
user, err := user_model.GetUserByID(ctx, uid)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
if project.RepoID > 0 {
|
||||
var repo *repo_model.Repository
|
||||
if project.Repo != nil {
|
||||
repo = project.Repo
|
||||
} else {
|
||||
repo, err = repo_model.GetRepositoryByID(ctx, project.RepoID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
}
|
||||
// AccessModeRead == 1; we use the literal because the
|
||||
// perm_model package's typed constant would force another
|
||||
// import alias and the meaning is well established here.
|
||||
ok, err := access_model.HasAccessUnit(ctx, user, repo, unit.TypeProjects, 1)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return ok, nil
|
||||
}
|
||||
|
||||
if project.OwnerID > 0 {
|
||||
owner := project.Owner
|
||||
if owner == nil {
|
||||
owner, err = user_model.GetUserByID(ctx, project.OwnerID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
}
|
||||
return user_model.IsUserVisibleToViewer(ctx, owner, user), nil
|
||||
}
|
||||
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// publishEvent is the shared pipeline used by every Publish* helper.
|
||||
// It marshals the payload, builds the SSE Event, looks up authorized
|
||||
// recipients, and fans the event out via broadcastFn. The whole thing
|
||||
// runs inside the calling goroutine; callers should wrap it in `go` so
|
||||
// request handlers stay responsive.
|
||||
func publishEvent(ctx context.Context, projectID int64, payload any) {
|
||||
data, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
log.Error("project_events: marshal payload for project %d: %v", projectID, err)
|
||||
return
|
||||
}
|
||||
event := &eventsource.Event{
|
||||
Name: eventName(projectID),
|
||||
Data: data,
|
||||
}
|
||||
uids := connectedUIDsWithProjectAccess(ctx, projectID)
|
||||
if len(uids) == 0 {
|
||||
return
|
||||
}
|
||||
broadcastFn(uids, event)
|
||||
}
|
||||
|
||||
// eventName returns the SSE event name for a given project id.
|
||||
func eventName(projectID int64) string {
|
||||
return "project-board." + strconv.FormatInt(projectID, 10)
|
||||
}
|
||||
|
||||
// Publishers -----------------------------------------------------------------
|
||||
|
||||
// PublishCardMoved fans out a CardMoved event for the given payload.
|
||||
func PublishCardMoved(ctx context.Context, payload CardMoved) {
|
||||
if payload.SessionTag == "" {
|
||||
payload.SessionTag = SessionTagFromContext(ctx)
|
||||
}
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishCardLinked fans out a CardLinked event for the given payload.
|
||||
func PublishCardLinked(ctx context.Context, payload CardLinked) {
|
||||
if payload.SessionTag == "" {
|
||||
payload.SessionTag = SessionTagFromContext(ctx)
|
||||
}
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishCardUnlinked fans out a CardUnlinked event for the given payload.
|
||||
func PublishCardUnlinked(ctx context.Context, payload CardUnlinked) {
|
||||
if payload.SessionTag == "" {
|
||||
payload.SessionTag = SessionTagFromContext(ctx)
|
||||
}
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishColumnCreated fans out a ColumnCreated event for the given payload.
|
||||
func PublishColumnCreated(ctx context.Context, payload ColumnCreated) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishColumnUpdated fans out a ColumnUpdated event for the given payload.
|
||||
func PublishColumnUpdated(ctx context.Context, payload ColumnUpdated) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishColumnDeleted fans out a ColumnDeleted event for the given payload.
|
||||
func PublishColumnDeleted(ctx context.Context, payload ColumnDeleted) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishColumnReordered fans out a ColumnReordered event for the given payload.
|
||||
func PublishColumnReordered(ctx context.Context, payload ColumnReordered) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishProjectUpdated fans out a ProjectUpdated event for the given payload.
|
||||
func PublishProjectUpdated(ctx context.Context, payload ProjectUpdated) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// PublishProjectDeleted fans out a ProjectDeleted event for the given payload.
|
||||
func PublishProjectDeleted(ctx context.Context, payload ProjectDeleted) {
|
||||
go publishEvent(detach(ctx), payload.ProjectID, payload)
|
||||
}
|
||||
|
||||
// detach strips cancellation/deadline from ctx but preserves stored
|
||||
// values (notably the session tag) so the goroutine outlives the request.
|
||||
func detach(ctx context.Context) context.Context {
|
||||
return context.WithoutCancel(ctx)
|
||||
}
|
||||
@@ -0,0 +1,322 @@
|
||||
// Copyright 2026 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package project_events
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
project_model "code.gitea.io/gitea/models/project"
|
||||
"code.gitea.io/gitea/modules/eventsource"
|
||||
"code.gitea.io/gitea/modules/json"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// capturedCall is one observed broadcast: the recipient uid set plus the
|
||||
// constructed Event.
|
||||
type capturedCall struct {
|
||||
uids []int64
|
||||
event *eventsource.Event
|
||||
}
|
||||
|
||||
// installFakes swaps every package-level seam used by publishEvent for
|
||||
// test doubles: a fake uid lister, a stubbed project lookup that
|
||||
// returns a synthetic project (no DB hit), an "everyone passes" access
|
||||
// checker, and a broadcaster that pushes calls onto a buffered channel.
|
||||
//
|
||||
// The returned restore func reverts every seam; defer it in the test.
|
||||
func installFakes(t *testing.T, uids []int64) (<-chan capturedCall, func()) {
|
||||
t.Helper()
|
||||
|
||||
calls := make(chan capturedCall, 16)
|
||||
|
||||
origBroadcast := broadcastFn
|
||||
origLister := connectedUIDsLister
|
||||
origChecker := projectAccessChecker
|
||||
origLookup := projectLookup
|
||||
|
||||
broadcastFn = func(uids []int64, event *eventsource.Event) {
|
||||
calls <- capturedCall{uids: append([]int64(nil), uids...), event: event}
|
||||
}
|
||||
connectedUIDsLister = func() []int64 {
|
||||
return append([]int64(nil), uids...)
|
||||
}
|
||||
projectLookup = func(_ context.Context, id int64) (*project_model.Project, error) {
|
||||
return &project_model.Project{ID: id}, nil
|
||||
}
|
||||
projectAccessChecker = func(_ context.Context, _ int64, _ *project_model.Project) (bool, error) {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
return calls, func() {
|
||||
broadcastFn = origBroadcast
|
||||
connectedUIDsLister = origLister
|
||||
projectAccessChecker = origChecker
|
||||
projectLookup = origLookup
|
||||
}
|
||||
}
|
||||
|
||||
// awaitCall blocks until one capturedCall arrives or the test deadline
|
||||
// elapses. It fails the test on timeout.
|
||||
func awaitCall(t *testing.T, ch <-chan capturedCall) capturedCall {
|
||||
t.Helper()
|
||||
select {
|
||||
case c := <-ch:
|
||||
return c
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("timed out waiting for broadcast")
|
||||
return capturedCall{}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEventNameFormat(t *testing.T) {
|
||||
assert.Equal(t, "project-board.42", eventName(42))
|
||||
assert.Equal(t, "project-board.0", eventName(0))
|
||||
}
|
||||
|
||||
func TestPublishHelpers_NameAndPayload(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
invoke func(ctx context.Context)
|
||||
wantName string
|
||||
wantData any
|
||||
}{
|
||||
{
|
||||
name: "card.moved",
|
||||
wantName: "project-board.10",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishCardMoved(ctx, CardMoved{
|
||||
ProjectID: 10, IssueID: 7, FromColumnID: 1, ToColumnID: 2, Sorting: 3,
|
||||
})
|
||||
},
|
||||
wantData: CardMoved{ProjectID: 10, IssueID: 7, FromColumnID: 1, ToColumnID: 2, Sorting: 3},
|
||||
},
|
||||
{
|
||||
name: "card.linked",
|
||||
wantName: "project-board.11",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishCardLinked(ctx, CardLinked{ProjectID: 11, IssueID: 8, ColumnID: 9})
|
||||
},
|
||||
wantData: CardLinked{ProjectID: 11, IssueID: 8, ColumnID: 9},
|
||||
},
|
||||
{
|
||||
name: "card.unlinked",
|
||||
wantName: "project-board.12",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishCardUnlinked(ctx, CardUnlinked{ProjectID: 12, IssueID: 8})
|
||||
},
|
||||
wantData: CardUnlinked{ProjectID: 12, IssueID: 8},
|
||||
},
|
||||
{
|
||||
name: "column.created",
|
||||
wantName: "project-board.13",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishColumnCreated(ctx, ColumnCreated{
|
||||
ProjectID: 13, ColumnID: 5, Title: "Backlog", Color: "#ff0000", Sorting: 0, IsDefault: true,
|
||||
})
|
||||
},
|
||||
wantData: ColumnCreated{
|
||||
ProjectID: 13, ColumnID: 5, Title: "Backlog", Color: "#ff0000", Sorting: 0, IsDefault: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "column.updated",
|
||||
wantName: "project-board.14",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishColumnUpdated(ctx, ColumnUpdated{ProjectID: 14, ColumnID: 5, Title: "Done"})
|
||||
},
|
||||
wantData: ColumnUpdated{ProjectID: 14, ColumnID: 5, Title: "Done"},
|
||||
},
|
||||
{
|
||||
name: "column.deleted",
|
||||
wantName: "project-board.15",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishColumnDeleted(ctx, ColumnDeleted{ProjectID: 15, ColumnID: 5})
|
||||
},
|
||||
wantData: ColumnDeleted{ProjectID: 15, ColumnID: 5},
|
||||
},
|
||||
{
|
||||
name: "column.reordered",
|
||||
wantName: "project-board.16",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishColumnReordered(ctx, ColumnReordered{
|
||||
ProjectID: 16,
|
||||
Columns: []ColumnSort{
|
||||
{ColumnID: 1, Sorting: 0},
|
||||
{ColumnID: 2, Sorting: 1},
|
||||
},
|
||||
})
|
||||
},
|
||||
wantData: ColumnReordered{
|
||||
ProjectID: 16,
|
||||
Columns: []ColumnSort{
|
||||
{ColumnID: 1, Sorting: 0},
|
||||
{ColumnID: 2, Sorting: 1},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "project.updated",
|
||||
wantName: "project-board.17",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishProjectUpdated(ctx, ProjectUpdated{
|
||||
ProjectID: 17, Title: "T", Description: "D", CardType: "text_only", IsClosed: false,
|
||||
})
|
||||
},
|
||||
wantData: ProjectUpdated{
|
||||
ProjectID: 17, Title: "T", Description: "D", CardType: "text_only", IsClosed: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "project.deleted",
|
||||
wantName: "project-board.18",
|
||||
invoke: func(ctx context.Context) {
|
||||
PublishProjectDeleted(ctx, ProjectDeleted{ProjectID: 18})
|
||||
},
|
||||
wantData: ProjectDeleted{ProjectID: 18},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
ch, restore := installFakes(t, []int64{1})
|
||||
defer restore()
|
||||
|
||||
tc.invoke(context.Background())
|
||||
|
||||
c := awaitCall(t, ch)
|
||||
assert.Equal(t, tc.wantName, c.event.Name)
|
||||
gotJSON, ok := c.event.Data.([]byte)
|
||||
require.True(t, ok, "Event.Data should be []byte")
|
||||
|
||||
wantJSON, err := json.Marshal(tc.wantData)
|
||||
require.NoError(t, err)
|
||||
assert.JSONEq(t, string(wantJSON), string(gotJSON))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestSessionTagPropagation verifies that when a publish is invoked
|
||||
// inside a context decorated by WithSessionTag, the emitted JSON
|
||||
// payload carries the tag.
|
||||
func TestSessionTagPropagation(t *testing.T) {
|
||||
ch, restore := installFakes(t, []int64{1})
|
||||
defer restore()
|
||||
|
||||
ctx := WithSessionTag(context.Background(), "abc-123")
|
||||
PublishCardMoved(ctx, CardMoved{
|
||||
ProjectID: 99, IssueID: 1, FromColumnID: 1, ToColumnID: 2, Sorting: 0,
|
||||
})
|
||||
|
||||
c := awaitCall(t, ch)
|
||||
var payload CardMoved
|
||||
require.NoError(t, json.Unmarshal(c.event.Data.([]byte), &payload))
|
||||
assert.Equal(t, "abc-123", payload.SessionTag)
|
||||
}
|
||||
|
||||
// TestSessionTagExplicitOverridesContext verifies that an explicit
|
||||
// SessionTag set on the payload struct is preserved.
|
||||
func TestSessionTagExplicitOverridesContext(t *testing.T) {
|
||||
ch, restore := installFakes(t, []int64{1})
|
||||
defer restore()
|
||||
|
||||
ctx := WithSessionTag(context.Background(), "from-ctx")
|
||||
PublishCardMoved(ctx, CardMoved{
|
||||
ProjectID: 1, IssueID: 1, FromColumnID: 1, ToColumnID: 2, Sorting: 0,
|
||||
SessionTag: "explicit",
|
||||
})
|
||||
|
||||
c := awaitCall(t, ch)
|
||||
var payload CardMoved
|
||||
require.NoError(t, json.Unmarshal(c.event.Data.([]byte), &payload))
|
||||
assert.Equal(t, "explicit", payload.SessionTag)
|
||||
}
|
||||
|
||||
// TestConnectedUIDsWithProjectAccess_FiltersByPermission ensures the
|
||||
// helper drops uids the access checker rejects.
|
||||
func TestConnectedUIDsWithProjectAccess_FiltersByPermission(t *testing.T) {
|
||||
origLister := connectedUIDsLister
|
||||
origChecker := projectAccessChecker
|
||||
origLookup := projectLookup
|
||||
defer func() {
|
||||
connectedUIDsLister = origLister
|
||||
projectAccessChecker = origChecker
|
||||
projectLookup = origLookup
|
||||
}()
|
||||
|
||||
connectedUIDsLister = func() []int64 { return []int64{1, 2, 3, 4} }
|
||||
projectLookup = func(_ context.Context, id int64) (*project_model.Project, error) {
|
||||
return &project_model.Project{ID: id}, nil
|
||||
}
|
||||
allowed := map[int64]bool{1: true, 3: true}
|
||||
projectAccessChecker = func(_ context.Context, uid int64, _ *project_model.Project) (bool, error) {
|
||||
return allowed[uid], nil
|
||||
}
|
||||
|
||||
got := connectedUIDsWithProjectAccess(context.Background(), 42)
|
||||
assert.ElementsMatch(t, []int64{1, 3}, got)
|
||||
}
|
||||
|
||||
// TestConnectedUIDsWithProjectAccess_NoConnections shortcuts when no
|
||||
// users are connected; the project lookup must not be called.
|
||||
func TestConnectedUIDsWithProjectAccess_NoConnections(t *testing.T) {
|
||||
origLister := connectedUIDsLister
|
||||
origLookup := projectLookup
|
||||
defer func() {
|
||||
connectedUIDsLister = origLister
|
||||
projectLookup = origLookup
|
||||
}()
|
||||
|
||||
connectedUIDsLister = func() []int64 { return nil }
|
||||
called := false
|
||||
projectLookup = func(_ context.Context, _ int64) (*project_model.Project, error) {
|
||||
called = true
|
||||
return &project_model.Project{}, nil
|
||||
}
|
||||
|
||||
got := connectedUIDsWithProjectAccess(context.Background(), 42)
|
||||
assert.Empty(t, got)
|
||||
assert.False(t, called, "project lookup should be skipped when no uids are connected")
|
||||
}
|
||||
|
||||
// TestPublishEvent_BroadcastsToAllowedUIDs exercises publishEvent
|
||||
// directly to verify the uid set computed by the access filter is
|
||||
// what gets handed to broadcastFn.
|
||||
func TestPublishEvent_BroadcastsToAllowedUIDs(t *testing.T) {
|
||||
origBroadcast := broadcastFn
|
||||
origLister := connectedUIDsLister
|
||||
origChecker := projectAccessChecker
|
||||
origLookup := projectLookup
|
||||
defer func() {
|
||||
broadcastFn = origBroadcast
|
||||
connectedUIDsLister = origLister
|
||||
projectAccessChecker = origChecker
|
||||
projectLookup = origLookup
|
||||
}()
|
||||
|
||||
var mu sync.Mutex
|
||||
var got []int64
|
||||
broadcastFn = func(uids []int64, _ *eventsource.Event) {
|
||||
mu.Lock()
|
||||
got = append([]int64(nil), uids...)
|
||||
mu.Unlock()
|
||||
}
|
||||
connectedUIDsLister = func() []int64 { return []int64{10, 20, 30} }
|
||||
projectLookup = func(_ context.Context, id int64) (*project_model.Project, error) {
|
||||
return &project_model.Project{ID: id}, nil
|
||||
}
|
||||
projectAccessChecker = func(_ context.Context, uid int64, _ *project_model.Project) (bool, error) {
|
||||
return uid != 20, nil
|
||||
}
|
||||
|
||||
publishEvent(context.Background(), 1, ColumnDeleted{ProjectID: 1, ColumnID: 5})
|
||||
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
assert.ElementsMatch(t, []int64{10, 30}, got)
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
// Copyright 2026 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package project
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
project_model "code.gitea.io/gitea/models/project"
|
||||
"code.gitea.io/gitea/services/convert"
|
||||
"code.gitea.io/gitea/services/project_events"
|
||||
)
|
||||
|
||||
// CreateColumn inserts a new column into a project and publishes a
|
||||
// ColumnCreated event. Routers should call this instead of
|
||||
// project_model.NewColumn so the SSE side-effect fires uniformly across
|
||||
// repo, user, and org scopes.
|
||||
func CreateColumn(ctx context.Context, column *project_model.Column) error {
|
||||
if err := project_model.NewColumn(ctx, column); err != nil {
|
||||
return err
|
||||
}
|
||||
project_events.PublishColumnCreated(ctx, project_events.ColumnCreated{
|
||||
ProjectID: column.ProjectID,
|
||||
ColumnID: column.ID,
|
||||
Title: column.Title,
|
||||
Color: column.Color,
|
||||
Sorting: int64(column.Sorting),
|
||||
IsDefault: column.Default,
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
// EditColumn updates a column and publishes a ColumnUpdated event.
|
||||
func EditColumn(ctx context.Context, column *project_model.Column) error {
|
||||
if err := project_model.UpdateColumn(ctx, column); err != nil {
|
||||
return err
|
||||
}
|
||||
project_events.PublishColumnUpdated(ctx, project_events.ColumnUpdated{
|
||||
ProjectID: column.ProjectID,
|
||||
ColumnID: column.ID,
|
||||
Title: column.Title,
|
||||
Color: column.Color,
|
||||
Sorting: int64(column.Sorting),
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeleteColumn removes a column from a project and publishes the
|
||||
// matching ColumnDeleted event. The model layer also moves the
|
||||
// column's issues to the project's default column; we publish those
|
||||
// individual moves so receiving tabs can patch the DOM without a full
|
||||
// reload. We snapshot affected issues *before* the delete so we have
|
||||
// their ids; the destination column id is resolved after.
|
||||
func DeleteColumn(ctx context.Context, columnID int64) error {
|
||||
// Snapshot the column + its issues so we know what to publish
|
||||
// after the delete commits. Errors here are non-fatal: we still
|
||||
// run the delete, and just skip per-issue events.
|
||||
col, snapErr := project_model.GetColumn(ctx, columnID)
|
||||
var (
|
||||
projectID int64
|
||||
movedIssues []int64
|
||||
)
|
||||
if snapErr == nil {
|
||||
projectID = col.ProjectID
|
||||
issues, err := col.GetIssues(ctx)
|
||||
if err == nil {
|
||||
movedIssues = make([]int64, 0, len(issues))
|
||||
for _, pi := range issues {
|
||||
movedIssues = append(movedIssues, pi.IssueID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if err := project_model.DeleteColumnByID(ctx, columnID); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if snapErr != nil || projectID == 0 {
|
||||
return nil
|
||||
}
|
||||
project_events.PublishColumnDeleted(ctx, project_events.ColumnDeleted{
|
||||
ProjectID: projectID,
|
||||
ColumnID: columnID,
|
||||
})
|
||||
|
||||
// Resolve the new (default) column to attach to the per-issue
|
||||
// CardMoved events. Failures here are tolerated; the frontend
|
||||
// already knows the column is gone and will simply render its
|
||||
// next refresh as authoritative.
|
||||
project, err := project_model.GetProjectByID(ctx, projectID)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
defaultCol, err := project.MustDefaultColumn(ctx)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
for _, issueID := range movedIssues {
|
||||
project_events.PublishCardMoved(ctx, project_events.CardMoved{
|
||||
ProjectID: projectID,
|
||||
IssueID: issueID,
|
||||
FromColumnID: columnID,
|
||||
ToColumnID: defaultCol.ID,
|
||||
})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReorderColumns persists a new sort order for project columns and
|
||||
// publishes a ColumnReordered batch event.
|
||||
func ReorderColumns(ctx context.Context, project *project_model.Project, sortedColumnIDs map[int64]int64) error {
|
||||
if err := project_model.MoveColumnsOnProject(ctx, project, sortedColumnIDs); err != nil {
|
||||
return err
|
||||
}
|
||||
cols := make([]project_events.ColumnSort, 0, len(sortedColumnIDs))
|
||||
for sorting, columnID := range sortedColumnIDs {
|
||||
cols = append(cols, project_events.ColumnSort{
|
||||
ColumnID: columnID,
|
||||
Sorting: sorting,
|
||||
})
|
||||
}
|
||||
project_events.PublishColumnReordered(ctx, project_events.ColumnReordered{
|
||||
ProjectID: project.ID,
|
||||
Columns: cols,
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeleteProject deletes a project and publishes a ProjectDeleted event.
|
||||
func DeleteProject(ctx context.Context, projectID int64) error {
|
||||
if err := project_model.DeleteProjectByID(ctx, projectID); err != nil {
|
||||
return err
|
||||
}
|
||||
project_events.PublishProjectDeleted(ctx, project_events.ProjectDeleted{
|
||||
ProjectID: projectID,
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
// publishProjectUpdated emits a ProjectUpdated event for the current
|
||||
// state of the given project. It is exported via UpdateProject in
|
||||
// project.go after the txn commits.
|
||||
func publishProjectUpdated(ctx context.Context, project *project_model.Project) {
|
||||
project_events.PublishProjectUpdated(ctx, project_events.ProjectUpdated{
|
||||
ProjectID: project.ID,
|
||||
Title: project.Title,
|
||||
Description: project.Description,
|
||||
CardType: convert.ProjectCardTypeToString(project.CardType),
|
||||
IsClosed: project.IsClosed,
|
||||
})
|
||||
}
|
||||
+110
-1
@@ -15,6 +15,7 @@ import (
|
||||
user_model "code.gitea.io/gitea/models/user"
|
||||
"code.gitea.io/gitea/modules/container"
|
||||
"code.gitea.io/gitea/modules/optional"
|
||||
"code.gitea.io/gitea/services/project_events"
|
||||
)
|
||||
|
||||
// ErrIssueNotInProject is returned when MoveIssuesOnProjectColumn is asked to move
|
||||
@@ -23,7 +24,14 @@ var ErrIssueNotInProject = errors.New("all issues have to be added to a project
|
||||
|
||||
// MoveIssuesOnProjectColumn moves or keeps issues in a column and sorts them inside that column
|
||||
func MoveIssuesOnProjectColumn(ctx context.Context, doer *user_model.User, column *project_model.Column, sortedIssueIDs map[int64]int64) error {
|
||||
return db.WithTx(ctx, func(ctx context.Context) error {
|
||||
// movedEvents accumulates one CardMoved per issue we touch so they
|
||||
// can be published after the transaction commits successfully.
|
||||
// We capture the from-column inside the txn (cheap extra query)
|
||||
// and emit *all* moves, including same-column reorders, so the
|
||||
// frontend can update sorting without re-fetching the whole column.
|
||||
var movedEvents []project_events.CardMoved
|
||||
err := db.WithTx(ctx, func(ctx context.Context) error {
|
||||
movedEvents = movedEvents[:0]
|
||||
issueIDs := make([]int64, 0, len(sortedIssueIDs))
|
||||
for _, issueID := range sortedIssueIDs {
|
||||
issueIDs = append(issueIDs, issueID)
|
||||
@@ -89,9 +97,110 @@ func MoveIssuesOnProjectColumn(ctx context.Context, doer *user_model.User, colum
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
movedEvents = append(movedEvents, project_events.CardMoved{
|
||||
ProjectID: column.ProjectID,
|
||||
IssueID: issueID,
|
||||
FromColumnID: projectColumnID,
|
||||
ToColumnID: column.ID,
|
||||
Sorting: sorting,
|
||||
})
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, ev := range movedEvents {
|
||||
project_events.PublishCardMoved(ctx, ev)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AssignOrRemoveProjects updates the projects associated with an issue
|
||||
// (delegating to issues_model.IssueAssignOrRemoveProject) and publishes
|
||||
// SSE events for each link/unlink so other tabs viewing the relevant
|
||||
// project boards can update without a reload.
|
||||
//
|
||||
// Routers should prefer this helper over calling the model function
|
||||
// directly so the publish side-effects fire at every call site.
|
||||
func AssignOrRemoveProjects(ctx context.Context, issue *issues_model.Issue, doer *user_model.User, newProjectIDs []int64) error {
|
||||
// Snapshot the current project ids before the update so we can
|
||||
// compute the link/unlink diff. If this read fails we just skip
|
||||
// publishing — the user-visible operation still succeeds.
|
||||
oldProjectIDs, snapErr := issueProjectIDs(ctx, issue.ID)
|
||||
if err := issues_model.IssueAssignOrRemoveProject(ctx, issue, doer, newProjectIDs); err != nil {
|
||||
return err
|
||||
}
|
||||
if snapErr != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
added, removed := diffInt64Slices(oldProjectIDs, newProjectIDs)
|
||||
|
||||
for _, pid := range removed {
|
||||
project_events.PublishCardUnlinked(ctx, project_events.CardUnlinked{
|
||||
ProjectID: pid,
|
||||
IssueID: issue.ID,
|
||||
})
|
||||
}
|
||||
// For additions we want to surface the destination column so the
|
||||
// receiving tab can refetch only that column's contents. The model
|
||||
// function places newly added issues in each project's default
|
||||
// column; re-derive that here.
|
||||
for _, pid := range added {
|
||||
project, err := project_model.GetProjectByID(ctx, pid)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
col, err := project.MustDefaultColumn(ctx)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
project_events.PublishCardLinked(ctx, project_events.CardLinked{
|
||||
ProjectID: pid,
|
||||
IssueID: issue.ID,
|
||||
ColumnID: col.ID,
|
||||
})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// issueProjectIDs reads the set of project ids currently linked to issue.
|
||||
// Mirrors models/issues/(*Issue).projectIDs but lives at the service layer
|
||||
// so we can keep the model surface untouched.
|
||||
func issueProjectIDs(ctx context.Context, issueID int64) ([]int64, error) {
|
||||
var ids []int64
|
||||
err := db.GetEngine(ctx).Table("project_issue").
|
||||
Where("issue_id = ?", issueID).
|
||||
Cols("project_id").
|
||||
Find(&ids)
|
||||
return ids, err
|
||||
}
|
||||
|
||||
// diffInt64Slices returns the elements present in `b` but missing in `a`
|
||||
// (added) and the elements present in `a` but missing in `b` (removed).
|
||||
// Both inputs are treated as sets.
|
||||
func diffInt64Slices(a, b []int64) (added, removed []int64) {
|
||||
inA := make(map[int64]struct{}, len(a))
|
||||
for _, v := range a {
|
||||
inA[v] = struct{}{}
|
||||
}
|
||||
inB := make(map[int64]struct{}, len(b))
|
||||
for _, v := range b {
|
||||
inB[v] = struct{}{}
|
||||
}
|
||||
for _, v := range b {
|
||||
if _, ok := inA[v]; !ok {
|
||||
added = append(added, v)
|
||||
}
|
||||
}
|
||||
for _, v := range a {
|
||||
if _, ok := inB[v]; !ok {
|
||||
removed = append(removed, v)
|
||||
}
|
||||
}
|
||||
return added, removed
|
||||
}
|
||||
|
||||
func LoadIssuesAssigneesForProject(ctx context.Context, issuesMap map[int64]issues_model.IssueList) ([]*user_model.User, error) {
|
||||
|
||||
@@ -19,9 +19,10 @@ type UpdateProjectOptions struct {
|
||||
IsClosed optional.Option[bool]
|
||||
}
|
||||
|
||||
// UpdateProject applies the provided options to the project atomically.
|
||||
// UpdateProject applies the provided options to the project atomically
|
||||
// and emits a ProjectUpdated SSE event when the txn commits.
|
||||
func UpdateProject(ctx context.Context, project *project_model.Project, opts UpdateProjectOptions) error {
|
||||
return db.WithTx(ctx, func(ctx context.Context) error {
|
||||
if err := db.WithTx(ctx, func(ctx context.Context) error {
|
||||
if opts.Title.Has() {
|
||||
project.Title = opts.Title.Value()
|
||||
}
|
||||
@@ -40,5 +41,9 @@ func UpdateProject(ctx context.Context, project *project_model.Project, opts Upd
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
publishProjectUpdated(ctx, project)
|
||||
return nil
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user