package server import ( "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.printContentView(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) { size, err := s.store.DocumentSize(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.ReadDocumentWindow(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 } }