mixandClaude Opus 5.5
96db0b7a86
Follows the design and guard commits before it. Written by Sonnet,
reviewed by Opus.
The report address
- Baseline: users.dmarc_default_mode, users.dmarc_default_address and
domains.dmarc_rua_user_id are gone. domains.dmarc_rua alone says
where reports go: '' is no reports (a new domain), the address
SelfPost derives for the domain is the hosted choice (while hosted
reports are on), anything else is a typed address.
- Removed: the user default and its store functions, a domain
following a user, keep / inherit, followCreator, POST /account/dmarc
with its handler, the DMARC box of Account, the user-delete item
about domains losing their address.
- Domain settings offers the three choices; beside the typed address a
"Use my e-mail" button fills in the profile e-mail (panel.js: one
generic data-fill hook; absent without a profile e-mail; it fills,
it does not save).
- The DMARC record's note names the address and no user. This closes
L4 of the security review.
- Domain export / import carries the address as a plain string.
- The ingest allow-list is the generic mailbox plus each domain's
address on this host; the generic mailbox is always open now.
- dev/migrate1x (not in the tree): a 1.x domain that inherited the
instance default gets that address as its own, so no published rua=
changes.
Row actions
- row_action partial (RowAction: Label, Post, Confirm, Danger);
panel.css has the mockup's three rules. A row of the Applications
table is Edit, New password, Delete; the confirmation texts are the
ones the application page's head uses. Both roles, with the checks
of the application page.
Tests cover: a new domain has no reports; each choice saved and shown
selected; hosted refused when hosted reports are off; a bad address
refused with what was typed kept; an untouched save changes nothing in
each state; the fill button with and without a profile e-mail; deleting
a user leaves every domain's address; the row's forms, targets and
confirmations for both roles and a 404 for a stranger.
Known: if hosted reports are switched off later, a stored hosted address
reads as a typed one. docs/guide.md still describes the old choices -
the documentation step.
Evidence
- docs/assets/panel-redesign/evidence/account.png,
out-domain-settings.png, out-domain.png, user-delete.png, help.png:
1440 px wide, headless Edge, real templates served locally with
their fixtures - NOT from the container.
- panel/audit.js on out-domain, out-domain-settings, account, help,
components and user-delete at 1440 and 1280: 1420 texts checked,
problems: [].
- In a browser: the fill button sets the field and does not submit;
the row buttons have the font, size and colour of the Edit link,
Delete the red of the other delete links; data-confirm fires on
both. Hover and focus states were not observed.
- go test -count=1 ./internal/web/... ./internal/store/...
./internal/dmarc/... ./internal/app/... ./internal/inbound/...
./cmd/panel: ok (ten packages; dev/migrate1x also ok).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
73 lines
2.0 KiB
Go
73 lines
2.0 KiB
Go
package handlers
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/mixeme/selfpost/internal/dmarc"
|
|
"github.com/mixeme/selfpost/internal/store"
|
|
"github.com/mixeme/selfpost/internal/web/auth"
|
|
"github.com/mixeme/selfpost/internal/web/view"
|
|
)
|
|
|
|
func (h *Handlers) principal(r *http.Request) (auth.Principal, bool) {
|
|
return auth.PrincipalFromRequest(r)
|
|
}
|
|
|
|
func (h *Handlers) requireGlobal(w http.ResponseWriter, r *http.Request) (auth.Principal, bool) {
|
|
p, ok := h.principal(r)
|
|
if !ok || !p.IsGlobal() {
|
|
http.NotFound(w, r)
|
|
return auth.Principal{}, false
|
|
}
|
|
return p, true
|
|
}
|
|
|
|
// shellMeta is what the shell of a page of the component kit needs to know
|
|
// about the person looking at it: their name and which groups of the menu they
|
|
// reach. The page's constructor adds its title and where it sits in the menu.
|
|
func (h *Handlers) shellMeta(r *http.Request) view.Meta {
|
|
p, _ := h.principal(r)
|
|
user := auth.CurrentUser(r)
|
|
if user == "" {
|
|
user = p.Username
|
|
}
|
|
return view.Meta{User: user, IsGlobal: p.IsGlobal(), HasOutbound: p.HasOutbound(), HasInbound: p.HasInbound()}
|
|
}
|
|
|
|
func (h *Handlers) assignedDomains(p auth.Principal) ([]store.Domain, error) {
|
|
if p.IsGlobal() {
|
|
return h.store.ListDomains()
|
|
}
|
|
return h.store.ListDomainsForUser(p.ID)
|
|
}
|
|
|
|
// hostedDMARCAddress is the SelfPost-hosted report mailbox for a sending
|
|
// domain, "" when report ingest is off on this server.
|
|
func (h *Handlers) hostedDMARCAddress(domainName string) string {
|
|
if h.dmarc == nil || !h.cfg.DMARCEnabled {
|
|
return ""
|
|
}
|
|
return dmarc.HostedReportAddress(h.cfg.Hostname, domainName)
|
|
}
|
|
|
|
func domainNameSet(domains []store.Domain) map[string]bool {
|
|
m := make(map[string]bool, len(domains))
|
|
for _, d := range domains {
|
|
m[d.Name] = true
|
|
}
|
|
return m
|
|
}
|
|
|
|
// domainIDSet is the set of sending domains a principal is limited to; nil
|
|
// means no limit (the global role, or a domain user with All).
|
|
func domainIDSet(p auth.Principal) map[int64]bool {
|
|
if p.IsGlobal() || p.AllDomains {
|
|
return nil
|
|
}
|
|
m := make(map[int64]bool, len(p.Domains))
|
|
for _, id := range p.Domains {
|
|
m[id] = true
|
|
}
|
|
return m
|
|
}
|