Diskussionsketten: jüngste Antwort im Teilbaum an Feed- und Antwortkarten
Jede Karte in Feed und Antwortliste zeigt die Antwort, die ihre Diskussion zuletzt fortgesetzt hat: [Beitrag] -- "k weitere Beiträge" -- [Antwort]. Gelöschte Beiträge werden als jüngste übersprungen, zählen auf dem Pfad mit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TiXsPUqw7oeomZ8wZrQW5q
This commit is contained in:
irrlicht
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
8e79e94bbb
commit
ade853f560
@@ -314,6 +314,10 @@ type threadEntry struct {
|
||||
Deleted int64 `json:"deleted"`
|
||||
Content string `json:"content"`
|
||||
Username string `json:"username"`
|
||||
Latest *struct {
|
||||
Entry threadEntry `json:"entry"`
|
||||
Skipped int64 `json:"skipped"`
|
||||
} `json:"latest"`
|
||||
}
|
||||
|
||||
// threadJSON ist die Antwortform von /entry/{pid}/thread. Nicht zu verwechseln
|
||||
@@ -438,6 +442,64 @@ func TestEditEntry(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// latestOf beschreibt Latest eines Beitrags knapp für Vergleiche und
|
||||
// Fehlermeldungen: "pid/skipped" oder "-".
|
||||
func latestOf(e threadEntry) string {
|
||||
if e.Latest == nil {
|
||||
return "-"
|
||||
}
|
||||
return fmt.Sprintf("%d/%d", e.Latest.Entry.PID, e.Latest.Skipped)
|
||||
}
|
||||
|
||||
func TestLatestDescendant(t *testing.T) {
|
||||
srv := newTestServer(t)
|
||||
alice := registerAndLogin(t, srv, "alice")
|
||||
|
||||
// root ── a ── b ── c
|
||||
// └─ d (d vor b und c erstellt)
|
||||
root := createEntry(t, alice, srv, "wurzel")
|
||||
a := createReply(t, alice, srv, "a", root)
|
||||
d := createReply(t, alice, srv, "d", root)
|
||||
b := createReply(t, alice, srv, "b", a)
|
||||
c := createReply(t, alice, srv, "c", b)
|
||||
|
||||
feed := func() []threadEntry {
|
||||
resp, err := http.Get(srv.URL + "/api/entry/feed/0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
var f []threadEntry
|
||||
json.NewDecoder(resp.Body).Decode(&f)
|
||||
return f
|
||||
}
|
||||
|
||||
// Feed: Root mit c, dazwischen a und b.
|
||||
if f := feed(); len(f) != 1 || latestOf(f[0]) != fmt.Sprintf("%d/2", c) {
|
||||
t.Fatalf("feed latest: erwartet %d/2, bekam %s", c, latestOf(f[0]))
|
||||
}
|
||||
|
||||
// Antworten auf Root: a mit c (b dazwischen), d ohne Nachfahren.
|
||||
want := map[int64]string{a: fmt.Sprintf("%d/1", c), d: "-"}
|
||||
for _, r := range getThread(t, srv, root).Replies {
|
||||
if got := latestOf(r); got != want[r.PID] {
|
||||
t.Fatalf("reply %d latest: erwartet %s, bekam %s", r.PID, want[r.PID], got)
|
||||
}
|
||||
}
|
||||
|
||||
// Direkte Antwort: skipped 0.
|
||||
if r := getThread(t, srv, a).Replies; len(r) != 1 || latestOf(r[0]) != fmt.Sprintf("%d/0", c) {
|
||||
t.Fatalf("b latest: erwartet %d/0, bekam %+v", c, r)
|
||||
}
|
||||
|
||||
// Gelöschter jüngster Beitrag wird übersprungen -> nächstjüngerer (b).
|
||||
resp := postForm(t, alice, fmt.Sprintf("%s/api/entry/%d/delete", srv.URL, c), url.Values{})
|
||||
resp.Body.Close()
|
||||
if f := feed(); latestOf(f[0]) != fmt.Sprintf("%d/1", b) {
|
||||
t.Fatalf("feed latest nach delete: erwartet %d/1, bekam %s", b, latestOf(f[0]))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSoftDelete(t *testing.T) {
|
||||
srv := newTestServer(t)
|
||||
alice := registerAndLogin(t, srv, "alice")
|
||||
|
||||
@@ -35,6 +35,16 @@ type Entry struct {
|
||||
LastBump int64 `json:"last_bump"`
|
||||
Username string `json:"username"`
|
||||
Avatar string `json:"avatar"`
|
||||
// Latest ist nur in Feed und Antwortliste gesetzt, siehe attachLatest.
|
||||
Latest *Latest `json:"latest,omitempty"`
|
||||
}
|
||||
|
||||
// Latest ist der jüngste (nicht gelöschte) Beitrag im Teilbaum unter einem
|
||||
// Beitrag -- die Antwort, die die Diskussion zuletzt fortgesetzt hat. Skipped
|
||||
// zählt die Beiträge, die auf dem Pfad dazwischen liegen (0 = direkte Antwort).
|
||||
type Latest struct {
|
||||
Entry Entry `json:"entry"`
|
||||
Skipped int64 `json:"skipped"`
|
||||
}
|
||||
|
||||
// LEFT JOIN + COALESCE, damit soft-gelöschte Beiträge (uid auf 0 gesetzt) als
|
||||
@@ -124,12 +134,90 @@ func feedPage(page int, uid int64, rootsOnly bool) ([]Entry, error) {
|
||||
return scanEntries(rows)
|
||||
}
|
||||
|
||||
// attachLatest hängt an jeden Beitrag den jüngsten nicht gelöschten Beitrag
|
||||
// aus seinem Teilbaum (Latest). So bildet eine flache Liste auch tiefe
|
||||
// Diskussionen ab: [Beitrag] -- "k weitere" -- [jüngste Antwort], ein Klick
|
||||
// führt ans aktuelle Ende.
|
||||
//
|
||||
// Ein Query für alle Beiträge: die rekursive CTE steigt von allen zugleich
|
||||
// ab, top merkt sich den Ausgangsbeitrag, depth die Tiefe darunter. Das Limit
|
||||
// deckelt die Tiefe wie bei der Ahnenkette (threadData).
|
||||
func attachLatest(entries []Entry) error {
|
||||
if len(entries) == 0 {
|
||||
return nil
|
||||
}
|
||||
pids := make([]int64, len(entries))
|
||||
for i, e := range entries {
|
||||
pids[i] = e.PID
|
||||
}
|
||||
|
||||
rows, err := db.Query(
|
||||
`WITH RECURSIVE sub(top, pid, depth) AS (
|
||||
SELECT e.reply_to, e.pid, 1 FROM entry e WHERE e.reply_to = ANY($1)
|
||||
UNION ALL
|
||||
SELECT s.top, e.pid, s.depth + 1
|
||||
FROM entry e JOIN sub s ON e.reply_to = s.pid
|
||||
WHERE s.depth < 50
|
||||
)
|
||||
SELECT DISTINCT ON (s.top) s.top, s.pid, s.depth
|
||||
FROM sub s JOIN entry x ON x.pid = s.pid
|
||||
WHERE x.deleted = 0
|
||||
ORDER BY s.top, x.created_at DESC, x.id DESC`, pids)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
type hit struct{ pid, depth int64 }
|
||||
hits := map[int64]hit{}
|
||||
latestPIDs := []int64{}
|
||||
for rows.Next() {
|
||||
var top int64
|
||||
var h hit
|
||||
if err := rows.Scan(&top, &h.pid, &h.depth); err != nil {
|
||||
rows.Close()
|
||||
return err
|
||||
}
|
||||
hits[top] = h
|
||||
latestPIDs = append(latestPIDs, h.pid)
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(latestPIDs) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
rows, err = db.Query(entrySelect+` WHERE e.pid = ANY($1)`, latestPIDs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
latest, err := scanEntries(rows)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
byPID := make(map[int64]Entry, len(latest))
|
||||
for _, e := range latest {
|
||||
byPID[e.PID] = e
|
||||
}
|
||||
for i := range entries {
|
||||
if h, ok := hits[entries[i].PID]; ok {
|
||||
if e, ok := byPID[h.pid]; ok {
|
||||
entries[i].Latest = &Latest{Entry: e, Skipped: h.depth - 1}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func handleFeed(w http.ResponseWriter, r *http.Request) error {
|
||||
page, _ := strconv.Atoi(chi.URLParam(r, "page"))
|
||||
entries, err := feedPage(page, 0, true)
|
||||
if err != nil {
|
||||
return Internal(err)
|
||||
}
|
||||
if err := attachLatest(entries); err != nil {
|
||||
return Internal(err)
|
||||
}
|
||||
writeJSON(w, http.StatusOK, entries)
|
||||
return nil
|
||||
}
|
||||
@@ -166,7 +254,7 @@ func pidParam(r *http.Request) (int64, error) {
|
||||
}
|
||||
|
||||
// handleThread liefert einen Beitrag mit seiner Ahnenkette (Root zuerst) und den
|
||||
// direkten Antworten (öffentlich).
|
||||
// direkten Antworten samt deren jüngstem Nachfahren (öffentlich).
|
||||
func handleThread(w http.ResponseWriter, r *http.Request) error {
|
||||
pid, err := pidParam(r)
|
||||
if err != nil {
|
||||
@@ -232,6 +320,9 @@ func threadData(pid int64) (thread, error) {
|
||||
if t.Replies, err = scanEntries(rows); err != nil {
|
||||
return thread{}, Internal(err)
|
||||
}
|
||||
if err := attachLatest(t.Replies); err != nil {
|
||||
return thread{}, Internal(err)
|
||||
}
|
||||
return t, nil
|
||||
}
|
||||
|
||||
|
||||
@@ -271,6 +271,16 @@ img.avatar-lg { width: 72px; height: 72px; }
|
||||
/* Nur die Vorfahren bilden einen Thread -> Linie. Antworten nur eingerückt. */
|
||||
#ancestors .threadline { border-right: var(--line-w) solid gray; }
|
||||
|
||||
/* Diskussionskette in Feed und Antworten (Discussion): Beitrag, ggf.
|
||||
"k weitere Beiträge", jüngste Antwort. Gleiches Bild wie die Ahnenkette --
|
||||
Strich an allen Gliedern außer dem letzten. */
|
||||
.chain > :not(:last-child) .threadline {
|
||||
display: block;
|
||||
flex: 0 0 calc(var(--avatar-sm) / 2 - var(--line-w));
|
||||
margin-right: calc(var(--avatar-sm) / 2);
|
||||
border-right: var(--line-w) solid gray;
|
||||
}
|
||||
|
||||
/* Interaktionsleiste: Antworten-Button links, Vote-Buttons mittig, Repost
|
||||
rechts. Antwort- und Repost-Zahl stehen in den Buttons; der Repost-Cooldown
|
||||
wandert in die Byline (siehe setupBump). */
|
||||
|
||||
@@ -65,3 +65,28 @@ function LiveCard({ entry: e, when, open }: { entry: Entry; when: string; open:
|
||||
</article>
|
||||
);
|
||||
}
|
||||
|
||||
// Discussion zeigt einen Beitrag mit der Antwort, die seine Diskussion zuletzt
|
||||
// fortgesetzt hat: [Beitrag] ── "k weitere Beiträge" ── [jüngste Antwort].
|
||||
// Der Strich verbindet die Glieder wie in der Ahnenkette; "k weitere" führt
|
||||
// wie die Antwort selbst zu deren Seite, wo die ganze Kette darüber steht.
|
||||
export function Discussion({ entry: e }: { entry: Entry }) {
|
||||
if (!e.latest) return <EntryCard entry={e} />;
|
||||
const { entry: latest, skipped } = e.latest;
|
||||
return (
|
||||
<div className="chain">
|
||||
<EntryCard entry={e} />
|
||||
{skipped > 0 && (
|
||||
<div className="threadline-wrapper">
|
||||
<div className="threadline"></div>
|
||||
<div className="body muted">
|
||||
<Link to={`/e/${latest.pid}`}>
|
||||
{skipped === 1 ? "1 weiterer Beitrag" : `${skipped} weitere Beiträge`}
|
||||
</Link>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
<EntryCard entry={latest} />
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ import { useEffect, useRef } from "react";
|
||||
import { useInfiniteQuery } from "@tanstack/react-query";
|
||||
import { api, errMsg } from "../api";
|
||||
import type { Entry } from "../types";
|
||||
import { EntryCard } from "./EntryCard";
|
||||
import { Discussion } from "./EntryCard";
|
||||
|
||||
// Das Backend deckelt die Seitenzahl bei 100 und liefert darüber wieder
|
||||
// Seite 100 -- ohne diese Grenze würde der Feed sie endlos wiederholen.
|
||||
@@ -54,7 +54,7 @@ export function Feed({ queryKey, urlFor, as: Container = "section" }: {
|
||||
return (
|
||||
<>
|
||||
<Container id="feed">
|
||||
{entries.map((e) => <EntryCard key={e.pid} entry={e} />)}
|
||||
{entries.map((e) => <Discussion key={e.pid} entry={e} />)}
|
||||
{feed.isError && <p className="msg">{errMsg(feed.error, "Feed konnte nicht geladen werden.")}</p>}
|
||||
{feed.isSuccess && !hasNextPage && <p className="muted">YOU REACHED THE END!</p>}
|
||||
</Container>
|
||||
|
||||
@@ -4,7 +4,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
|
||||
import { api, errMsg } from "../api";
|
||||
import { useMe } from "../auth";
|
||||
import { pasteImage } from "../paste";
|
||||
import { EntryCard } from "../components/EntryCard";
|
||||
import { Discussion, EntryCard } from "../components/EntryCard";
|
||||
import type { CreatedEntry, Entry, Thread } from "../types";
|
||||
|
||||
// Beim Wechsel zu einem anderen Beitrag frisch anfangen (offene Bearbeitung,
|
||||
@@ -56,7 +56,7 @@ function ThreadView({ pid }: { pid: string }) {
|
||||
|
||||
<section id="replies">
|
||||
{data && !data.replies.length && <p className="muted">Noch keine Antworten.</p>}
|
||||
{data?.replies.map((e) => <EntryCard key={e.pid} entry={e} />)}
|
||||
{data?.replies.map((e) => <Discussion key={e.pid} entry={e} />)}
|
||||
</section>
|
||||
</>
|
||||
);
|
||||
|
||||
@@ -15,6 +15,9 @@ export interface Entry {
|
||||
last_bump: number;
|
||||
username: string;
|
||||
avatar: string;
|
||||
// Nur in Feed und Antwortliste: jüngster Beitrag im Teilbaum, skipped =
|
||||
// Beiträge auf dem Pfad dazwischen (0 = direkte Antwort).
|
||||
latest?: { entry: Entry; skipped: number };
|
||||
}
|
||||
|
||||
export interface Thread {
|
||||
|
||||
Reference in New Issue
Block a user