Code sync, security fixes

internal/web/public.go

@@ -0,0 +1,115 @@
+package web
+
+import (
+	"net/http"
+
+	"github.com/andydixon/relata/internal/api"
+	"github.com/andydixon/relata/internal/relationships"
+)
+
+// publicBase carries what every public page needs.
+//
+// It deliberately does not embed `base`: the shared page context reads the
+// pending-review count from the database, and a page served to an anonymous
+// visitor must touch no workspace data at all.
+type publicBase struct {
+	Title        string
+	Version      string
+	SignedIn     bool
+	OAuthEnabled bool
+	LocalEnabled bool
+	ProviderName string
+	RequestID    string
+}
+
+func (h *Handlers) newPublicBase(r *http.Request, title string) publicBase {
+	return publicBase{
+		Title:        title,
+		Version:      h.d.Version,
+		SignedIn:     api.PrincipalFrom(r.Context()) != nil,
+		OAuthEnabled: h.oauthEnabled(),
+		LocalEnabled: h.localLoginEnabled(),
+		ProviderName: h.providerName(),
+	}
+}
+
+// LandingPage is the only dual-purpose route.
+//
+// Signed in, it is the dashboard. Signed out, it is a description of what
+// Relata does — served rather than redirected, so the front page of the site is
+// not a login form.
+func (h *Handlers) LandingPage(w http.ResponseWriter, r *http.Request) {
+	if api.PrincipalFrom(r.Context()) != nil {
+		h.Dashboard(w, r)
+		return
+	}
+
+	data := struct {
+		publicBase
+		Weights []publicWeightRow
+	}{
+		publicBase: h.newPublicBase(r, "Relata — a self-organising semantic document database"),
+		Weights:    publicWeightRows(),
+	}
+	h.d.Renderer.RenderPublic(w, r, "public_landing.html", http.StatusOK, data)
+}
+
+// HowItWorksPage explains the pipeline and the scoring, without any data.
+func (h *Handlers) HowItWorksPage(w http.ResponseWriter, r *http.Request) {
+	data := struct {
+		publicBase
+		Weights []publicWeightRow
+	}{
+		publicBase: h.newPublicBase(r, "How Relata works"),
+		Weights:    publicWeightRows(),
+	}
+	h.d.Renderer.RenderPublic(w, r, "public_how.html", http.StatusOK, data)
+}
+
+// PublicAPIPage describes the API and how to authenticate against it.
+func (h *Handlers) PublicAPIPage(w http.ResponseWriter, r *http.Request) {
+	data := struct {
+		publicBase
+		CallbackURL string
+	}{
+		publicBase:  h.newPublicBase(r, "The Relata API"),
+		CallbackURL: h.callbackURL(),
+	}
+	h.d.Renderer.RenderPublic(w, r, "public_api.html", http.StatusOK, data)
+}
+
+// publicWeightRow is one signal weight, shown publicly because the scoring model is
+// part of what the product claims rather than something to be discovered.
+type publicWeightRow struct {
+	Signal string
+	Weight float64
+	Means  string
+}
+
+func publicWeightRows() []publicWeightRow {
+	explain := map[string]string{
+		"content_hash_match":  "Byte-identical content.",
+		"semantic_similarity": "How alike the wording is, rebased so that ordinary similarity counts for little.",
+		"shared_entity":       "An exact entity match, discounted by how common that entity is.",
+		"claim_support":       "Two statements agree about the same subject.",
+		"claim_contradiction": "Two statements disagree about the same subject.",
+		"model_classification": "A language model's opinion. One signal, weighted below the storage " +
+			"threshold, so it can never create a relationship on its own.",
+		"shared_concept":     "Overlapping concept vocabulary.",
+		"alias_entity":       "A match through an alias a person confirmed. Unconfirmed candidates count for nothing.",
+		"temporal_proximity": "Created close together in time.",
+		"shared_metadata":    "Matching metadata you supplied.",
+		"user_confirmation":  "A person confirmed it. This dominates everything else.",
+		"user_rejection":     "A person rejected it. This drives the score to zero.",
+	}
+
+	rows := make([]publicWeightRow, 0, len(relationships.Weights))
+	for _, sig := range relationships.WeightOrder() {
+		rows = append(rows, publicWeightRow{
+			Signal: string(sig),
+			Weight: relationships.Weights[sig],
+			Means:  explain[string(sig)],
+		})
+	}
+	return rows
+}