144 lines
3.3 KiB
Go
144 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io/fs"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.yetaga.in/alazyreader/library/config"
|
|
"git.yetaga.in/alazyreader/library/database"
|
|
"git.yetaga.in/alazyreader/library/frontend"
|
|
"git.yetaga.in/alazyreader/library/media"
|
|
"github.com/kelseyhightower/envconfig"
|
|
)
|
|
|
|
func max(a, b int) int {
|
|
if a > b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func obscureStr(in string, l int) string {
|
|
return in[0:max(l, len(in))] + strings.Repeat("*", max(0, len(in)-l))
|
|
}
|
|
|
|
type Library interface {
|
|
GetAllBooks(context.Context) ([]media.Book, error)
|
|
}
|
|
|
|
type RecordCollection interface {
|
|
GetAllRecords(context.Context) ([]media.Record, error)
|
|
}
|
|
|
|
type Router struct {
|
|
static fs.FS
|
|
lib Library
|
|
rcol RecordCollection
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, b []byte, status int) {
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(status)
|
|
w.Write(b)
|
|
w.Write([]byte("\n"))
|
|
}
|
|
|
|
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
|
if req.URL.Path == "/api/records" {
|
|
RecordsAPIHandler(r.rcol).ServeHTTP(w, req)
|
|
return
|
|
}
|
|
if req.URL.Path == "/api/books" {
|
|
BooksAPIHandler(r.lib).ServeHTTP(w, req)
|
|
return
|
|
}
|
|
StaticHandler(r.static).ServeHTTP(w, req)
|
|
}
|
|
|
|
func BooksAPIHandler(l Library) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
books, err := l.GetAllBooks(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
b, err := json.Marshal(books)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
|
|
}
|
|
writeJSON(w, b, http.StatusOK)
|
|
})
|
|
}
|
|
|
|
func RecordsAPIHandler(l RecordCollection) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
books, err := l.GetAllRecords(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
b, err := json.Marshal(books)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, b, http.StatusOK)
|
|
})
|
|
}
|
|
|
|
func StaticHandler(f fs.FS) http.Handler {
|
|
return http.FileServer(http.FS(f))
|
|
}
|
|
|
|
func main() {
|
|
var c config.Config
|
|
err := envconfig.Process("library", &c)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
f, err := frontend.Root()
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
if c.DBUser == "" || c.DBPass == "" || c.DBHost == "" || c.DBPort == "" || c.DBName == "" {
|
|
if c.DBPass != "" {
|
|
c.DBPass = obscureStr(c.DBPass, 3)
|
|
}
|
|
if c.DiscogsToken != "" {
|
|
c.DiscogsToken = obscureStr(c.DiscogsToken, 3)
|
|
}
|
|
log.Fatalf("vars: %+v", c)
|
|
}
|
|
lib, err := database.NewMySQLConnection(c.DBUser, c.DBPass, c.DBHost, c.DBPort, c.DBName)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
err = lib.PrepareDatabase(context.Background())
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
latest, run, err := lib.RunMigrations(context.Background())
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
log.Printf("latest migration: %d; migrations run: %d", latest, run)
|
|
discogsCache, err := database.NewDiscogsCache(c.DiscogsToken, time.Hour*24, c.DiscogsUser, c.DiscogsPersist, c.DiscogsCacheFile)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
r := &Router{
|
|
static: f,
|
|
lib: lib,
|
|
rcol: discogsCache,
|
|
}
|
|
log.Println("Listening on http://0.0.0.0:8080/")
|
|
log.Fatalln(http.ListenAndServe(":8080", r))
|
|
}
|