16 KiB
16 KiB
phase, plan, type, wave, depends_on, files_modified, autonomous, requirements, must_haves
| phase | plan | type | wave | depends_on | files_modified | autonomous | requirements | must_haves | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 04-ux-improvements | 01 | execute | 1 |
|
true |
|
|
Purpose: Enables the frontend (Plan 03) to offer "Dismiss All" and "Dismiss Group" buttons. Output: Two new Store interface methods, implementations for both SQLite and PostgreSQL, two new HTTP handlers, route registrations, and tests.
<execution_context> @$HOME/.claude/get-shit-done/workflows/execute-plan.md @$HOME/.claude/get-shit-done/templates/summary.md </execution_context>
@.planning/PROJECT.md @.planning/ROADMAP.md @.planning/STATE.md @.planning/phases/04-ux-improvements/04-CONTEXT.md @.planning/phases/04-ux-improvements/04-RESEARCH.md From pkg/diunwebhook/store.go: ```go type Store interface { UpsertEvent(event DiunEvent) error GetUpdates() (map[string]UpdateEntry, error) AcknowledgeUpdate(image string) (found bool, err error) ListTags() ([]Tag, error) CreateTag(name string) (Tag, error) DeleteTag(id int) (found bool, err error) AssignTag(image string, tagID int) error UnassignTag(image string) error TagExists(id int) (bool, error) } ```From pkg/diunwebhook/sqlite_store.go (AcknowledgeUpdate pattern to follow):
func (s *SQLiteStore) AcknowledgeUpdate(image string) (found bool, err error) {
s.mu.Lock()
defer s.mu.Unlock()
res, err := s.db.Exec(`UPDATE updates SET acknowledged_at = datetime('now') WHERE image = ?`, image)
if err != nil {
return false, err
}
n, _ := res.RowsAffected()
return n > 0, nil
}
From pkg/diunwebhook/postgres_store.go (same method, PostgreSQL dialect):
func (s *PostgresStore) AcknowledgeUpdate(image string) (found bool, err error) {
res, err := s.db.Exec(`UPDATE updates SET acknowledged_at = NOW() WHERE image = $1`, image)
if err != nil {
return false, err
}
n, _ := res.RowsAffected()
return n > 0, nil
}
From pkg/diunwebhook/diunwebhook.go (DismissHandler pattern to follow):
func (s *Server) DismissHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPatch {
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
// ...
}
Current route registration order in cmd/diunwebhook/main.go:
mux.HandleFunc("/api/updates/", srv.DismissHandler)
mux.HandleFunc("/api/updates", srv.UpdatesHandler)
1. Add test helper exports to `export_test.go`:
```go
func (s *Server) TestAcknowledgeAll() (int, error) {
return s.Store().AcknowledgeAll()
}
func (s *Server) TestAcknowledgeByTag(tagID int) (int, error) {
return s.Store().AcknowledgeByTag(tagID)
}
```
(Add a `Store() Store` accessor method on Server if not already present, or access the store field directly via an existing test export pattern.)
2. Write store-level tests in `diunwebhook_test.go` following existing `Test<Function>_<Scenario>` convention:
- `TestAcknowledgeAll_Empty`: create server, call TestAcknowledgeAll, assert count=0, no error
- `TestAcknowledgeAll_AllUnacknowledged`: upsert 3 events via TestUpsertEvent, call TestAcknowledgeAll, assert count=3, then call GetUpdates and verify all have acknowledged=true
- `TestAcknowledgeAll_MixedState`: upsert 3 events, acknowledge 1 via existing dismiss, call TestAcknowledgeAll, assert count=2
- `TestAcknowledgeByTag_MatchingTag`: upsert 2 events, create tag, assign both to tag, call TestAcknowledgeByTag(tagID), assert count=2
- `TestAcknowledgeByTag_NonExistentTag`: call TestAcknowledgeByTag(9999), assert count=0, no error
- `TestAcknowledgeByTag_OnlyAffectsTargetTag`: upsert 3 events, create 2 tags, assign 2 events to tag1 and 1 to tag2, call TestAcknowledgeByTag(tag1.ID), assert count=2, verify tag2's event is still unacknowledged via GetUpdates
Run tests -- they must FAIL (RED) since methods don't exist yet.
3. Add two methods to the Store interface in `store.go` (per D-01):
```go
AcknowledgeAll() (count int, err error)
AcknowledgeByTag(tagID int) (count int, err error)
```
4. Implement in `sqlite_store.go` (following AcknowledgeUpdate pattern with mutex):
- `AcknowledgeAll`: `s.mu.Lock()`, `s.db.Exec("UPDATE updates SET acknowledged_at = datetime('now') WHERE acknowledged_at IS NULL")`, return `int(RowsAffected())`
- `AcknowledgeByTag`: `s.mu.Lock()`, `s.db.Exec("UPDATE updates SET acknowledged_at = datetime('now') WHERE acknowledged_at IS NULL AND image IN (SELECT image FROM tag_assignments WHERE tag_id = ?)", tagID)`, return `int(RowsAffected())`
5. Implement in `postgres_store.go` (no mutex, use NOW() and $1 positional param):
- `AcknowledgeAll`: `s.db.Exec("UPDATE updates SET acknowledged_at = NOW() WHERE acknowledged_at IS NULL")`, return `int(RowsAffected())`
- `AcknowledgeByTag`: `s.db.Exec("UPDATE updates SET acknowledged_at = NOW() WHERE acknowledged_at IS NULL AND image IN (SELECT image FROM tag_assignments WHERE tag_id = $1)", tagID)`, return `int(RowsAffected())`
6. Run tests again -- they must PASS (GREEN).
2. Add `AcknowledgeByTagHandler` to `diunwebhook.go` (per D-02):
```go
func (s *Server) AcknowledgeByTagHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes)
var req struct {
TagID int `json:"tag_id"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "bad request", http.StatusBadRequest)
return
}
if req.TagID <= 0 {
http.Error(w, "bad request: tag_id required", http.StatusBadRequest)
return
}
count, err := s.store.AcknowledgeByTag(req.TagID)
if err != nil {
log.Printf("AcknowledgeByTagHandler: %v", err)
http.Error(w, "internal error", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]int{"count": count})
}
```
3. Register routes in `main.go` -- CRITICAL: new specific paths BEFORE the existing `/api/updates/` subtree pattern:
```go
mux.HandleFunc("/api/updates/acknowledge-all", srv.AcknowledgeAllHandler)
mux.HandleFunc("/api/updates/acknowledge-by-tag", srv.AcknowledgeByTagHandler)
mux.HandleFunc("/api/updates/", srv.DismissHandler) // existing -- must remain after
mux.HandleFunc("/api/updates", srv.UpdatesHandler) // existing
```
4. Add test helper to `export_test.go`:
```go
func (s *Server) TestCreateTag(name string) (Tag, error) {
return s.store.CreateTag(name)
}
func (s *Server) TestAssignTag(image string, tagID int) error {
return s.store.AssignTag(image, tagID)
}
```
5. Write handler tests in `diunwebhook_test.go` following the existing `Test<Handler>_<Scenario>` naming convention. Use `NewTestServer()` for each test. Setup: use `TestUpsertEvent` to create events, `TestCreateTag` + `TestAssignTag` to setup tag assignments.
6. Also add the Vite dev proxy for the two new endpoints in `frontend/vite.config.ts` -- NOT needed, the existing proxy config already proxies all `/api` requests to `:8080`.
<success_criteria>
- Store interface has 11 methods (9 existing + 2 new)
- Both SQLiteStore and PostgresStore implement all 11 methods
- POST /api/updates/acknowledge-all returns 200 + {"count": N}
- POST /api/updates/acknowledge-by-tag returns 200 + {"count": N}
- All existing tests continue to pass
- Route registration order prevents DismissHandler from shadowing new endpoints </success_criteria>