Add a frontend with htmx and simple API

.gitignore

@@ -31,6 +31,7 @@ go.work.sum
 .idea/
 .vscode/
 *.~
+*~
 
 # Database files
 api/*.db

api/api.go

@@ -2,37 +2,51 @@ package api
 
 import (
 	"fmt"
+	"html/template"
 	"log"
 	"net/http"
 
+	"lidsol.org/papeador/auth"
 	"lidsol.org/papeador/store"
 )
 
 type ApiContext struct {
 	Store store.Store
 }
 
+var templates = template.Must(template.ParseGlob("templates/*.html"))
+
 func API(s store.Store, port int) {
 	apiCtx := ApiContext{
 		Store: s,
 	}
 
 	mux := http.NewServeMux()
-	mux.HandleFunc("/program", methodHandler("POST", apiCtx.submitProgram))
-	mux.HandleFunc("/users", methodHandler("POST", apiCtx.createUser))
-	mux.HandleFunc("/contests", methodHandler("POST", apiCtx.createContest))
-	mux.HandleFunc("/problems", methodHandler("POST", apiCtx.createProblem))
-	mux.HandleFunc("/program", methodHandler("POST", apiCtx.SubmitProgram))
 
-	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%v", port), mux))
-}
+	mux.HandleFunc("GET /", apiCtx.getContests)
 
-func methodHandler(method string, h http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != method {
-			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-		h(w, r)
-	}
+	mux.HandleFunc("POST /users/login", apiCtx.loginUser)
+	mux.HandleFunc("GET /login", apiCtx.loginUserView)
+	mux.HandleFunc("GET /logout", apiCtx.logoutUser)
+
+	mux.HandleFunc("POST /users/create", apiCtx.createUser)
+	// mux.HandleFunc("GET /users", apiCtx.createUserView)
+	mux.HandleFunc("GET /users/{id}", apiCtx.getUserByID)
+
+	mux.HandleFunc("POST /contests/new", auth.RequireAuth(apiCtx.createContest))
+	mux.HandleFunc("GET /new-contest", auth.RequireAuth(apiCtx.createContestView))
+	mux.HandleFunc("GET /contests", apiCtx.getContests)
+	mux.HandleFunc("GET /contests/{id}", apiCtx.getContestByID)
+
+	mux.HandleFunc("POST /contests/{id}/problems/new", auth.RequireAuth(apiCtx.createProblem))
+	mux.HandleFunc("GET /contests/{id}/new-problem", auth.RequireAuth(apiCtx.createProblemView))
+	mux.HandleFunc("GET /contests/{contestID}/problems/{problemID}", apiCtx.getProblemByID)
+	mux.HandleFunc("GET /contests/{contestID}/problems/{problemID}/pdf", apiCtx.getProblemStatementByID)
+
+	mux.HandleFunc("POST /contests/{constestID}/problems/{problemID}/submit", auth.RequireAuth(apiCtx.submitProgram))
+	// mux.HandleFunc("GET /contests/{constestID}/problems/{problemID}/submit/{submitID}", auth.RequireAuth(apiCtx.getSubmissionByID))
+	mux.HandleFunc("GET /contests/{constestID}/problems/{problemID}/submit", auth.RequireAuth(apiCtx.getSubmissions))
+	// mux.HandleFunc("GET /contests/{constestID}/problems/{problemID}/last-submit", auth.RequireAuth(apiCtx.getLastSubmission))
+
+	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), mux))
 }

api/contest.go

@@ -1,21 +1,49 @@
 package api
 
 import (
-	"encoding/json"
+	"fmt"
 	"log"
 	"net/http"
+	"strconv"
 
 	"lidsol.org/papeador/store"
 )
 
+type ContestRequestContent struct {
+	store.Contest
+	Username string `json:"username"`
+	JWT      string `json:"jwt"`
+}
+
 func (api *ApiContext) createContest(w http.ResponseWriter, r *http.Request) {
 	var in store.Contest
-	if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
+
+	in.ContestName = r.FormValue("contest-name")
+	in.StartDate = r.FormValue("start-date")
+	in.EndDate = r.FormValue("end-date")
+
+	cookieUsername, err := r.Cookie("username")
+	username := cookieUsername.Value
+
+	// We shouldn't ever get here, handle it anyways
+	if err != nil {
+		log.Println("Sin cookie")
+		http.Error(w, "No hay sesión iniciada", http.StatusNotFound)
+		return
+	}
+
+	id, err := api.Store.GetUserID(r.Context(), username)
+
+	// We shouldn't ever get here, handle it anyways
+	if err != nil {
+		log.Println("Usuario no existe")
+		http.Error(w, "Este usuario no existe", http.StatusNotFound)
 		return
 	}
 
-	if err := api.Store.CreateContest(r.Context(), &in); err != nil {
+	in.OrganizerID = int64(id)
+
+	if err = api.Store.CreateContest(r.Context(), &in); err != nil {
 		if err == store.ErrAlreadyExists {
 			http.Error(w, "El nombre del contest ya esta registrado", http.StatusConflict)
 			log.Println("El nombre del contest ya esta registrado")
@@ -26,7 +54,74 @@ func (api *ApiContext) createContest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	w.Header().Set("Content-Type", "application/json")
+	path := fmt.Sprintf("/contests/%v", in.ContestID)
+	w.Header().Set("HX-Redirect", path)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (api *ApiContext) createContestView(w http.ResponseWriter, r *http.Request) {
+	templates.ExecuteTemplate(w, "createContest.html", nil)
+}
+
+func (api *ApiContext) getContests(w http.ResponseWriter, r *http.Request) {
+	type contestsInfo struct {
+		Contests []store.Contest
+		Username string
+	}
+
+	var info contestsInfo
+	contests, err := api.Store.GetContests(r.Context())
+	info.Contests = contests
+
+	cookieUsername, err := r.Cookie("username")
+	if err == nil {
+		username := cookieUsername.Value
+		info.Username = username
+	}
+
+	if err != nil {
+		log.Println("ERROR", err)
+		w.WriteHeader(http.StatusNotFound)
+		templates.ExecuteTemplate(w, "404.html", &info)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/html")
 	w.WriteHeader(http.StatusCreated)
-	json.NewEncoder(w).Encode(in)
+	templates.ExecuteTemplate(w, "contests.html", &info)
+}
+
+func (api *ApiContext) getContestByID(w http.ResponseWriter, r *http.Request) {
+	idStr := r.PathValue("id")
+	id, _ := strconv.Atoi(idStr)
+
+	type contestInfo struct {
+		store.Contest
+		Problems []store.Problem
+		Username string
+	}
+
+	c, err := api.Store.GetContestByID(r.Context(), id)
+	info := contestInfo{Contest: c}
+
+	cookieUsername, err := r.Cookie("username")
+	if err == nil {
+		username := cookieUsername.Value
+		info.Username = username
+	}
+
+	w.Header().Set("Content-Type", "text/html")
+	if err != nil {
+		log.Println("ERRROR", err)
+		w.WriteHeader(http.StatusNotFound)
+		templates.ExecuteTemplate(w, "404.html", &info)
+		return
+	}
+
+	problems, err := api.Store.GetContestProblems(r.Context(), int(info.ContestID))
+	info.Problems = problems
+	log.Println("info", info)
+
+	w.WriteHeader(http.StatusOK)
+	templates.ExecuteTemplate(w, "contest.html", &info)
 }

api/login.go

@@ -0,0 +1,65 @@
+package api
+
+import (
+	"log"
+	"net/http"
+
+	"lidsol.org/papeador/security"
+	"lidsol.org/papeador/store"
+)
+
+func (api *ApiContext) login(w http.ResponseWriter, r *http.Request) {
+	var in store.User
+	r.ParseForm()
+
+	in.Email = r.FormValue("email")
+	in.Username = r.FormValue("username")
+	in.Password = r.FormValue("password")
+
+	if (in.Username == "" && in.Email == "") || (in.Password == "") {
+		http.Error(w, "Usuario y contraseña son requeridos", http.StatusBadRequest)
+		log.Println("Campos requeridos vacíos")
+		return
+	}
+
+	if err := api.Store.Login(r.Context(), &in); err != nil {
+		if err == store.ErrNotFound {
+			http.Error(w, "El usuario ingresado no existe", http.StatusUnauthorized)
+			log.Println("El usuario ingresado no existe")
+			return
+		} else if err == security.ErrInvalidPassword {
+			http.Error(w, "La contraseña ingresada es incorrecta", http.StatusUnauthorized)
+			log.Println("La contraseña ingresada es incorrecta")
+			return
+		}
+
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		log.Println(err)
+		return
+	}
+	log.Println("SE PUDO INICIAR SESIÓN")
+	http.SetCookie(w, &http.Cookie{
+		Name:  "session",
+		Value: in.JWT,
+		Path:  "/",
+	})
+	http.SetCookie(w, &http.Cookie{
+		Name:  "username",
+		Value: in.Username,
+		Path:  "/",
+	})
+	w.Header().Set("HX-Redirect", "/")
+	w.WriteHeader(http.StatusOK)
+
+}
+func (api *ApiContext) createLoginView(w http.ResponseWriter, r *http.Request) {
+	type prueba struct {
+		Title string
+	}
+	a := prueba{Title: "Iniciar sesión"}
+	if err := templates.ExecuteTemplate(w, "login.html", &a); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		log.Println("Error ejecutando template login.html:", err)
+	}
+}
+