538 lines
12 KiB
Go
538 lines
12 KiB
Go
package utils
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
dbtypes "git.andr3h3nriqu3s.com/andr3/fyp/logic/db_types"
|
|
. "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/utils"
|
|
"github.com/charmbracelet/log"
|
|
"github.com/goccy/go-json"
|
|
)
|
|
|
|
type AnyMap = map[string]interface{}
|
|
|
|
type Error struct {
|
|
Code int
|
|
data any
|
|
}
|
|
|
|
type HandleFunc struct {
|
|
path string
|
|
fn func(c *Context) *Error
|
|
}
|
|
|
|
type Handler interface {
|
|
New()
|
|
Startup()
|
|
Get(fn func(c *Context) *Error)
|
|
Post(fn func(c *Context) *Error)
|
|
}
|
|
|
|
type Handle struct {
|
|
Db *sql.DB
|
|
gets []HandleFunc
|
|
posts []HandleFunc
|
|
deletes []HandleFunc
|
|
}
|
|
|
|
func decodeBody(r *http.Request) (string, *Error) {
|
|
body, err := io.ReadAll(r.Body)
|
|
if err == nil {
|
|
return "", &Error{Code: http.StatusBadRequest}
|
|
}
|
|
|
|
return string(body[:]), nil
|
|
}
|
|
|
|
func handleError(err *Error, c *Context) {
|
|
if err != nil {
|
|
c.Logger.Warn("Responded with error", "code", err.Code, "data", err.data)
|
|
c.Writer.WriteHeader(err.Code)
|
|
var e *Error
|
|
if err.data != nil {
|
|
e = c.SendJSON(err.data)
|
|
} else {
|
|
e = c.SendJSON(500)
|
|
}
|
|
if e != nil {
|
|
c.Logger.Error("Something went very wront while trying to send and error message")
|
|
c.Writer.Write([]byte("505"))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (x *Handle) Get(path string, fn func(c *Context) *Error) {
|
|
x.gets = append(x.gets, HandleFunc{path, fn})
|
|
}
|
|
|
|
func (x *Handle) Post(path string, fn func(c *Context) *Error) {
|
|
x.posts = append(x.posts, HandleFunc{path, fn})
|
|
}
|
|
|
|
func (x *Handle) Delete(path string, fn func(c *Context) *Error) {
|
|
x.deletes = append(x.deletes, HandleFunc{path, fn})
|
|
}
|
|
|
|
func (x *Handle) handleGets(context *Context) {
|
|
for _, s := range x.gets {
|
|
if s.path == context.R.URL.Path {
|
|
handleError(s.fn(context), context)
|
|
return
|
|
}
|
|
}
|
|
context.ShowMessage = false
|
|
handleError(&Error{404, "Endpoint not found"}, context)
|
|
}
|
|
|
|
func (x *Handle) handlePosts(context *Context) {
|
|
for _, s := range x.posts {
|
|
if s.path == context.R.URL.Path {
|
|
handleError(s.fn(context), context)
|
|
return
|
|
}
|
|
}
|
|
context.ShowMessage = false
|
|
handleError(&Error{404, "Endpoint not found"}, context)
|
|
}
|
|
|
|
func (x *Handle) handleDeletes(context *Context) {
|
|
for _, s := range x.deletes {
|
|
if s.path == context.R.URL.Path {
|
|
handleError(s.fn(context), context)
|
|
return
|
|
}
|
|
}
|
|
context.ShowMessage = false
|
|
handleError(&Error{404, "Endpoint not found"}, context)
|
|
}
|
|
|
|
func (c *Context) CheckAuthLevel(authLevel int) bool {
|
|
if authLevel > 0 {
|
|
if c.requireAuth() {
|
|
c.Logoff()
|
|
return false
|
|
}
|
|
if c.User.UserType < authLevel {
|
|
c.NotAuth()
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
type Context struct {
|
|
Token *string
|
|
User *dbtypes.User
|
|
Logger *log.Logger
|
|
Db *sql.DB
|
|
Writer http.ResponseWriter
|
|
R *http.Request
|
|
Tx *sql.Tx
|
|
ShowMessage bool
|
|
}
|
|
|
|
func (c Context) Prepare(str string) (*sql.Stmt, error) {
|
|
if c.Tx == nil {
|
|
return c.Db.Prepare(str)
|
|
}
|
|
|
|
return c.Tx.Prepare(str)
|
|
}
|
|
|
|
var TransactionAlreadyStarted = errors.New("Transaction already started")
|
|
var TransactionNotStarted = errors.New("Transaction not started")
|
|
|
|
func (c *Context) StartTx() error {
|
|
if c.Tx != nil {
|
|
return TransactionAlreadyStarted
|
|
}
|
|
var err error = nil
|
|
c.Tx, err = c.Db.Begin()
|
|
return err
|
|
}
|
|
|
|
func (c *Context) CommitTx() error {
|
|
if c.Tx == nil {
|
|
return TransactionNotStarted
|
|
}
|
|
err := c.Tx.Commit()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.Tx = nil
|
|
return nil
|
|
}
|
|
|
|
func (c *Context) RollbackTx() error {
|
|
if c.Tx == nil {
|
|
return TransactionNotStarted
|
|
}
|
|
err := c.Tx.Rollback()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.Tx = nil
|
|
return nil
|
|
}
|
|
|
|
func (c Context) ToJSON(dat any) *Error {
|
|
|
|
decoder := json.NewDecoder(c.R.Body)
|
|
|
|
err := decoder.Decode(dat)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c Context) SendJSON(dat any) *Error {
|
|
c.Writer.Header().Add("content-type", "application/json")
|
|
text, err := json.Marshal(dat)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
if _, err = c.Writer.Write(text); err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c Context) SendJSONStatus(status int, dat any) *Error {
|
|
c.Writer.Header().Add("content-type", "application/json")
|
|
c.Writer.WriteHeader(status)
|
|
text, err := json.Marshal(dat)
|
|
if err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
if _, err = c.Writer.Write(text); err != nil {
|
|
return c.Error500(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c Context) JsonBadRequest(dat any) *Error {
|
|
c.SetReportCaller(true)
|
|
c.Logger.Warn("Request failed with a bad request", "dat", dat)
|
|
c.SetReportCaller(false)
|
|
return c.SendJSONStatus(http.StatusBadRequest, dat)
|
|
}
|
|
|
|
func (c Context) JsonErrorBadRequest(err error, dat any) *Error {
|
|
c.SetReportCaller(true)
|
|
c.Logger.Error("Error while processing request", "err", err, "dat", dat)
|
|
c.SetReportCaller(false)
|
|
return c.SendJSONStatus(http.StatusBadRequest, dat)
|
|
}
|
|
|
|
func (c *Context) GetModelFromId(id_path string) (*BaseModel, *Error) {
|
|
|
|
id, err := GetIdFromUrl(c, id_path)
|
|
if err != nil {
|
|
return nil, c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
}
|
|
|
|
model, err := GetBaseModel(c.Db, id)
|
|
if err == ModelNotFoundError {
|
|
return nil, c.SendJSONStatus(http.StatusNotFound, "Model not found")
|
|
} else if err != nil {
|
|
return nil, c.Error500(err)
|
|
}
|
|
|
|
return model, nil
|
|
}
|
|
|
|
func ModelUpdateStatus(c *Context, id string, status int) {
|
|
_, err := c.Db.Exec("update models set status=$1 where id=$2;", status, id)
|
|
if err != nil {
|
|
c.Logger.Error("Failed to update model status", "err", err)
|
|
c.Logger.Warn("TODO Maybe handle better")
|
|
}
|
|
}
|
|
|
|
func (c Context) SetReportCaller(report bool) {
|
|
if report {
|
|
c.Logger.SetCallerOffset(2)
|
|
c.Logger.SetReportCaller(true)
|
|
} else {
|
|
c.Logger.SetCallerOffset(1)
|
|
c.Logger.SetReportCaller(false)
|
|
}
|
|
}
|
|
|
|
func (c Context) ErrorCode(err error, code int, data any) *Error {
|
|
if code == 400 {
|
|
c.SetReportCaller(true)
|
|
c.Logger.Warn("When returning BadRequest(400) please use context.Error400\n")
|
|
c.SetReportCaller(false)
|
|
}
|
|
if err != nil {
|
|
c.Logger.Errorf("Something went wrong returning with: %d\n.Err:\n", code)
|
|
c.Logger.Error(err)
|
|
}
|
|
return &Error{code, data}
|
|
}
|
|
|
|
func (c Context) Error500(err error) *Error {
|
|
return c.ErrorCode(err, http.StatusInternalServerError, nil)
|
|
}
|
|
|
|
func (c *Context) requireAuth() bool {
|
|
if c.User == nil {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var LogoffError = errors.New("Invalid token!")
|
|
|
|
func (x Handle) createContext(handler *Handle, r *http.Request, w http.ResponseWriter) (*Context, error) {
|
|
|
|
var token *string
|
|
|
|
logger := log.NewWithOptions(os.Stdout, log.Options{
|
|
ReportCaller: true,
|
|
ReportTimestamp: true,
|
|
TimeFormat: time.Kitchen,
|
|
Prefix: r.URL.Path,
|
|
})
|
|
|
|
t := r.Header.Get("token")
|
|
if t != "" {
|
|
token = &t
|
|
}
|
|
|
|
// TODO check that the token is still valid
|
|
if token == nil {
|
|
return &Context{
|
|
Logger: logger,
|
|
Db: handler.Db,
|
|
Writer: w,
|
|
R: r,
|
|
ShowMessage: true,
|
|
}, nil
|
|
}
|
|
|
|
user, err := dbtypes.UserFromToken(x.Db, *token)
|
|
if err != nil {
|
|
return nil, errors.Join(err, LogoffError)
|
|
}
|
|
|
|
return &Context{token, user, logger, handler.Db, w, r, nil, true}, nil
|
|
}
|
|
|
|
func contextlessLogoff(w http.ResponseWriter) {
|
|
w.WriteHeader(http.StatusUnauthorized)
|
|
w.Write([]byte("\"Not Authorized\""))
|
|
}
|
|
|
|
func (c *Context) Logoff() { contextlessLogoff(c.Writer) }
|
|
|
|
func (c *Context) NotAuth() {
|
|
c.Writer.WriteHeader(http.StatusUnauthorized)
|
|
e := c.SendJSON("Not Authorized")
|
|
if e != nil {
|
|
c.Writer.WriteHeader(http.StatusInternalServerError)
|
|
c.Writer.Write([]byte("You can not access this resource!"))
|
|
}
|
|
}
|
|
|
|
func (x Handle) StaticFiles(pathTest string, fileType string, contentType string) {
|
|
http.HandleFunc(pathTest, func(w http.ResponseWriter, r *http.Request) {
|
|
path := r.URL.Path[len(pathTest):]
|
|
|
|
if !strings.HasSuffix(path, fileType) {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("File not found"))
|
|
return
|
|
}
|
|
|
|
t, err := template.ParseFiles("./views" + pathTest + path)
|
|
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("Failed to load template"))
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", contentType+"; charset=utf-8")
|
|
t.Execute(w, nil)
|
|
})
|
|
}
|
|
|
|
func (x Handle) ReadFiles(pathTest string, baseFilePath string, fileType string, contentType string) {
|
|
http.HandleFunc(pathTest, func(w http.ResponseWriter, r *http.Request) {
|
|
user_path := r.URL.Path[len(pathTest):]
|
|
|
|
// fmt.Printf("Requested path: %s\n", user_path)
|
|
|
|
if !strings.HasSuffix(user_path, fileType) {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("File not found"))
|
|
return
|
|
}
|
|
|
|
bytes, err := os.ReadFile(path.Join(baseFilePath, pathTest, user_path))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("Failed to load file"))
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", contentType)
|
|
w.Write(bytes)
|
|
})
|
|
}
|
|
|
|
// TODO remove this
|
|
func (x Handle) ReadTypesFiles(pathTest string, baseFilePath string, fileTypes []string, contentTypes []string) {
|
|
http.HandleFunc(pathTest, func(w http.ResponseWriter, r *http.Request) {
|
|
user_path := r.URL.Path[len(pathTest):]
|
|
|
|
// fmt.Printf("Requested path: %s\n", user_path)
|
|
|
|
found := false
|
|
index := -1
|
|
|
|
for i, fileType := range fileTypes {
|
|
if strings.HasSuffix(user_path, fileType) {
|
|
found = true
|
|
index = i
|
|
break
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("File not found"))
|
|
return
|
|
}
|
|
|
|
bytes, err := os.ReadFile(path.Join(baseFilePath, pathTest, user_path))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("Failed to load file"))
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", contentTypes[index])
|
|
w.Write(bytes)
|
|
})
|
|
}
|
|
|
|
func (x Handle) ReadTypesFilesApi(pathTest string, baseFilePath string, fileTypes []string, contentTypes []string) {
|
|
http.HandleFunc("/api"+pathTest, func(w http.ResponseWriter, r *http.Request) {
|
|
r.URL.Path = strings.Replace(r.URL.Path, "/api", "", 1)
|
|
|
|
user_path := r.URL.Path[len(pathTest):]
|
|
|
|
found := false
|
|
index := -1
|
|
|
|
for i, fileType := range fileTypes {
|
|
if strings.HasSuffix(user_path, fileType) {
|
|
found = true
|
|
index = i
|
|
break
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("File not found"))
|
|
return
|
|
}
|
|
|
|
bytes, err := os.ReadFile(path.Join(baseFilePath, pathTest, user_path))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("Failed to load file"))
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", contentTypes[index])
|
|
w.Write(bytes)
|
|
})
|
|
}
|
|
|
|
func NewHandler(db *sql.DB) *Handle {
|
|
|
|
var gets []HandleFunc
|
|
var posts []HandleFunc
|
|
var deletes []HandleFunc
|
|
x := &Handle{db, gets, posts, deletes}
|
|
|
|
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Add("Access-Control-Allow-Origin", "*")
|
|
w.Header().Add("Access-Control-Allow-Headers", "*")
|
|
w.Header().Add("Access-Control-Allow-Methods", "*")
|
|
|
|
// Decide answertype
|
|
if !(r.Header.Get("content-type") == "application/json" || r.Header.Get("response-type") == "application/json") {
|
|
w.WriteHeader(500)
|
|
w.Write([]byte("Please set content-type to application/json or set response-type to application/json\n"))
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(r.URL.Path, "/api") {
|
|
w.WriteHeader(404)
|
|
w.Write([]byte("Path not found"))
|
|
return
|
|
}
|
|
|
|
r.URL.Path = strings.Replace(r.URL.Path, "/api", "", 1)
|
|
|
|
//Login state
|
|
context, err := x.createContext(x, r, w)
|
|
if err != nil {
|
|
contextlessLogoff(w)
|
|
return
|
|
}
|
|
|
|
// context.Logger.Info("Parsing", "path", r.URL.Path)
|
|
|
|
if r.Method == "GET" {
|
|
x.handleGets(context)
|
|
} else if r.Method == "POST" {
|
|
x.handlePosts(context)
|
|
} else if r.Method == "DELETE" {
|
|
x.handleDeletes(context)
|
|
} else if r.Method == "OPTIONS" {
|
|
// do nothing
|
|
} else {
|
|
panic("TODO handle method: " + r.Method)
|
|
}
|
|
|
|
if context.ShowMessage {
|
|
context.Logger.Info("Processed", "method", r.Method, "url", r.URL.Path)
|
|
}
|
|
})
|
|
|
|
return x
|
|
}
|
|
|
|
func (x Handle) Startup() {
|
|
log.Info("Starting up!\n")
|
|
|
|
port := os.Getenv("PORT")
|
|
if port == "" {
|
|
port = "8000"
|
|
}
|
|
|
|
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
|
|
}
|