83 lines
2.6 KiB
Go
83 lines
2.6 KiB
Go
package web
|
|
|
|
import (
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/nmoniz/any2anexoj/internal/ofigi"
|
|
)
|
|
|
|
// Server wires the HTTP handlers, embedded static assets, and shared state
|
|
// behind a single http.Handler. Use NewServer to construct one.
|
|
type Server struct {
|
|
state *State
|
|
router *http.ServeMux
|
|
staticFS fs.FS
|
|
indexHTML []byte
|
|
figiClient *ofigi.Client
|
|
}
|
|
|
|
// Option mutates a Server during construction. Use WithFigiClient (mainly in
|
|
// tests) to inject a custom OpenFIGI client so tests can run offline against
|
|
// a stub while production uses a real network client.
|
|
type Option func(*Server)
|
|
|
|
// WithFigiClient overrides the OpenFIGI client used by the report pipeline.
|
|
// Production should leave this unset so NewServer constructs a real client
|
|
// (no API key, 5 s timeout) that gracefully falls back to NatureUnknown
|
|
// when OpenFIGI calls fail. Tests pass a stub backed by an httptest-style
|
|
// transport to keep the test suite offline and deterministic.
|
|
func WithFigiClient(c *ofigi.Client) Option {
|
|
return func(s *Server) {
|
|
s.figiClient = c
|
|
}
|
|
}
|
|
|
|
// NewServer constructs a Server with all routes registered. The staticFS is
|
|
// the embedded subtree rooted at the directory that should be served under
|
|
// /static/* (i.e. it must contain an "index.html" file). The returned
|
|
// Server's Handler() method exposes the configured http.Handler.
|
|
func NewServer(state *State, staticFS fs.FS, opts ...Option) (*Server, error) {
|
|
indexBytes, err := fs.ReadFile(staticFS, "index.html")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("web: missing index.html in static FS: %w", err)
|
|
}
|
|
|
|
s := &Server{
|
|
state: state,
|
|
router: http.NewServeMux(),
|
|
staticFS: staticFS,
|
|
indexHTML: indexBytes,
|
|
figiClient: ofigi.NewOpenFIGI(&http.Client{Timeout: 5 * time.Second}, ""),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(s)
|
|
}
|
|
s.routes()
|
|
return s, nil
|
|
}
|
|
|
|
// Handler returns the configured HTTP handler, wrapped in the auth middleware
|
|
// stub so future auth wiring only has to change auth.go.
|
|
func (s *Server) Handler() http.Handler {
|
|
return AuthMiddleware(s.router)
|
|
}
|
|
|
|
// routes registers the HTTP routes handled by this server.
|
|
func (s *Server) routes() {
|
|
// API routes.
|
|
s.router.HandleFunc("POST /api/upload", s.handleUpload)
|
|
s.router.HandleFunc("GET /api/table", s.handleGetTable)
|
|
|
|
// Serve the embedded static assets under /static/*.
|
|
s.router.Handle("GET /static/", http.StripPrefix("/static/", http.FileServer(http.FS(s.staticFS))))
|
|
|
|
// Serve the embedded index page at "/".
|
|
s.router.HandleFunc("GET /{$}", func(w http.ResponseWriter, _ *http.Request) {
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
_, _ = w.Write(s.indexHTML)
|
|
})
|
|
}
|