2022-12-22 04:45:15 +00:00
|
|
|
package admin
|
|
|
|
|
|
|
|
import (
|
2023-01-31 04:38:30 +00:00
|
|
|
"encoding/json"
|
2023-02-10 05:45:09 +00:00
|
|
|
_ "fmt"
|
2023-01-31 04:38:30 +00:00
|
|
|
"hacklab.nilfm.cc/felt/admin/util"
|
|
|
|
"hacklab.nilfm.cc/felt/models"
|
|
|
|
"hacklab.nilfm.cc/felt/mongodb"
|
|
|
|
"hacklab.nilfm.cc/quartzgun/auth"
|
|
|
|
. "hacklab.nilfm.cc/quartzgun/middleware"
|
|
|
|
"hacklab.nilfm.cc/quartzgun/renderer"
|
|
|
|
"hacklab.nilfm.cc/quartzgun/router"
|
|
|
|
. "hacklab.nilfm.cc/quartzgun/util"
|
2023-02-10 05:45:09 +00:00
|
|
|
"html/template"
|
|
|
|
"net/http"
|
2022-12-22 04:45:15 +00:00
|
|
|
)
|
|
|
|
|
2022-12-22 16:39:39 +00:00
|
|
|
func apiGetTableList(next http.Handler, udb auth.UserStore) http.Handler {
|
2022-12-22 04:45:15 +00:00
|
|
|
handlerFunc := func(w http.ResponseWriter, req *http.Request) {
|
|
|
|
|
2022-12-25 04:02:35 +00:00
|
|
|
user := util.GetUserFromToken(req)
|
|
|
|
self, err := util.GetTablesByUser(user, udb)
|
2022-12-22 04:45:15 +00:00
|
|
|
if err != nil {
|
2022-12-25 04:02:35 +00:00
|
|
|
w.WriteHeader(404)
|
|
|
|
} else {
|
|
|
|
AddContextValue(req, "tableList", self)
|
2022-12-22 04:45:15 +00:00
|
|
|
}
|
2022-12-25 04:02:35 +00:00
|
|
|
next.ServeHTTP(w, req)
|
|
|
|
}
|
2022-12-22 04:45:15 +00:00
|
|
|
|
2022-12-25 04:02:35 +00:00
|
|
|
return http.HandlerFunc(handlerFunc)
|
|
|
|
}
|
|
|
|
|
|
|
|
func apiGetTableData(next http.Handler, udb auth.UserStore, dbAdapter mongodb.DbAdapter) http.Handler {
|
|
|
|
handlerFunc := func(w http.ResponseWriter, req *http.Request) {
|
|
|
|
|
2023-02-10 05:45:09 +00:00
|
|
|
urlParams := req.Context().Value("params").(map[string]string)
|
|
|
|
tableName := urlParams["Slug"]
|
2022-12-25 04:02:35 +00:00
|
|
|
tableKey := models.TableKey{
|
2023-02-10 05:45:09 +00:00
|
|
|
Name: tableName,
|
|
|
|
Passcode: req.FormValue("passcode"),
|
2022-12-25 04:02:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if dbAdapter.CheckTable(tableKey) {
|
|
|
|
mapUrl, _ := dbAdapter.GetMapImageUrl(tableKey)
|
|
|
|
auxMessage, _ := dbAdapter.GetAuxMessage(tableKey)
|
|
|
|
availableTokens, _ := dbAdapter.GetTokens(tableKey, true)
|
|
|
|
activeTokens, _ := dbAdapter.GetTokens(tableKey, false)
|
2023-02-10 05:45:09 +00:00
|
|
|
diceRolls, _ := dbAdapter.GetDiceRolls(tableKey)
|
2022-12-25 04:02:35 +00:00
|
|
|
|
|
|
|
AddContextValue(req, "tableData", models.Table{
|
2023-02-10 05:45:09 +00:00
|
|
|
Name: tableKey.Name,
|
|
|
|
Passcode: tableKey.Passcode,
|
|
|
|
DiceRolls: diceRolls,
|
2022-12-25 04:02:35 +00:00
|
|
|
MapImageUrl: mapUrl,
|
|
|
|
Tokens: activeTokens,
|
|
|
|
AvailableTokens: availableTokens,
|
|
|
|
AuxMessage: auxMessage,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
w.WriteHeader(404)
|
2022-12-22 04:45:15 +00:00
|
|
|
}
|
|
|
|
|
2022-12-22 16:39:39 +00:00
|
|
|
next.ServeHTTP(w, req)
|
2022-12-22 04:45:15 +00:00
|
|
|
}
|
|
|
|
|
2022-12-22 16:39:39 +00:00
|
|
|
return http.HandlerFunc(handlerFunc)
|
|
|
|
}
|
|
|
|
|
2022-12-25 04:02:35 +00:00
|
|
|
func apiCreateTable(next http.Handler, udb auth.UserStore, dbAdapter mongodb.DbAdapter) http.Handler {
|
|
|
|
handlerFunc := func(w http.ResponseWriter, req *http.Request) {
|
2023-01-31 04:38:30 +00:00
|
|
|
tableKey := models.TableKey{}
|
|
|
|
err := json.NewDecoder(req.Body).Decode(&tableKey)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
next.ServeHTTP(w, req)
|
|
|
|
return
|
|
|
|
}
|
2022-12-25 04:02:35 +00:00
|
|
|
|
|
|
|
// table name is primary key so w edon't need to check
|
2023-01-28 07:28:15 +00:00
|
|
|
err = dbAdapter.CreateTable(tableKey)
|
2022-12-25 04:02:35 +00:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
AddContextValue(req, "result", err.Error())
|
|
|
|
// TODO: parse error and change the status
|
|
|
|
w.WriteHeader(500)
|
|
|
|
} else {
|
|
|
|
user := util.GetUserFromToken(req)
|
|
|
|
tables, err := util.GetTablesByUser(user, udb)
|
|
|
|
tables = append(tables, tableKey)
|
|
|
|
err = util.SetTablesForUser(user, tables, udb)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(500)
|
|
|
|
} else {
|
|
|
|
w.WriteHeader(201)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
next.ServeHTTP(w, req)
|
|
|
|
}
|
|
|
|
|
|
|
|
return http.HandlerFunc(handlerFunc)
|
|
|
|
}
|
|
|
|
|
|
|
|
func apiDestroyTable(next http.Handler, udb auth.UserStore, dbAdapter mongodb.DbAdapter) http.Handler {
|
|
|
|
handlerFunc := func(w http.ResponseWriter, req *http.Request) {
|
|
|
|
// check table actually belongs to this user
|
2023-01-05 04:59:54 +00:00
|
|
|
user := util.GetUserFromToken(req)
|
|
|
|
tables, err := util.GetTablesByUser(user, udb)
|
|
|
|
|
|
|
|
if err == nil {
|
|
|
|
|
|
|
|
destroy := false
|
|
|
|
i := 0
|
2023-01-31 04:38:30 +00:00
|
|
|
|
2023-02-26 05:43:38 +00:00
|
|
|
table := models.TableKey{}
|
|
|
|
err = json.NewDecoder(req.Body).Decode(&table)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
2023-01-05 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for j, t := range tables {
|
|
|
|
if t.Name == table.Name && t.Passcode == table.Passcode {
|
2023-01-31 04:38:30 +00:00
|
|
|
|
|
|
|
// try to destroy it
|
|
|
|
destroy = dbAdapter.DestroyTable(table) == nil
|
|
|
|
i = j
|
|
|
|
break
|
|
|
|
}
|
2023-01-05 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if destroy {
|
|
|
|
newTables := append(tables[:i], tables[i+1:]...)
|
|
|
|
util.SetTablesForUser(user, newTables, udb)
|
|
|
|
w.WriteHeader(204)
|
|
|
|
} else {
|
|
|
|
w.WriteHeader(404)
|
|
|
|
}
|
2023-01-31 04:38:30 +00:00
|
|
|
|
2023-01-05 04:59:54 +00:00
|
|
|
} else {
|
|
|
|
w.WriteHeader(500)
|
|
|
|
}
|
|
|
|
next.ServeHTTP(w, req)
|
2022-12-25 04:02:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return http.HandlerFunc(handlerFunc)
|
2022-12-22 04:45:15 +00:00
|
|
|
}
|
|
|
|
|
2023-02-26 05:43:38 +00:00
|
|
|
func apiUploadMapImg(next http.Handler, udb auth.UserStore, dbAdapter mongodb.DbAdapter) http.Handler {
|
|
|
|
handlerFunc := func(w http.ResponseWriter, req *http.Request) {
|
|
|
|
// ensure data storage dir exists
|
|
|
|
// check for filename; call create to overwrite regardless
|
|
|
|
// get file data from multipart form
|
|
|
|
// write to file
|
|
|
|
// respond with URL?
|
|
|
|
}
|
|
|
|
|
2023-02-26 21:22:18 +00:00
|
|
|
return http.HandlerFunc(handlerFunc)
|
2023-02-26 05:43:38 +00:00
|
|
|
}
|
|
|
|
|
2023-02-26 21:22:18 +00:00
|
|
|
func CreateAdminInterface(udb auth.UserStore, dbAdapter mongodb.DbAdapter, uploads string, uploadMaxMB int) http.Handler {
|
2022-12-22 04:45:15 +00:00
|
|
|
// create quartzgun router
|
2023-01-31 04:38:30 +00:00
|
|
|
rtr := &router.Router{Fallback: *template.Must(template.ParseFiles("static/error.html"))}
|
2022-12-25 04:02:35 +00:00
|
|
|
|
2022-12-22 16:39:39 +00:00
|
|
|
scopes := map[string]string{}
|
2022-12-22 04:45:15 +00:00
|
|
|
|
2022-12-25 04:02:35 +00:00
|
|
|
rtr.Post("/api/auth/", Provision(udb, 84))
|
2023-02-26 21:22:18 +00:00
|
|
|
|
|
|
|
// table management
|
2022-12-25 04:02:35 +00:00
|
|
|
rtr.Get("/api/table/", Validate(apiGetTableList(renderer.JSON("tableList"), udb), udb, scopes))
|
|
|
|
rtr.Get(`/api/table/(?P<Slug>\S+)`, Validate(apiGetTableData(renderer.JSON("tableData"), udb, dbAdapter), udb, scopes))
|
|
|
|
rtr.Post("/api/table/", Validate(apiCreateTable(renderer.JSON("result"), udb, dbAdapter), udb, scopes))
|
2023-01-05 04:59:54 +00:00
|
|
|
rtr.Delete(`/api/table/(?P<Slug>\S+)`, Validate(apiDestroyTable(renderer.JSON("result"), udb, dbAdapter), udb, scopes))
|
2022-12-22 04:45:15 +00:00
|
|
|
|
2023-02-26 21:22:18 +00:00
|
|
|
// asset management
|
|
|
|
// POST /api/upload/<table>/map/
|
|
|
|
// DELETE /api/upload/<table>/map/<map>
|
|
|
|
// POST /api/upload/<table>/token/
|
|
|
|
// DELETE /api/upload/<table>/token/<token>
|
|
|
|
|
2022-12-22 16:39:39 +00:00
|
|
|
return http.HandlerFunc(rtr.ServeHTTP)
|
2022-12-22 04:45:15 +00:00
|
|
|
}
|