path: root/server/cmd/main.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"regexp"
	"slices"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"github.com/jackc/pgx/v5/pgxpool"

	"git.huntm.net/wedding/server/guest"
)

type guestHandler struct {
	store guestStore
}

type guestStore interface {
	FindGuest(credentials guest.Credentials) (guest.Guest, error)
	Get() ([]guest.Guest, error)
	Add(guest guest.Guest) error
	Update(guest guest.Guest) error
}

var (
	user     = os.Getenv("USER")
	pass     = os.Getenv("PASS")
	host     = "localhost"
	port     = "5432"
	database = "postgres"

	guestRe   = regexp.MustCompile(`^/guest/*$`)
	guestIdRe = regexp.MustCompile(`^/guest/([0-9]+)$`)
)

func main() {
	db, err := pgxpool.New(context.Background(), fmt.Sprintf("postgres://%s:%s@%s:%s/%s", user, pass, host, port, database))
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	store := guest.NewMemStore(db)
	guestHandler := createGuestHandler(store)

	mux := http.NewServeMux()
	mux.Handle("/guest/", guestHandler)
	log.Fatal(http.ListenAndServe(":8080", enableCors(mux)))
}

func createGuestHandler(s guestStore) *guestHandler {
	return &guestHandler{
		store: s,
	}
}

func enableCors(next http.Handler) http.Handler {
	allowedOrigins := []string{"http://localhost:5173", "http://192.168.1.41:5173"}
	allowedMethods := []string{"OPTIONS", "POST", "PUT"}
	return serveHttp(next, allowedOrigins, allowedMethods)
}

func serveHttp(next http.Handler, allowedOrigins []string, allowedMethods []string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		method := r.Header.Get("Access-Control-Request-Method")
		if isPreflight(r) && slices.Contains(allowedMethods, method) {
			w.Header().Add("Access-Control-Allow-Methods", method)
		}

		origin := r.Header.Get("Origin")
		if slices.Contains(allowedOrigins, origin) {
			w.Header().Add("Access-Control-Allow-Origin", origin)
		}

		w.Header().Add("Access-Control-Allow-Headers", "*")
		next.ServeHTTP(w, r)
	})
}

func isPreflight(r *http.Request) bool {
	return r.Method == "OPTIONS" &&
		r.Header.Get("Origin") != "" &&
		r.Header.Get("Access-Control-Request-Method") != ""
}

func (guestHandler *guestHandler) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
	switch {
	case request.Method == http.MethodOptions:
		responseWriter.WriteHeader(http.StatusOK)
	case request.Method == http.MethodPost && request.URL.Path == "/guest/login":
		guestHandler.login(responseWriter, request)
	case request.Method == http.MethodPut && guestIdRe.MatchString(request.URL.Path):
		guestHandler.putGuest(responseWriter, request)
	case request.Method == http.MethodGet && guestRe.MatchString(request.URL.Path):
		guestHandler.getGuests(responseWriter)
	case request.Method == http.MethodPost && guestRe.MatchString(request.URL.Path):
		guestHandler.postGuest(responseWriter, request)
	default:
		responseWriter.WriteHeader(http.StatusNotFound)
	}
}

func (guestHandler *guestHandler) login(responseWriter http.ResponseWriter, request *http.Request) {
	credentials := guestHandler.decodeCredentials(responseWriter, request)
	guest := guestHandler.findGuest(responseWriter, credentials)
	expirationTime := guestHandler.setExpirationTime()
	claims := guestHandler.createClaims(credentials, expirationTime)
	key := guestHandler.readKey(responseWriter)
	token := guestHandler.createToken(responseWriter, claims, key)
	jsonBytes := guestHandler.marshalResponse(responseWriter, guest, token)
	responseWriter.Write(jsonBytes)
}

func (guestHandler *guestHandler) decodeCredentials(responseWriter http.ResponseWriter, request *http.Request) guest.Credentials {
	var credentials guest.Credentials
	err := json.NewDecoder(request.Body).Decode(&credentials)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Failed to unmarshal credentials")
	}
	defer request.Body.Close()
	return credentials
}

func (guestHandler *guestHandler) findGuest(responseWriter http.ResponseWriter, credentials guest.Credentials) guest.Guest {
	guest, err := guestHandler.store.FindGuest(credentials)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusUnauthorized)
		log.Panic("Guest not found")
	}
	return guest
}

func (guestHandler *guestHandler) setExpirationTime() time.Time {
	return time.Now().Add(15 * time.Minute)
}

func (guestHandler *guestHandler) createClaims(credentials guest.Credentials, expirationTime time.Time) *guest.Claims {
	return &guest.Claims{
		Credentials: credentials,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(expirationTime),
		},
	}
}

func (guestHandler *guestHandler) readKey(responseWriter http.ResponseWriter) []byte {
	key, err := os.ReadFile("C:\\Users\\mhunt\\skey.pem")
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
		log.Panic("Failed to read secret key")
	}
	return key
}

func (guestHandler *guestHandler) createToken(responseWriter http.ResponseWriter, claims *guest.Claims, key []byte) string {
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	tokenString, err := token.SignedString(key)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
		log.Panic("Failed to read token")
	}
	return tokenString
}

func (guestHandler *guestHandler) marshalResponse(responseWriter http.ResponseWriter, weddingGuest guest.Guest, token string) []byte {
	loginResponse := guestHandler.createLoginResponse(weddingGuest, token)
	jsonBytes, err := json.Marshal(loginResponse)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Failed to marshal response")
	}
	return jsonBytes
}

func (guestHandler *guestHandler) createLoginResponse(weddingGuest guest.Guest, token string) *guest.LoginResponse {
	return &guest.LoginResponse{
		Guest: weddingGuest,
		Token: token,
	}
}

func (guestHandler *guestHandler) putGuest(responseWriter http.ResponseWriter, request *http.Request) {
	token := guestHandler.getToken(request)
	claims := guestHandler.initializeClaims()
	key := guestHandler.readKey(responseWriter)
	guestHandler.checkClaims(responseWriter, token, claims, key)
	guestHandler.findId(responseWriter, request)
	guest := guestHandler.decodeGuest(responseWriter, request)
	guestHandler.updateGuest(responseWriter, guest)
}

func (guestHandler *guestHandler) getToken(request *http.Request) string {
	return request.Header.Get("Authorization")
}

func (guestHandler *guestHandler) initializeClaims() *guest.Claims {
	return &guest.Claims{}
}

func (guestHandler *guestHandler) checkClaims(responseWriter http.ResponseWriter, tokenString string, claims *guest.Claims, key []byte) *jwt.Token {
	token, err := guestHandler.parseWithClaims(tokenString, claims, key)
	if err != nil {
		if err == jwt.ErrSignatureInvalid {
			responseWriter.WriteHeader(http.StatusUnauthorized)
			log.Panic("Invalid signature")
		}
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Failed to parse claims")
	}
	if !token.Valid {
		responseWriter.WriteHeader(http.StatusUnauthorized)
		log.Panic("Invalid token")
	}
	return token
}

func (guestHandler *guestHandler) parseWithClaims(token string, claims *guest.Claims, key []byte) (*jwt.Token, error) {
	return jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (any, error) {
		return key, nil
	})
}

func (guestHandler *guestHandler) findId(responseWriter http.ResponseWriter, request *http.Request) {
	matches := guestIdRe.FindStringSubmatch(request.URL.Path)
	if len(matches) < 2 {
		http.Error(responseWriter, "ID not found", http.StatusBadRequest)
		log.Panic("ID not found")
	}
}

func (guestHandler *guestHandler) decodeGuest(responseWriter http.ResponseWriter, request *http.Request) guest.Guest {
	var guest guest.Guest
	err := json.NewDecoder(request.Body).Decode(&guest)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Invalid guest")
	}
	defer request.Body.Close()
	return guest
}

func (guestHandler *guestHandler) updateGuest(responseWriter http.ResponseWriter, guest guest.Guest) {
	err := guestHandler.store.Update(guest)
	if err != nil {
		http.Error(responseWriter, "Failed to update guest", http.StatusBadRequest)
		log.Panic("Failed to update guest")
	}
}

func (guestHandler *guestHandler) getGuests(responseWriter http.ResponseWriter) {
	guests := guestHandler.findGuests(responseWriter)
	jsonBytes := guestHandler.marshalGuests(responseWriter, guests)
	responseWriter.Write(jsonBytes)
}

func (guestHandler *guestHandler) findGuests(responseWriter http.ResponseWriter) []guest.Guest {
	guests, err := guestHandler.store.Get()
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Failed to find guests")
	}
	return guests
}

func (guestHandler *guestHandler) marshalGuests(responseWriter http.ResponseWriter, guests []guest.Guest) []byte {
	jsonBytes, err := json.Marshal(guests)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		log.Panic("Failed to marshal guests")
	}
	return jsonBytes
}

func (guestHandler *guestHandler) postGuest(responseWriter http.ResponseWriter, request *http.Request) {
	guest := guestHandler.decodeGuest(responseWriter, request)
	guests := guestHandler.findGuests(responseWriter)
	guestHandler.checkExistingGuests(responseWriter, guests, guest)
	guestHandler.addGuest(responseWriter, guest)
	responseWriter.WriteHeader(http.StatusOK)
}

func (guestHandler *guestHandler) checkExistingGuests(responseWriter http.ResponseWriter, guests []guest.Guest, newGuest guest.Guest) {
	for _, guest := range guests {
		if guest.Id == newGuest.Id {
			http.Error(responseWriter, "ID already exists", http.StatusBadRequest)
			log.Panic("ID already exists")
		}
	}
}

func (guestHandler *guestHandler) addGuest(responseWriter http.ResponseWriter, guest guest.Guest) {
	err := guestHandler.store.Add(guest)
	if err != nil {
		http.Error(responseWriter, err.Error(), http.StatusBadRequest)
		return
	}
}