Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
153 lines
4.8 KiB
Go
153 lines
4.8 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"html/template"
|
|
"mime"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"pageswiki/internal/store"
|
|
)
|
|
|
|
const (
|
|
maxPrintTextBytes = int64(2 << 20)
|
|
maxPrintHydratedBytes = int64(16 << 20)
|
|
)
|
|
|
|
func (s *Server) handlePrint(w http.ResponseWriter, r *http.Request) {
|
|
address := strings.TrimPrefix(r.URL.Path, "/_/view/print/")
|
|
revision, semanticPath, err := s.resolvePrintRevision(r, address)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
view, err := s.printContentViewContext(r.Context(), revision, semanticPath)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
rendered := ""
|
|
if view.Kind == "html" {
|
|
rendered = s.safeHTMLProjection(r, view.Text, semanticPath, true)
|
|
}
|
|
s.renderWithContext(w, r, "print.gohtml", map[string]any{
|
|
"Title": view.Filename,
|
|
"Path": semanticPath,
|
|
"Revision": revision,
|
|
"ContentView": view,
|
|
"RenderedHTML": template.HTML(rendered),
|
|
"Locale": s.getLocale(s.domainUUIDForRequest(r)),
|
|
})
|
|
}
|
|
|
|
func (s *Server) resolvePrintRevision(r *http.Request, address string) (*store.Revision, string, error) {
|
|
domainUUID := s.domainUUIDForRequest(r)
|
|
var objectUUID, semanticPath string
|
|
switch {
|
|
case strings.HasPrefix(address, "path:"):
|
|
semanticPath = strings.TrimPrefix(address, "path:")
|
|
var err error
|
|
objectUUID, err = s.store.ResolvePathInDomain(domainUUID, semanticPath)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
revision, err := s.latestRevisionMetadataForRequest(r, objectUUID)
|
|
return revision, semanticPath, err
|
|
case strings.HasPrefix(address, "uuid:"):
|
|
objectUUID = strings.TrimPrefix(address, "uuid:")
|
|
if !s.store.ObjectBoundInDomain(domainUUID, objectUUID) {
|
|
return nil, "", sql.ErrNoRows
|
|
}
|
|
case strings.HasPrefix(address, "rev:"):
|
|
revision, err := s.store.GetRevisionMetadata(strings.TrimPrefix(address, "rev:"))
|
|
if err != nil || !s.store.ObjectBoundInDomain(domainUUID, revision.ObjectUUID) {
|
|
if err == nil {
|
|
err = sql.ErrNoRows
|
|
}
|
|
return nil, "", err
|
|
}
|
|
semanticPath, _ = s.store.GetPathByUUIDInDomain(domainUUID, revision.ObjectUUID)
|
|
return revision, semanticPath, nil
|
|
default:
|
|
return nil, "", sql.ErrNoRows
|
|
}
|
|
semanticPath, _ = s.store.GetPathByUUIDInDomain(domainUUID, objectUUID)
|
|
revision, err := s.latestRevisionMetadataForRequest(r, objectUUID)
|
|
return revision, semanticPath, err
|
|
}
|
|
|
|
func (s *Server) printContentView(metadata *store.Revision, semanticPath string) (contentView, error) {
|
|
return s.printContentViewContext(context.Background(), metadata, semanticPath)
|
|
}
|
|
|
|
func (s *Server) printContentViewContext(ctx context.Context, metadata *store.Revision, semanticPath string) (contentView, error) {
|
|
size, err := s.store.DocumentSizeContext(ctx, metadata.DocumentHash)
|
|
if err != nil {
|
|
return contentView{}, err
|
|
}
|
|
mediaType, _, _ := mime.ParseMediaType(metadata.ContentType)
|
|
filename := strings.TrimSpace(metadata.Filename)
|
|
if filename == "" {
|
|
filename = filepath.Base(semanticPath)
|
|
}
|
|
adapter := selectProjectionAdapter(contentDescriptor{MediaType: strings.ToLower(mediaType), Filename: filename, SizeBytes: size})
|
|
rawURL := rawProjectionURL("rev:" + metadata.UUID)
|
|
view := contentView{Kind: adapter.Kind, AdapterID: adapter.ID, Delivery: adapter.Delivery, ContentType: metadata.ContentType, Filename: filename, SizeBytes: size, RawURL: rawURL, RevisionUUID: metadata.UUID, DocumentHash: metadata.DocumentHash, ObjectUUID: metadata.ObjectUUID}
|
|
if adapter.ID == "archive" && !strings.EqualFold(filepath.Ext(filename), ".zip") {
|
|
s.applyMetadataProjection(&view, semanticPath)
|
|
return view, nil
|
|
}
|
|
|
|
if !adapterNeedsPrintBody(adapter) {
|
|
if adapter.ID == "pdf" {
|
|
view.PDFPages = s.pdfPageCount(metadata.DocumentHash)
|
|
}
|
|
return view, nil
|
|
}
|
|
if adapter.WindowableText && size > maxPrintTextBytes {
|
|
window, err := s.store.ReadDocumentWindowContext(ctx, metadata.DocumentHash, 0, maxPrintTextBytes)
|
|
if err != nil {
|
|
return contentView{}, err
|
|
}
|
|
view = revisionWindowedContentView(metadata, semanticPath, size, window.Data, window.NextOffset)
|
|
view.RawURL = rawURL
|
|
return view, nil
|
|
}
|
|
if size > maxPrintHydratedBytes {
|
|
view.Kind = "download"
|
|
view.ParseError = "This structured document is too large for synchronous print projection."
|
|
return view, nil
|
|
}
|
|
revision, err := s.store.GetRevision(metadata.UUID)
|
|
if err != nil {
|
|
return contentView{}, err
|
|
}
|
|
view = revisionContentView(revision, semanticPath)
|
|
if view.Kind == "html" {
|
|
view.Text = revision.Body
|
|
}
|
|
view.RawURL = rawURL
|
|
view.RevisionUUID = metadata.UUID
|
|
return view, nil
|
|
}
|
|
|
|
func adapterNeedsPrintBody(adapter projectionAdapter) bool {
|
|
if adapter.NeedsText {
|
|
return true
|
|
}
|
|
switch adapter.ID {
|
|
case "html", "archive", "eml", "debian-package", "pe", "excalidraw":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|