Lunch Tracker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// decodeJSON rejects non-JSON Content-Type, decodes the body into
    // dst, and rejects unknown fields. Returns true on success; on
    // failure it has already written the error response.
    func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
    if ct := r.Header.Get("Content-Type"); ct != "" &&
    !strings.HasPrefix(ct, "application/json") {
    http.Error(w, "Content-Type must be application/json", http.StatusUnsupportedMediaType)
    return false
    }
    dec := json.NewDecoder(r.Body)
    dec.DisallowUnknownFields()
    if err := dec.Decode(dst); err != nil {
    writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON: " + err.Error()})
    return false
    }
    return true
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// handleClockIn persists the latest clock-in for a date.
    func (s *server) handleClockIn(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()

    var rec ClockIn
    if !decodeJSON(w, r, &rec) {
    return
    }

    date, err := time.ParseInLocation("2006-01-02", rec.Date, time.Local)
    if err != nil {
    writeJSON(w, http.StatusBadRequest, map[string]string{"error": "date must be YYYY-MM-DD"})
    return
    }
    ci, err := parseClockIn(rec.ClockIn)
    if err != nil {
    writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
    return
    }

    // Reject clock-ins that are noticeably in the future relative to
    // the server's wall-clock. The HRMS page sometimes shows a stale
    // "Checked In" text from the previous day; without this guard the
    // userscript would happily store a 1:15 PM record for an 11:00 AM
    // today.
    now := time.Now()
    if ci.After(now.Add(clockInFutureSlack)) {
    writeJSON(w, http.StatusBadRequest, map[string]string{
    "error": fmt.Sprintf("clock-in %s is in the future (now=%s); refusing to store a stale or fake record",
    rec.ClockIn, now.Format("3:04:05 PM")),
    })
    return
    }
    // ...date-in-future guard, persist, respond
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Caller must hold s.mu (write).
    func pruneOldRecordsLocked(records map[string]ClockIn) {
    if len(records) == 0 {
    return
    }
    // Fast path: under the cap, and no stale weekday entries are
    // possible because a workweek holds at most maxRetainedDays rows.
    if len(records) <= maxRetainedDays {
    // Even under the cap, defensive prune: drop anything that
    // somehow pre-dates the current Sunday (e.g. legacy data.json
    // from before this rule shipped). The loop is cheap and
    // guarantees the invariant.
    boundary := currentWorkweekStart(time.Now())
    for d := range records {
    if d < boundary {
    delete(records, d)
    }
    }
    return
    }
    // ...fall-through: full prune + oldest-first truncation
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// flushLocked writes the in-memory map atomically: encode to a
    // temp file in the same directory and rename over the destination.
    // Caller must hold writeMu.
    func (s *Store) flushLocked() error {
    s.mu.RLock()
    buf, err := json.MarshalIndent(s.records, "", " ")
    s.mu.RUnlock()
    if err != nil {
    return fmt.Errorf("encode %s: %w", s.path, err)
    }

    dir := filepath.Dir(s.path)
    tmp, err := os.CreateTemp(dir, "data-*.json.tmp")
    if err != nil {
    return fmt.Errorf("create temp: %w", err)
    }
    tmpName := tmp.Name()
    cleanup := func() { _ = os.Remove(tmpName) }

    if _, err := tmp.Write(buf); err != nil {
    _ = tmp.Close()
    cleanup()
    return fmt.Errorf("write temp: %w", err)
    }
    if err := tmp.Sync(); err != nil {
    _ = tmp.Close()
    cleanup()
    return fmt.Errorf("sync temp: %w", err)
    }
    if err := tmp.Close(); err != nil {
    cleanup()
    return fmt.Errorf("close temp: %w", err)
    }
    if err := os.Rename(tmpName, s.path); err != nil {
    cleanup()
    return fmt.Errorf("rename: %w", err)
    }
    return nil
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// matchOrigin returns true if pattern matches origin. The single
    // wildcard "*" matches everything; otherwise the match is exact.
    func matchOrigin(pattern, origin string) bool {
    if pattern == "*" {
    return true
    }
    if !strings.HasPrefix(pattern, "https://") &&
    !strings.HasPrefix(pattern, "http://") {
    return false
    }
    return pattern == origin
    }