dorfylegends/backend/server/server.go

274 lines
7.7 KiB
Go
Raw Normal View History

2022-04-26 10:24:16 +03:00
package server
import (
"embed"
2022-04-26 22:00:09 +03:00
"encoding/json"
2022-04-26 10:24:16 +03:00
"fmt"
"io/fs"
2022-04-26 18:39:24 +03:00
"io/ioutil"
2022-04-26 10:24:16 +03:00
"net/http"
"os"
2022-04-27 22:44:39 +03:00
"path/filepath"
"runtime"
2022-04-28 21:14:33 +03:00
"sort"
2022-04-26 18:39:24 +03:00
"strings"
2022-04-26 10:24:16 +03:00
"github.com/gorilla/mux"
"github.com/robertjanetzko/LegendsBrowser2/backend/model"
"github.com/robertjanetzko/LegendsBrowser2/backend/templates"
2022-04-27 22:44:39 +03:00
"github.com/robertjanetzko/LegendsBrowser2/backend/util"
"github.com/shirou/gopsutil/disk"
2022-04-26 10:24:16 +03:00
)
2022-04-26 18:39:24 +03:00
type DfServerContext struct {
world *model.DfWorld
isLoading bool
2022-04-26 22:00:09 +03:00
progress *model.LoadProgress
2022-04-26 18:39:24 +03:00
}
2022-04-26 10:24:16 +03:00
type DfServer struct {
router *mux.Router
2022-04-26 22:00:09 +03:00
loader *loadHandler
2022-04-26 10:24:16 +03:00
templates *templates.Template
2022-04-26 18:39:24 +03:00
context *DfServerContext
2022-04-26 10:24:16 +03:00
}
func StartServer(world *model.DfWorld, static embed.FS) {
srv := &DfServer{
router: mux.NewRouter().StrictSlash(true),
2022-04-26 18:39:24 +03:00
context: &DfServerContext{
world: world,
isLoading: false,
2022-04-26 22:00:09 +03:00
progress: &model.LoadProgress{},
2022-04-26 18:39:24 +03:00
},
2022-04-26 10:24:16 +03:00
}
2022-04-26 22:00:09 +03:00
srv.loader = &loadHandler{server: srv}
2022-04-26 10:24:16 +03:00
srv.LoadTemplates()
2022-04-27 22:44:39 +03:00
srv.RegisterWorldPage("/entities", "entities.html", func(p Parms) any { return grouped(srv.context.world.Entities) })
2022-04-26 18:39:24 +03:00
srv.RegisterWorldResourcePage("/entity/{id}", "entity.html", func(id int) any { return srv.context.world.Entities[id] })
2022-04-27 22:44:39 +03:00
2022-04-28 22:24:55 +03:00
srv.RegisterWorldPage("/regions", "regions.html", func(p Parms) any { return grouped(srv.context.world.Regions) })
2022-04-26 18:39:24 +03:00
srv.RegisterWorldResourcePage("/region/{id}", "region.html", func(id int) any { return srv.context.world.Regions[id] })
2022-04-28 22:24:55 +03:00
srv.RegisterWorldPage("/sites", "sites.html", func(p Parms) any { return grouped(srv.context.world.Sites) })
2022-04-26 18:39:24 +03:00
srv.RegisterWorldResourcePage("/site/{id}", "site.html", func(id int) any { return srv.context.world.Sites[id] })
2022-04-28 22:24:55 +03:00
srv.RegisterWorldPage("/worldconstructions", "worldconstructions.html", func(p Parms) any { return grouped(srv.context.world.WorldConstructions) })
srv.RegisterWorldResourcePage("/worldconstruction/{id}", "worldconstruction.html", func(id int) any { return srv.context.world.WorldConstructions[id] })
srv.RegisterWorldPage("/artifacts", "artifacts.html", func(p Parms) any { return grouped(srv.context.world.Artifacts) })
2022-04-26 18:39:24 +03:00
srv.RegisterWorldResourcePage("/artifact/{id}", "artifact.html", func(id int) any { return srv.context.world.Artifacts[id] })
2022-04-28 22:24:55 +03:00
srv.RegisterWorldPage("/artforms", "artforms.html", func(p Parms) any {
return struct {
DanceForms map[string][]*model.DanceForm
MusicalForms map[string][]*model.MusicalForm
PoeticForms map[string][]*model.PoeticForm
}{
DanceForms: grouped(srv.context.world.DanceForms),
MusicalForms: grouped(srv.context.world.MusicalForms),
PoeticForms: grouped(srv.context.world.PoeticForms),
}
})
srv.RegisterWorldPage("/writtencontents", "writtencontents.html", func(p Parms) any { return grouped(srv.context.world.WrittenContents) })
srv.RegisterWorldResourcePage("/writtencontent/{id}", "writtencontent.html", func(id int) any { return srv.context.world.WrittenContents[id] })
srv.RegisterWorldResourcePage("/hf/{id}", "hf.html", func(id int) any { return srv.context.world.HistoricalFigures[id] })
2022-04-26 18:39:24 +03:00
srv.RegisterWorldPage("/", "eventTypes.html", func(p Parms) any { return srv.context.world.AllEventTypes() })
srv.RegisterWorldPage("/events", "eventTypes.html", func(p Parms) any { return srv.context.world.AllEventTypes() })
srv.RegisterWorldPage("/events/{type}", "eventType.html", func(p Parms) any { return srv.context.world.EventsOfType(p["type"]) })
2022-04-26 22:00:09 +03:00
srv.router.PathPrefix("/load").Handler(srv.loader)
2022-04-26 10:24:16 +03:00
spa := spaHandler{staticFS: static, staticPath: "static", indexPath: "index.html"}
srv.router.PathPrefix("/").Handler(spa)
OpenBrowser("http://localhost:8080")
fmt.Println("Serving at :8080")
http.ListenAndServe(":8080", srv.router)
}
type spaHandler struct {
staticFS embed.FS
staticPath string
indexPath string
}
func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// get the absolute path to prevent directory traversal
path := r.URL.Path
// if err != nil {
// // if we failed to get the absolute path respond with a 400 bad request and stop
// http.Error(w, err.Error(), http.StatusBadRequest)
// return
// }
// prepend the path with the path to the static directory
path = h.staticPath + path
_, err := h.staticFS.Open(path)
if os.IsNotExist(err) {
// file does not exist, serve index.html
fmt.Println(path)
index, err := h.staticFS.ReadFile(h.staticPath + "/" + h.indexPath)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(http.StatusAccepted)
w.Write(index)
return
} else if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// get the subdirectory of the static dir
statics, err := fs.Sub(h.staticFS, h.staticPath)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// otherwise, use http.FileServer to serve the static dir
http.FileServer(http.FS(statics)).ServeHTTP(w, r)
}
2022-04-26 18:39:24 +03:00
type loadHandler struct {
server *DfServer
}
2022-04-26 22:00:09 +03:00
type loadProgress struct {
Msg string `json:"msg"`
Progress float64 `json:"progress"`
Done bool `json:"done"`
}
func (h loadHandler) Progress() *loadProgress {
percent := 0.0
p := h.server.context.progress
if p.ProgressBar != nil {
percent = float64(p.ProgressBar.Current()*100) / float64(p.ProgressBar.Total())
}
return &loadProgress{
Msg: h.server.context.progress.Message,
Progress: percent,
Done: h.server.context.world != nil,
}
}
2022-04-26 18:39:24 +03:00
func (h loadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2022-04-26 22:00:09 +03:00
if r.URL.Path == "/load/progress" {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(h.Progress())
return
}
2022-04-27 22:44:39 +03:00
var partitions []string
if runtime.GOOS == "windows" {
ps, _ := disk.Partitions(false)
partitions = util.Map(ps, func(p disk.PartitionStat) string { return p.Mountpoint + `\` })
} else {
partitions = append(partitions, "/")
}
2022-04-26 18:39:24 +03:00
path := r.URL.Query().Get("p")
p := &paths{
2022-04-27 22:44:39 +03:00
Partitions: partitions,
Current: path,
2022-04-26 18:39:24 +03:00
}
if p.Current == "" {
p.Current = "."
}
2022-04-27 22:44:39 +03:00
var err error
p.Current, err = filepath.Abs(p.Current)
if err != nil {
httpError(w, err)
return
}
2022-04-26 18:39:24 +03:00
if f, err := os.Stat(p.Current); err == nil {
if f.IsDir() {
p.List, err = ioutil.ReadDir(p.Current)
if err != nil {
2022-04-27 22:44:39 +03:00
httpError(w, err)
return
2022-04-26 18:39:24 +03:00
}
2022-04-26 21:06:21 +03:00
err = h.server.templates.Render(w, "load.html", p)
2022-04-26 18:39:24 +03:00
if err != nil {
2022-04-27 22:44:39 +03:00
httpError(w, err)
2022-04-26 18:39:24 +03:00
}
return
} else {
h.server.context.isLoading = true
2022-04-27 22:44:39 +03:00
h.server.context.world = nil
2022-04-26 22:00:09 +03:00
go loadWorld(h.server, p.Current)
2022-04-26 18:39:24 +03:00
http.Redirect(w, r, "/", http.StatusSeeOther)
return
}
}
http.Redirect(w, r, "/load", http.StatusSeeOther)
}
func isLegendsXml(f fs.FileInfo) bool {
return strings.HasSuffix(f.Name(), "-legends.xml")
}
2022-04-26 22:00:09 +03:00
func loadWorld(server *DfServer, file string) {
2022-04-27 22:44:39 +03:00
runtime.GC()
2022-04-26 22:00:09 +03:00
wrld, _ := model.Parse(file, server.context.progress)
server.context.world = wrld
server.context.isLoading = false
}
type paths struct {
2022-04-27 22:44:39 +03:00
Current string
List []fs.FileInfo
Partitions []string
2022-04-26 22:00:09 +03:00
}
func (srv *DfServer) renderLoading(w http.ResponseWriter, r *http.Request) {
if srv.context.isLoading {
err := srv.templates.Render(w, "loading.html", srv.loader.Progress())
if err != nil {
2022-04-27 22:44:39 +03:00
httpError(w, err)
2022-04-26 22:00:09 +03:00
}
} else {
http.Redirect(w, r, "/load", http.StatusSeeOther)
}
}
2022-04-27 22:44:39 +03:00
func httpError(w http.ResponseWriter, err error) {
fmt.Fprintln(w, err)
fmt.Println(err)
}
2022-04-28 21:14:33 +03:00
type namedTyped interface {
model.Named
model.Typed
}
func grouped[T namedTyped](input map[int]T) map[string][]T {
2022-04-27 22:44:39 +03:00
output := make(map[string][]T)
for _, v := range input {
k := v.Type()
output[k] = append(output[k], v)
}
2022-04-28 21:14:33 +03:00
for _, v := range output {
sort.Slice(v, func(i, j int) bool { return v[i].Name() < v[j].Name() })
}
2022-04-27 22:44:39 +03:00
return output
}