inbound-antispam-panel: Inbound > Log and Inbound > Filter lists
Step 6/12 of docs/plans/inbound-antispam-panel.md. Written by a Sonnet
subagent from the mockups, reviewed and corrected by me.
GET /inbound/log - the journal a page at a time (50), filtered by
domain, decision and day; QueryInboundSpam / CountInboundSpam with the
viewer's inbound domains as the scope. The global role reads all of it
and gets "Deny sender" / "Allow sender" links into the lists; a user
with the domain role reads the rows of the inbound domains assigned to
them, without the links. The plan said global-only for the journal;
the accepted mockup and 2.0's delegation of Inbound say otherwise -
recorded in the plan as built.
GET, POST /inbound/filter-lists and POST .../{id}/delete - global role,
404 otherwise. Add form (prefilled from the query), the two lists with
Remove as the kit's row action, and "Where the lists go" with the
filter's state and when the maps were last written
(Lists.LastWritten). A refused or duplicate entry is 422 with the
message and what was typed.
Server > Settings: "Keep inbound log rows, days" with the relay on.
Help: Inbound log, Filter lists. Navigation: Log for everyone who sees
Inbound, Filter lists for the global role (Shell.ShowFilterLists).
Status tags accept / reject / tempfail join the kit's mapping.
Tests: page fixtures for both screens, held to outlines.json; view and
handler tests (both roles, filters, paging, relay off, add / duplicate
/ invalid / delete, map file content, settings field, help). e2e reads
the journal from the page instead of the database and adds and removes
a deny entry through the panel, reading deny_domain.map after each.
Seen: both pages and Settings rendered from their fixtures and compared
with the mockups side by side (headless Edge, 1360 px) - same layout
and wording.
Checked on the test server, uncommitted tree: go vet ./... ok,
go test ./... ok (22 packages), make e2e ok.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,205 @@
|
||||
package view
|
||||
|
||||
// The data of the Inbound log (templates/in_log.html, mockup in-log.html): what
|
||||
// port 25 decided about each message offered for an inbound domain, one row per
|
||||
// recipient. Unlike the Outbound log it does not poll: a decision does not change
|
||||
// after it is made, and the page is read to find one row, not watched.
|
||||
//
|
||||
// A page is a typed struct that embeds Meta, built by a constructor and filled
|
||||
// by With… methods; the handler reads the journal, the view decides what is
|
||||
// said and how it is worded.
|
||||
|
||||
import (
|
||||
"net/url"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
const inboundLog = "/inbound/log"
|
||||
|
||||
// InLogFilter is what the filters of the Inbound log are set to, as the strings
|
||||
// the form sends: a domain name, a decision and two days (2006-01-02). Empty
|
||||
// means no narrowing.
|
||||
type InLogFilter struct {
|
||||
Domain string
|
||||
Decision string
|
||||
From string
|
||||
To string
|
||||
}
|
||||
|
||||
func (f InLogFilter) active() bool { return f != InLogFilter{} }
|
||||
|
||||
// query is the query string of a page of the log: the filters and the page, each
|
||||
// left out when it says nothing, so the first unfiltered page is the bare path.
|
||||
func (f InLogFilter) query(page int) string {
|
||||
q := url.Values{}
|
||||
for name, v := range map[string]string{"domain": f.Domain, "decision": f.Decision, "from": f.From, "to": f.To} {
|
||||
if v != "" {
|
||||
q.Set(name, v)
|
||||
}
|
||||
}
|
||||
if page > 1 {
|
||||
q.Set("p", strconv.Itoa(page))
|
||||
}
|
||||
if len(q) == 0 {
|
||||
return ""
|
||||
}
|
||||
return "?" + q.Encode()
|
||||
}
|
||||
|
||||
// InLogHref is the address of a page of the Inbound log.
|
||||
func InLogHref(f InLogFilter, page int) string { return inboundLog + f.query(page) }
|
||||
|
||||
// InLog is the data of the Inbound log: the decisions about mail for the inbound
|
||||
// domains the viewer reaches, filtered by domain, decision and day, a page at a
|
||||
// time.
|
||||
type InLog struct {
|
||||
Meta
|
||||
Head Head
|
||||
|
||||
Messages Box
|
||||
Rows []InLogRow
|
||||
Empty EmptyState
|
||||
Foot Foot
|
||||
|
||||
filter InLogFilter
|
||||
}
|
||||
|
||||
// InLogRow is one recipient of one message: when it was decided, who the mail
|
||||
// was from (and the address of the server that offered it) and for, its subject,
|
||||
// the decision as a tag, who decided and why, and — for the global role, who
|
||||
// alone edits the filter lists — the way to correct the decision.
|
||||
type InLogRow struct {
|
||||
Time string
|
||||
From string
|
||||
Client string
|
||||
To string
|
||||
Subject string
|
||||
Decision Tag
|
||||
Why string
|
||||
Action *Anchor
|
||||
}
|
||||
|
||||
// InLogRowInput is what the journal holds about one row. Subject, Detail and
|
||||
// From may be empty: refused mail is read from mail.log, which has no subject,
|
||||
// and a filter that said nothing has no detail.
|
||||
type InLogRowInput struct {
|
||||
At time.Time
|
||||
From string
|
||||
Client string
|
||||
To string
|
||||
Subject string
|
||||
Decision string
|
||||
Engine string
|
||||
Detail string
|
||||
}
|
||||
|
||||
// NewInLog builds the log for a viewer. domains are the choices of the domain
|
||||
// filter (only the inbound domains the viewer reaches) and filter is what is in
|
||||
// force. retentionDays is how long rows are kept; the global role, who can
|
||||
// change it and who edits the lists, is read from m.
|
||||
func NewInLog(m Meta, retentionDays int, domains []string, filter InLogFilter) *InLog {
|
||||
m.Title, m.Section, m.Page = "Inbound log", "inbound", "log"
|
||||
lead := Rich("What port 25 decided about each message, one row per recipient. Accepted mail is recorded as it passes, refused mail is read from ",
|
||||
Code("mail.log"), "; the filter's verdict appears when the spam filter is on. Rows older than "+plural(int64(retentionDays), "day", "days")+" are deleted")
|
||||
if m.IsGlobal {
|
||||
lead = append(lead, Inline{Text: " — change that in "}, Link("/server/settings", "Settings"))
|
||||
}
|
||||
lead = append(lead, Inline{Text: "."})
|
||||
|
||||
domainOptions := []Option{{Value: "", Label: "All domains"}}
|
||||
for _, d := range domains {
|
||||
domainOptions = append(domainOptions, Option{Value: d, Label: d})
|
||||
}
|
||||
decisionOptions := []Option{{Value: "", Label: "Any decision"}}
|
||||
for _, d := range []string{"accept", "reject", "tempfail", "quarantine"} {
|
||||
decisionOptions = append(decisionOptions, Option{Value: d, Label: d})
|
||||
}
|
||||
p := &InLog{
|
||||
Meta: m,
|
||||
Head: Head{Kicker: "Inbound", Title: "Inbound log", Lead: lead},
|
||||
Messages: Box{No: "01", Title: "Messages", Help: topicLink(HelpInboundLog, "What the decisions mean"), Filter: &Filter{
|
||||
Action: inboundLog,
|
||||
Selects: []Select{
|
||||
{Name: "domain", Label: "Domain", Options: domainOptions, Selected: filter.Domain},
|
||||
{Name: "decision", Label: "Decision", Options: decisionOptions, Selected: filter.Decision},
|
||||
},
|
||||
Dates: []DateInput{
|
||||
{Name: "from", Label: "From date", Value: filter.From},
|
||||
{Name: "to", Label: "To date", Value: filter.To},
|
||||
},
|
||||
}},
|
||||
Empty: EmptyState{Icon: "ti-list-details", Text: Plain("No messages logged yet.")},
|
||||
filter: filter,
|
||||
}
|
||||
if filter.active() {
|
||||
p.Empty.Text = Plain("No messages match these filters.")
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// NewRow words one row of the journal for the viewer of the page.
|
||||
func (p *InLog) NewRow(in InLogRowInput) InLogRow {
|
||||
why := in.Engine
|
||||
if in.Detail != "" {
|
||||
why += " · " + in.Detail
|
||||
}
|
||||
r := InLogRow{
|
||||
Time: FormatLogTime(in.At), From: orDash(in.From), Client: in.Client, To: in.To, Subject: in.Subject,
|
||||
Decision: Tag{Status: in.Decision}, Why: why,
|
||||
}
|
||||
if p.IsGlobal {
|
||||
r.Action = senderAction(in.Decision, in.Engine, in.From)
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// senderAction is the way to correct a decision from its row, if there is one:
|
||||
// a message that got through is the one to deny its sender for, a message the
|
||||
// filter turned away or put off is the one to allow its sender for, and a
|
||||
// refusal by Postfix's own policy (an unknown recipient, say) can only be
|
||||
// answered by denying — allowing the sender would not change what Postfix
|
||||
// thinks of the recipient. A row with no sender has nobody to list.
|
||||
func senderAction(decision, engine, from string) *Anchor {
|
||||
if from == "" {
|
||||
return nil
|
||||
}
|
||||
list := ""
|
||||
switch {
|
||||
case decision == "accept":
|
||||
list = "deny"
|
||||
case engine == "rspamd":
|
||||
list = "allow"
|
||||
case decision == "reject" && engine == "postfix":
|
||||
list = "deny"
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
label := "Deny sender"
|
||||
if list == "allow" {
|
||||
label = "Allow sender"
|
||||
}
|
||||
return &Anchor{Href: FilterListsHref(list, "address", from), Label: label}
|
||||
}
|
||||
|
||||
// WithRows sets the table for page of last, and the foot under it: where the
|
||||
// viewer is, and the way to the newer and older rows. For the global role the
|
||||
// foot also says where the sender links lead.
|
||||
func (p *InLog) WithRows(rows []InLogRow, page, last int) *InLog {
|
||||
p.Rows = rows
|
||||
if len(rows) == 0 {
|
||||
return p
|
||||
}
|
||||
text := Rich("Page " + strconv.Itoa(page) + " of " + strconv.Itoa(last))
|
||||
if page > 1 {
|
||||
text = append(text, Inline{Text: " · "}, Link(InLogHref(p.filter, page-1), "← Newer"))
|
||||
}
|
||||
p.Foot.Text = text
|
||||
if page < last {
|
||||
p.Foot.Link = &Anchor{Href: InLogHref(p.filter, page+1), Label: "Older →"}
|
||||
}
|
||||
if p.IsGlobal {
|
||||
p.Foot.End = Rich("Allow / Deny sender opens ", Link(inboundFilterLists, "Filter lists"), " with the entry filled in")
|
||||
}
|
||||
return p
|
||||
}
|
||||
Reference in New Issue
Block a user