cli: dashboard activity as sentences, no duplicate issues !481

merged merged by cmc on 2026-09-28 22:03 UTC · krz/gitbay:cli-ux-activity into main

17 files changed, +326 −72

Layout: unified · split

CHANGELOG.org +7

	@@ -69,6 +69,13 @@ must add =--scope full=. Existing tokens keep their scope.
69	separately (#275).	69	separately (#275).
70	- Audit retention deletes by id, up to the newest row older than the	70	- Audit retention deletes by id, up to the newest row older than the
71	retention, so a clock step back cannot leave a gap in the chain (#275).	71	retention, so a clock step back cannot leave a gap in the chain (#275).
		72	- =dashboard= and =feed= print activity as sentences
		73	(=cmc opened issue krz/gitbay#12=) instead of raw event payloads,
		74	and a labelled event names its labels there and on the web feed. An
		75	issue assigned to you appears only under "assigned to you": the
		76	=open_issues= field of =dashboard --json= no longer includes issues
		77	assigned to the caller. =notifications list= names =--all= when only
		78	read items remain (#265).
72		79
73	* v1.36.0 — 2026-09-23	80	* v1.36.0 — 2026-09-23
74		81

e2e/dashboard_test.go +3 −2

 		d.Assigned[0].Title != "todo one" {
 		t.Fatalf("assigned_issues = %+v", d.Assigned)
 	}
-	if len(d.Issues) != 1 || d.Issues[0].Repo != "alice/app" || d.Issues[0].Number != 1 ||
+	// The only open issue is assigned to alice, so it is listed under
-		d.Issues[0].Title != "todo one" {
+	// assigned_issues and not again under open_issues.
+	if len(d.Issues) != 0 {
 		t.Fatalf("open_issues = %+v", d.Issues)
 	}
 	if len(d.Activity) == 0 || d.Activity[0].Repo != "alice/app" {

internal/control/dashboard.go +9 −7

 		}
 		section("pinned:", []string{"PATH", "VISIBILITY", "DESCRIPTION"}, pinnedRows)
-		activityRows := make([][]cell, len(d.Activity))
+		lines := FeedLines(events)
-		for i, e := range d.Activity {
+		activityRows := make([][]cell, len(lines))
-			activityRows[i] = []cell{cAge(e.CreatedAt), cText(e.Actor), cText(e.Kind), cRef(e.Repo), cFlex(string(e.Data))}
+		for i, l := range lines {
+			activityRows[i] = []cell{cAge(l.When), cFlex(l.Sentence())}
 		}
-		section("recent activity:", []string{"WHEN", "ACTOR", "KIND", "REPO", "DATA"}, activityRows)
+		section("recent activity:", []string{"WHEN", "EVENT"}, activityRows)
 		buildRows := make([][]cell, len(d.Builds))
 		for i, b := range d.Builds {
 		return strconv.FormatInt(e.ID, 10)
 	})
 	ds := feedOutputs(events)
+	lines := FeedLines(events)
 	return c.emitPage(p, ds, next, func(w io.Writer) {
-		tb := c.table(w, "WHEN", "ACTOR", "KIND", "REPO", "DATA")
+		tb := c.table(w, "WHEN", "EVENT")
-		for _, d := range ds {
+		for _, l := range lines {
-			tb.row(cAge(d.CreatedAt), cText(d.Actor), cText(d.Kind), cRef(d.Repo), cFlex(string(d.Data)))
+			tb.row(cAge(l.When), cFlex(l.Sentence()))
 		}
 		tb.flush()
 	})

internal/control/dashboard_test.go +47

	@@ -23,6 +23,53 @@ func TestDashboardEmptySectionsSayNone(t *testing.T) {
23	}	23	}
24	}	24	}
25		25
		26	func TestDashboardActivityIsASentence(t *testing.T) {
		27	c := notifTestCtx(t, "cmc")
		28	repoID, err := c.Store.CreateRepo("user", c.User.ID, "gitbay", "public")
		29	if err != nil {
		30	t.Fatal(err)
		31	}
		32	repo, err := c.Store.RepoByID(repoID)
		33	if err != nil {
		34	t.Fatal(err)
		35	}
		36	c.Store.RecordEvent(repo.ID, c.User.ID, "issue.labeled", `{"number":262,"labels":["ops","security"]}`)
		37
		38	var out bytes.Buffer
		39	c.Stdout, c.Stderr = &out, &out
		40	if code := runDashboard(c, nil); code != 0 {
		41	t.Fatalf("exit %d: %s", code, out.String())
		42	}
		43	if strings.Contains(out.String(), `{"number"`) {
		44	t.Errorf("raw payload leaked into plain output:\n%s", out.String())
		45	}
		46	if !strings.Contains(out.String(), "cmc labelled cmc/gitbay#262 ops, security") {
		47	t.Errorf("no sentence in output:\n%s", out.String())
		48	}
		49	}
		50
		51	func TestFeedIsASentence(t *testing.T) {
		52	c := notifTestCtx(t, "cmc")
		53	repoID, err := c.Store.CreateRepo("user", c.User.ID, "gitbay", "public")
		54	if err != nil {
		55	t.Fatal(err)
		56	}
		57	repo, err := c.Store.RepoByID(repoID)
		58	if err != nil {
		59	t.Fatal(err)
		60	}
		61	c.Store.RecordEvent(repo.ID, c.User.ID, "issue.created", `{"number":1}`)
		62
		63	var out bytes.Buffer
		64	c.Stdout, c.Stderr = &out, &out
		65	if code := runFeed(c, nil); code != 0 {
		66	t.Fatalf("exit %d: %s", code, out.String())
		67	}
		68	if !strings.Contains(out.String(), "cmc opened issue cmc/gitbay#1") {
		69	t.Errorf("no sentence in output:\n%s", out.String())
		70	}
		71	}
		72
26	// The push queue is the one worker queue whose worst failure — a key_id	73	// The push queue is the one worker queue whose worst failure — a key_id
27	// or team_id Apple did not issue, which config validation cannot check —	74	// or team_id Apple did not issue, which config validation cannot check —
28	// dead-letters every row on its first attempt with nothing but a log	75	// dead-letters every row on its first attempt with nothing but a log

internal/httpd/feed.go → internal/control/feedline.go renamed +70 −14

-package httpd
+package control
 import (
 	"encoding/json"
 	"gitbay.org/gitbay/internal/store"
 )
-// feedLine is one activity entry, already phrased and linked.
+// FeedLine is one activity entry, already phrased and linked.
-type feedLine struct {
+type FeedLine struct {
 	Actor string
 	Verb  string // "opened issue", "merged", "ran 2 jobs on"
 	Ref   string // "#12", "!35", "v0.4.0", a short sha
 	WhenT time.Time // parsed from When, for ago/whenT rendering
 	State string    // a build run's combined status; empty for anything else
 	Jobs  []string  // job names folded into a build run
-	sha   string    // the commit a build event fired on, for fold-matching
+	// Extra is trailing detail shown after the ref: the label list on a
+	// labelled event, empty for everything else.
+	Extra string
+	sha   string // the commit a build event fired on, for fold-matching
 }
-// feedLines turns stored events into readable lines. An unknown kind
+// Sentence renders the line the way the CLI shows it: "<actor> <verb>
+// <repo><ref>" for an issue or MR ("krz/gitbay#1"), "<repo> <ref>" for a
+// tag, job or sha, with Extra (a label list) appended when set.
+func (l FeedLine) Sentence() string {
+	ref := l.Ref
+	if ref != "" && ref[0] != '#' && ref[0] != '!' {
+		ref = " " + ref
+	}
+	s := fmt.Sprintf("%s %s %s%s", l.Actor, l.Verb, l.Repo, ref)
+	if l.Extra != "" {
+		s += " " + l.Extra
+	}
+	return s
+}
+// FeedLines turns stored events into readable lines. An unknown kind
 // still shows: the feed says what happened even for events added later.
 // Build events on the same commit, adjacent in the input, fold into one
 // "run" line (D04): its State is the worst of the folded jobs' outcomes,
-// via worstStatus — the same rule the builds tab uses for a run's status.
+// via WorstStatus — the same rule the builds tab uses for a run's status.
 // A repeated job name ends the line and starts the next, so a scheduled
 // job firing daily on an unchanged tip reads as one line a day rather than
 // "ran 9 jobs on" one commit (#240). groupRuns separates its runs by
 // per job, so there is no queue moment here to key on. The cost is that
 // the oldest scheduled line on a commit folds in the push's jobs, which
 // have not been seen yet on that line.
-func feedLines(events []store.FeedEvent) []feedLine {
+func FeedLines(events []store.FeedEvent) []FeedLine {
-	out := make([]feedLine, 0, len(events))
+	out := make([]FeedLine, 0, len(events))
 	statuses := make([][]string, 0, len(events))
 	for _, e := range events {
 		var d struct {
-			Number int64  `json:"number"`
+			Number int64    `json:"number"`
-			Job    string `json:"job"`
+			Job    string   `json:"job"`
-			Tag    string `json:"tag"`
+			Tag    string   `json:"tag"`
-			SHA    string `json:"sha"`
+			SHA    string   `json:"sha"`
+			Labels []string `json:"labels"`
 		}
 		json.Unmarshal([]byte(e.Data), &d)
 		kind, rest, _ := strings.Cut(e.Kind, ".")
 				out[i].Verb = fmt.Sprintf("ran %d jobs on", len(out[i].Jobs))
 				out[i].Ref = fmt.Sprintf("%.10s", d.SHA)
 				out[i].URL = fmt.Sprintf("/%s/commit/%s", e.RepoPath, d.SHA)
-				out[i].State = worstStatus(statuses[i])
+				out[i].State = WorstStatus(statuses[i])
 				continue
 			}
 		}
-		l := feedLine{Actor: e.Actor, Repo: e.RepoPath, When: e.CreatedAt, WhenT: parseEventTime(e.CreatedAt)}
+		l := FeedLine{Actor: e.Actor, Repo: e.RepoPath, When: e.CreatedAt, WhenT: parseEventTime(e.CreatedAt)}
 		if l.Actor == "" {
 			l.Actor = "gitbay"
 		}
 		case "issue":
 			l.Verb, l.Ref = issueVerb(rest), fmt.Sprintf("#%d", d.Number)
 			l.URL = fmt.Sprintf("/%s/issues/%d", e.RepoPath, d.Number)
+			if rest == "labeled" {
+				l.Extra = strings.Join(d.Labels, ", ")
+			}
 		case "mr":
 			l.Verb, l.Ref = mrVerb(rest), fmt.Sprintf("!%d", d.Number)
 			l.URL = fmt.Sprintf("/%s/mrs/%d", e.RepoPath, d.Number)
+			if rest == "labeled" {
+				l.Extra = strings.Join(d.Labels, ", ")
+			}
 		case "build":
 			l.Verb, l.Ref = "build "+rest, d.Job
 			l.URL = fmt.Sprintf("/%s/builds/%d", e.RepoPath, d.Number)
 	return out
 }
+// runStatusPriority orders WorstStatus's worst-first check: a run reads
+// as its least finished or least successful build.
+var runStatusPriority = []string{"failure", "cancelled", "running", "pending"}
+// WorstStatus is the worst of a set of build statuses, success only when
+// every one of them is. It backs both the builds tab's combinedStatus and
+// FeedLines' folded build run (D04). A status outside runStatusPriority (a
+// future state such as "skipped") is still not "success": it is returned
+// unchanged rather than falling through and reading as green.
+func WorstStatus(statuses []string) string {
+	has := map[string]bool{}
+	for _, s := range statuses {
+		has[s] = true
+	}
+	for _, s := range runStatusPriority {
+		if has[s] {
+			return s
+		}
+	}
+	for _, s := range statuses {
+		if s != "success" {
+			return s
+		}
+	}
+	return "success"
+}
 // parseEventTime parses a stored RFC3339 timestamp for ago/whenT
 // rendering; an unparseable value (or none) comes back zero rather than
 // guessing.
 		return "reopened issue"
 	case "commented":
 		return "commented on"
+	case "labeled":
+		return "labelled"
 	}
 	return "issue " + s
 }
 		return "commented on"
 	case "closed":
 		return "closed merge request"
+	case "labeled":
+		return "labelled"
 	}
 	return "merge request " + s
 }

internal/httpd/feed_test.go → internal/control/feedline_test.go renamed +66 −10

-package httpd
+package control
 import (
 	"fmt"
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.failure",
 			Data: `{"number":2,"job":"lint","sha":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 1 {
 		t.Fatalf("feedLines returned %d lines, want 1: %+v", len(lines), lines)
 	}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.success",
 			Data: `{"number":1,"job":"unit","sha":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 1 {
 		t.Fatalf("feedLines returned %d lines, want 1", len(lines))
 	}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.success",
 			Data: `{"number":2,"job":"lint","sha":"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 2 {
 		t.Fatalf("feedLines returned %d lines, want 2: %+v", len(lines), lines)
 	}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.success", Data: `{"number":1,"job":"unit"}`},
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.success", Data: `{"number":2,"job":"lint"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 2 {
 		t.Fatalf("feedLines returned %d lines, want 2: %+v", len(lines), lines)
 	}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.failure",
 			Data: `{"number":2,"job":"lint","sha":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 3 {
 		t.Fatalf("feedLines returned %d lines, want 3: %+v", len(lines), lines)
 	}
 			events[i] = store.FeedEvent{RepoPath: "alice/app", Actor: "alice", Kind: "build." + s,
 				Data: fmt.Sprintf(`{"number":1,"job":"j%d","sha":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}`, i)}
 		}
-		lines := feedLines(events)
+		lines := FeedLines(events)
 		if len(lines) != 1 || lines[0].State != tc.want {
 			t.Errorf("statuses %v: got %+v, want State %q", tc.statuses, lines, tc.want)
 		}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "issue.created",
 			Data: `{"number":2}`, CreatedAt: "not-a-time"},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	want, _ := time.Parse(time.RFC3339Nano, "2026-09-10T12:00:00Z")
 	if !lines[0].WhenT.Equal(want) {
 		t.Errorf("WhenT = %v, want %v", lines[0].WhenT, want)
 	}
 }
+// A labelled issue names which labels were added, not just "issue
+// labeled": the sentence is otherwise silent about what changed.
+func TestFeedLinesNamesTheLabelsOnALabelledIssue(t *testing.T) {
+	events := []store.FeedEvent{
+		{RepoPath: "krz/gitbay", Actor: "cmc", Kind: "issue.labeled",
+			Data: `{"number":262,"labels":["ops","security"]}`},
+	}
+	lines := FeedLines(events)
+	if len(lines) != 1 {
+		t.Fatalf("FeedLines returned %d lines, want 1", len(lines))
+	}
+	l := lines[0]
+	if l.Verb != "labelled" || l.Ref != "#262" || l.Extra != "ops, security" {
+		t.Errorf("got %+v", l)
+	}
+}
+// Same for a labelled merge request.
+func TestFeedLinesNamesTheLabelsOnALabelledMR(t *testing.T) {
+	events := []store.FeedEvent{
+		{RepoPath: "krz/gitbay", Actor: "cmc", Kind: "mr.labeled",
+			Data: `{"number":471,"labels":["review"]}`},
+	}
+	lines := FeedLines(events)
+	if len(lines) != 1 || lines[0].Verb != "labelled" || lines[0].Ref != "!471" || lines[0].Extra != "review" {
+		t.Errorf("got %+v", lines)
+	}
+}
 // A scheduled job firing daily on an unchanged tip is a separate event
 // each tick, not another job of one run (#240): a repeated job name starts
 // a new line, so three days read as three lines rather than "ran 3 jobs on"
 		events = append(events, store.FeedEvent{RepoPath: "alice/app", Actor: "alice",
 			Kind: "build." + status, Data: `{"number":1,"job":"instances","sha":"` + sha + `"}`})
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 3 {
 		t.Fatalf("feedLines returned %d lines, want 3: %+v", len(lines), lines)
 	}
 		{RepoPath: "alice/app", Actor: "alice", Kind: "build.success",
 			Data: `{"number":1,"job":"lint","sha":"` + sha + `"}`},
 	}
-	lines := feedLines(events)
+	lines := FeedLines(events)
 	if len(lines) != 2 {
 		t.Fatalf("feedLines returned %d lines, want 2: %+v", len(lines), lines)
 	}
 		t.Errorf("second line jobs: %+v, want the schedule and the push folded", lines[1].Jobs)
 	}
 }
+func TestFeedLineSentence(t *testing.T) {
+	l := FeedLine{Actor: "cmc", Verb: "opened issue", Repo: "krz/gitbay", Ref: "#1"}
+	if got, want := l.Sentence(), "cmc opened issue krz/gitbay#1"; got != want {
+		t.Errorf("Sentence() = %q, want %q", got, want)
+	}
+	l.Extra = "ops, security"
+	if got, want := l.Sentence(), "cmc opened issue krz/gitbay#1 ops, security"; got != want {
+		t.Errorf("Sentence() with Extra = %q, want %q", got, want)
+	}
+	for _, c := range []struct {
+		l    FeedLine
+		want string
+	}{
+		{FeedLine{Actor: "cmc", Verb: "released", Repo: "krz/gitbay", Ref: "v1.30.0"}, "cmc released krz/gitbay v1.30.0"},
+		{FeedLine{Actor: "cmc", Verb: "build success", Repo: "krz/gitbay", Ref: "test"}, "cmc build success krz/gitbay test"},
+		{FeedLine{Actor: "cmc", Verb: "ran 2 jobs on", Repo: "krz/gitbay", Ref: "0123456789"}, "cmc ran 2 jobs on krz/gitbay 0123456789"},
+		{FeedLine{Actor: "cmc", Verb: "merged", Repo: "krz/gitbay", Ref: "!3"}, "cmc merged krz/gitbay!3"},
+		{FeedLine{Actor: "cmc", Verb: "repository created", Repo: "krz/gitbay"}, "cmc repository created krz/gitbay"},
+	} {
+		if got := c.l.Sentence(); got != c.want {
+			t.Errorf("Sentence() = %q, want %q", got, c.want)
+		}
+	}
+}

internal/control/notifications.go +10

	@@ -418,6 +418,16 @@ func runNotificationsList(c *Ctx, args []string) int {
418	for _, n := range notices {	418	for _, n := range notices {
419	ds = append(ds, out{n.ID, n.RepoPath, n.Kind, n.Actor, n.Summary, n.Path, n.CreatedAt, n.ReadAt})	419	ds = append(ds, out{n.ID, n.RepoPath, n.Kind, n.Actor, n.Summary, n.Path, n.CreatedAt, n.ReadAt})
420	}	420	}
		421	if !c.JSON && !p.active && len(ds) == 0 {
		422	msg := "nothing to list"
		423	if !all {
		424	if read, err := c.Store.Inbox(c.User.ID, false, 1, 0); err == nil && len(read) > 0 {
		425	msg = "no unread notifications (--all for read ones)"
		426	}
		427	}
		428	fmt.Fprintln(c.Stderr, msg)
		429	return protocol.ExitOK
		430	}
421	return c.emitPage(p, ds, next, func(w io.Writer) {	431	return c.emitPage(p, ds, next, func(w io.Writer) {
422	tb := c.table(w, "ID", "WHEN", "REPO", "EVENT", "PATH")	432	tb := c.table(w, "ID", "WHEN", "REPO", "EVENT", "PATH")
423	for _, d := range ds {	433	for _, d := range ds {

internal/control/notifications_test.go +43

	@@ -267,3 +267,46 @@ func TestNotificationsSettingsShowsPush(t *testing.T) {
267	t.Fatalf("no push key: %s", out.String())	267	t.Fatalf("no push key: %s", out.String())
268	}	268	}
269	}	269	}
		270
		271	func TestNotificationsListEmptyUnreadSaysHowToSeeRead(t *testing.T) {
		272	c, repo, bob := testRepoWithWatcher(t)
		273	// An inbox with nothing in it at all keeps the plain message.
		274	var empty bytes.Buffer
		275	alice := c.User
		276	c.User = store.User{ID: bob, Username: "bob"}
		277	c.Stdout, c.Stderr = &bytes.Buffer{}, &empty
		278	if code := runNotificationsList(c, nil); code != protocol.ExitOK {
		279	t.Fatalf("exit %d: %s", code, empty.String())
		280	}
		281	if got := empty.String(); got != "nothing to list\n" {
		282	t.Errorf("empty inbox stderr = %q", got)
		283	}
		284	c.User = alice
		285	// Give bob one notice (acting as alice, so bob isn't filtered out as
		286	// the actor), then mark it read as bob, so his inbox has rows but no
		287	// unread ones.
		288	notify(c, []int64{bob}, notice{repo: repo, kind: "issue", subject: "s", action: "a", path: "x"})
		289	c.User = store.User{ID: bob, Username: "bob"}
		290	if code := runNotificationsRead(c, []string{"--all"}); code != protocol.ExitOK {
		291	t.Fatalf("mark read: exit %d", code)
		292	}
		293	var out, errOut bytes.Buffer
		294	c.Stdout, c.Stderr = &out, &errOut
		295	if code := runNotificationsList(c, nil); code != protocol.ExitOK {
		296	t.Fatalf("exit %d: %s", code, errOut.String())
		297	}
		298	if got := errOut.String(); got != "no unread notifications (--all for read ones)\n" {
		299	t.Errorf("stderr = %q", got)
		300	}
		301	// --all sees it and stays the generic message when that too is empty.
		302	out.Reset()
		303	errOut.Reset()
		304	if code := runNotificationsList(c, []string{"--all"}); code != protocol.ExitOK {
		305	t.Fatalf("exit %d: %s", code, errOut.String())
		306	}
		307	// The inbox row's summary is the notice's action ("a"), not its mail
		308	// subject ("s"); check the path instead, which is unique to this row.
		309	if !strings.Contains(out.String(), "x") {
		310	t.Errorf("--all did not show the read notice: %q", out.String())
		311	}
		312	}

internal/httpd/anchors_test.go +2 −1

 	"testing"
 	"gitbay.org/gitbay/internal/config"
+	"gitbay.org/gitbay/internal/control"
 	"gitbay.org/gitbay/internal/store"
 	"gitbay.org/gitbay/internal/web"
 )
 		Assigned []store.DashboardItem
 		MRs      []store.DashboardItem
 		Issues   []store.DashboardItem
-		Feed     []feedLine
+		Feed     []control.FeedLine
 	}{base, "dashboard", nil, nil, nil, nil, nil, nil})
 	if err != nil {
 		t.Fatal(err)

internal/httpd/builds.go +1 −28

	@@ -147,10 +147,6 @@ type buildRun struct {
147	Builds []control.BuildOut	147	Builds []control.BuildOut
148	}	148	}
149		149
150	// runStatusPriority orders combinedStatus's worst-first check: a run reads
151	// as its least finished or least successful build.
152	var runStatusPriority = []string{"failure", "cancelled", "running", "pending"}
153
154	// combinedStatus is the run's status: the worst of its builds' statuses,	150	// combinedStatus is the run's status: the worst of its builds' statuses,
155	// success only when every one of them is.	151	// success only when every one of them is.
156	func combinedStatus(builds []control.BuildOut) string {	152	func combinedStatus(builds []control.BuildOut) string {
	@@ -158,30 +154,7 @@ func combinedStatus(builds []control.BuildOut) string {
158	for i, b := range builds {	154	for i, b := range builds {
159	statuses[i] = b.Status	155	statuses[i] = b.Status
160	}	156	}
161	return worstStatus(statuses)	157	return control.WorstStatus(statuses)
162	}
163
164	// worstStatus is combinedStatus's ordering rule, factored out so the
165	// dashboard feed can apply the same worst-first precedence to a folded
166	// build run (D04). A status outside runStatusPriority (a future state
167	// such as "skipped") is still not "success": it is returned unchanged
168	// rather than falling through and reading as green.
169	func worstStatus(statuses []string) string {
170	has := map[string]bool{}
171	for _, s := range statuses {
172	has[s] = true
173	}
174	for _, s := range runStatusPriority {
175	if has[s] {
176	return s
177	}
178	}
179	for _, s := range statuses {
180	if s != "success" {
181	return s
182	}
183	}
184	return "success"
185	}	158	}
186		159
187	// groupRuns folds consecutive builds of the same commit and the same	160	// groupRuns folds consecutive builds of the same commit and the same

internal/httpd/dashpins_test.go +2 −1

 	"strings"
 	"testing"
+	"gitbay.org/gitbay/internal/control"
 	"gitbay.org/gitbay/internal/store"
 	"gitbay.org/gitbay/internal/web"
 )
 		Assigned []store.DashboardItem
 		MRs      []store.DashboardItem
 		Issues   []store.DashboardItem
-		Feed     []feedLine
+		Feed     []control.FeedLine
 	}{base, "dashboard", []pinnedRow{
 		{Owner: "krz", Name: "gitbay", Issues: 3, MRs: 0, Build: "success"},
 		{Owner: "krz", Name: "old", Build: "cancelled"},

internal/httpd/ownerpage_test.go +2 −2

	@@ -55,7 +55,7 @@ func TestOwnerPageTabOrder(t *testing.T) {
55	// it — not the whole history, which is what the atom feed is for.	55	// it — not the whole history, which is what the atom feed is for.
56	func TestOwnerPageAboutCarriesTheGraphAndLog(t *testing.T) {	56	func TestOwnerPageAboutCarriesTheGraphAndLog(t *testing.T) {
57	d := ownerFixture()	57	d := ownerFixture()
58	d.Log = []feedLine{{Actor: "cmc", Verb: "opened issue", Ref: "#12", Repo: "krz/gitbay", URL: "/krz/gitbay/issues/12"}}	58	d.Log = []control.FeedLine{{Actor: "cmc", Verb: "opened issue", Ref: "#12", Repo: "krz/gitbay", URL: "/krz/gitbay/issues/12"}}
59	out := renderOwner(t, "about", d)	59	out := renderOwner(t, "about", d)
60	for _, want := range []string{"Christian Cleberg", "actgraph", "opened issue", "#12", "/cmc/activity.atom"} {	60	for _, want := range []string{"Christian Cleberg", "actgraph", "opened issue", "#12", "/cmc/activity.atom"} {
61	if !strings.Contains(out, want) {	61	if !strings.Contains(out, want) {
	@@ -149,7 +149,7 @@ type ownerFixtureData struct {
149	Self bool	149	Self bool
150	Snippets int	150	Snippets int
151	Members []control.ProfileMember	151	Members []control.ProfileMember
152	Log []feedLine	152	Log []control.FeedLine
153	Bookmarks []control.BookmarkOut	153	Bookmarks []control.BookmarkOut
154	SnippetRows []snippetRow	154	SnippetRows []snippetRow
155	}	155	}

internal/httpd/web.go +5 −5

	@@ -216,8 +216,8 @@ func (s Server) dashboard(w http.ResponseWriter, r http.Request, viewer store.
216	Assigned []store.DashboardItem	216	Assigned []store.DashboardItem
217	MRs []store.DashboardItem	217	MRs []store.DashboardItem
218	Issues []store.DashboardItem	218	Issues []store.DashboardItem
219	Feed []feedLine	219	Feed []control.FeedLine
220	}{s.baseFor(viewer), "dashboard", s.pinnedRows(viewer), reviews, assigned, mrs, issues, feedLines(events)})	220	}{s.baseFor(viewer), "dashboard", s.pinnedRows(viewer), reviews, assigned, mrs, issues, control.FeedLines(events)})
221	}	221	}
222		222
223	func (s Server) explore(w http.ResponseWriter, r http.Request) {	223	func (s Server) explore(w http.ResponseWriter, r http.Request) {
	@@ -467,7 +467,7 @@ const profileEvents = 30
467	// ActivityByDay and OrgActivityByDay respectively — a log that counted	467	// ActivityByDay and OrgActivityByDay respectively — a log that counted
468	// something else would contradict the total printed over it. Only the	468	// something else would contradict the total printed over it. Only the
469	// About tab renders it, so no other tab pays for the query.	469	// About tab renders it, so no other tab pays for the query.
470	func (s *Server) ownerFeed(tab, kind, name string) []feedLine {	470	func (s *Server) ownerFeed(tab, kind, name string) []control.FeedLine {
471	if tab != "about" {	471	if tab != "about" {
472	return nil	472	return nil
473	}	473	}
	@@ -490,7 +490,7 @@ func (s *Server) ownerFeed(tab, kind, name string) []feedLine {
490	if err != nil {	490	if err != nil {
491	return nil	491	return nil
492	}	492	}
493	return feedLines(events)	493	return control.FeedLines(events)
494	}	494	}
495		495
496	// ownerPage is what owner.html renders against. It is a named type	496	// ownerPage is what owner.html renders against. It is a named type
	@@ -508,7 +508,7 @@ type ownerPage struct {
508	Orgs []control.ProfileMember	508	Orgs []control.ProfileMember
509	Activity []activityWeek	509	Activity []activityWeek
510	ActivityTotal int	510	ActivityTotal int
511	Log []feedLine	511	Log []control.FeedLine
512	Bookmarks []control.BookmarkOut	512	Bookmarks []control.BookmarkOut
513	SnippetRows []snippetRow	513	SnippetRows []snippetRow
514	SnippetsAll bool	514	SnippetsAll bool

internal/store/dashboard.go +2

	@@ -76,6 +76,8 @@ const dashboardIssuesQuery = `
76	LEFT JOIN orgs o ON r.owner_kind = 'org' AND o.id = r.owner_id	76	LEFT JOIN orgs o ON r.owner_kind = 'org' AND o.id = r.owner_id
77	JOIN users au ON au.id = x.author_id	77	JOIN users au ON au.id = x.author_id
78	WHERE x.state = 'open' AND ` + involvedCond + `	78	WHERE x.state = 'open' AND ` + involvedCond + `
		79	AND NOT EXISTS (SELECT 1 FROM issue_assignees ia
		80	WHERE ia.issue_id = x.id AND ia.user_id = ?1)
79	ORDER BY x.updated_at DESC LIMIT 50`	81	ORDER BY x.updated_at DESC LIMIT 50`
80		82
81	func (s *Store) DashboardIssues(userID int64) ([]DashboardItem, error) {	83	func (s *Store) DashboardIssues(userID int64) ([]DashboardItem, error) {

internal/store/dashboard_test.go added +55

@@ -0,0 +1,55 @@
	1	package store
	2
	3	import "testing"
	4
	5	// An issue assigned to the user is not repeated under DashboardIssues:
	6	// AssignedIssues already covers it, and a repository the user can
	7	// otherwise reach (here, one they own) is the common case where the two
	8	// queries used to overlap (#265).
	9	func TestDashboardIssuesExcludesAssignedIssues(t *testing.T) {
	10	s := open(t)
	11	if err := s.MigrateUp(); err != nil {
	12	t.Fatal(err)
	13	}
	14	uid, err := s.CreateUser("cmc", false)
	15	if err != nil {
	16	t.Fatal(err)
	17	}
	18	repoID, err := s.CreateRepo("user", uid, "gitbay", "public")
	19	if err != nil {
	20	t.Fatal(err)
	21	}
	22	repo, err := s.RepoByID(repoID)
	23	if err != nil {
	24	t.Fatal(err)
	25	}
	26	assignedNum, err := s.CreateIssue(repo.ID, uid, "assigned to me", "", "markdown")
	27	if err != nil {
	28	t.Fatal(err)
	29	}
	30	if _, err := s.CreateIssue(repo.ID, uid, "not assigned", "", "markdown"); err != nil {
	31	t.Fatal(err)
	32	}
	33	assigned, err := s.IssueByNumber(repo.ID, assignedNum)
	34	if err != nil {
	35	t.Fatal(err)
	36	}
	37	if err := s.SetIssueAssignee(assigned.ID, uid, true); err != nil {
	38	t.Fatal(err)
	39	}
	40
	41	issues, err := s.DashboardIssues(uid)
	42	if err != nil {
	43	t.Fatal(err)
	44	}
	45	if len(issues) != 1 \|\| issues[0].Title != "not assigned" {
	46	t.Fatalf("DashboardIssues = %+v, want only the unassigned issue", issues)
	47	}
	48	assignedList, err := s.AssignedIssues(uid)
	49	if err != nil {
	50	t.Fatal(err)
	51	}
	52	if len(assignedList) != 1 \|\| assignedList[0].Title != "assigned to me" {
	53	t.Fatalf("AssignedIssues = %+v, want the assigned issue", assignedList)
	54	}
	55	}

internal/web/templates/dashboard.html +1 −1

	@@ -46,7 +46,7 @@
46		46
47	<aside class="feedcol" aria-label="Recent activity">	47	<aside class="feedcol" aria-label="Recent activity">
48	<h2 class="colhead">Recent activity</h2>	48	<h2 class="colhead">Recent activity</h2>
49	{{range .Feed}}<p class="feedline"><a href="/{{.Actor}}">{{.Actor}}</a> {{.Verb}} <a href="{{.URL}}"{{if .Jobs}} title="{{join .Jobs ", "}}"{{end}}>{{.Ref}}</a><br><span class="none">{{.Repo}} · <span title="{{whenT .WhenT}}">{{ago .WhenT}}</span></span></p>	49	{{range .Feed}}<p class="feedline"><a href="/{{.Actor}}">{{.Actor}}</a> {{.Verb}} <a href="{{.URL}}"{{if .Jobs}} title="{{join .Jobs ", "}}"{{end}}>{{.Ref}}</a>{{if .Extra}} {{.Extra}}{{end}}<br><span class="none">{{.Repo}} · <span title="{{whenT .WhenT}}">{{ago .WhenT}}</span></span></p>
50	{{else}}<p class="none">No activity yet</p>{{end}}	50	{{else}}<p class="none">No activity yet</p>{{end}}
51	</aside>	51	</aside>
52		52

internal/web/templates/owner.html +1 −1

	@@ -36,7 +36,7 @@
36	that goes back. */}}	36	that goes back. */}}
37	{{if .Log}}<h3 class="logsub">recent</h3>	37	{{if .Log}}<h3 class="logsub">recent</h3>
38	<div class="ownerlog">	38	<div class="ownerlog">
39	{{range .Log}}<p class="feedline"><a href="/{{.Actor}}">{{.Actor}}</a> {{.Verb}} <a href="{{.URL}}"{{if .Jobs}} title="{{join .Jobs ", "}}"{{end}}>{{.Ref}}</a><br><span class="none">{{.Repo}} · <span title="{{whenT .WhenT}}">{{ago .WhenT}}</span></span></p>	39	{{range .Log}}<p class="feedline"><a href="/{{.Actor}}">{{.Actor}}</a> {{.Verb}} <a href="{{.URL}}"{{if .Jobs}} title="{{join .Jobs ", "}}"{{end}}>{{.Ref}}</a>{{if .Extra}} {{.Extra}}{{end}}<br><span class="none">{{.Repo}} · <span title="{{whenT .WhenT}}">{{ago .WhenT}}</span></span></p>
40	{{end}}	40	{{end}}
41	</div>	41	</div>
42	<p class="meta"><a href="{{.Feed}}">activity feed</a></p>	42	<p class="meta"><a href="{{.Feed}}">activity feed</a></p>