changes + add uploader

internal/apps/flags/handlers.go

@@ -1,203 +1,215 @@
 package flags
 
 import (
-	"context"
-	"database/sql"
-	"net/http"
-	"strconv"
-	"time"
+    "context"
+    "database/sql"
+    "net/http"
+    "strconv"
+    "time"
 
-	"git.tijl.dev/tijl/tijl.dev-core/internal/queries"
-	"git.tijl.dev/tijl/tijl.dev-core/internal/user"
-	"git.tijl.dev/tijl/tijl.dev-core/internal/utils"
-	"git.tijl.dev/tijl/tijl.dev-core/modules/db"
-	"git.tijl.dev/tijl/tijl.dev-core/modules/i18n"
-	"git.tijl.dev/tijl/tijl.dev-core/modules/web"
-	"github.com/enescakir/emoji"
-	"github.com/gofiber/fiber/v2"
-	"github.com/google/uuid"
+    "git.tijl.dev/tijl/tijl.dev-core/internal/queries"
+    "git.tijl.dev/tijl/tijl.dev-core/internal/user"
+    "git.tijl.dev/tijl/tijl.dev-core/internal/utils"
+    "git.tijl.dev/tijl/tijl.dev-core/modules/db"
+    "git.tijl.dev/tijl/tijl.dev-core/modules/i18n"
+    "git.tijl.dev/tijl/tijl.dev-core/modules/web"
+    "github.com/enescakir/emoji"
+    "github.com/gofiber/fiber/v2"
+    "github.com/google/uuid"
 )
 
 const flagSessionCookie string = "app_flags_game_session"
 
 type NullableUUID struct {
-	uuid.UUID
-	valid bool
+    uuid.UUID
+    valid bool
 }
 
 type NullableString struct {
-	String string
-	valid  bool
+    String string
+    valid  bool
 }
 
 func answerHandler(c *fiber.Ctx) error {
 
-	gameId, err := uuid.Parse(c.Cookies(flagSessionCookie))
-	if err != nil {
-		return err
-	}
+    gameId, err := uuid.Parse(c.Cookies(flagSessionCookie))
+    if err != nil {
+        return err
+    }
 
-	answer := c.FormValue("answer")
+    answer := c.FormValue("answer")
 
-	gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
-	if err != nil {
-		return err
-	}
+    gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
+    if err != nil {
+        return err
+    }
 
-	err, countries := filterCountriesByTags(gameSession.Tags)
-	if err != nil {
-		return err
-	}
+    err, countries := filterCountriesByTags(gameSession.Tags)
+    if err != nil {
+        return err
+    }
 
-	shuffledCountries := shuffleSlice(countries, gameSession.GameSeed.String())
+    shuffledCountries := shuffleSlice(countries, gameSession.GameSeed.String())
 
-	correctAnswer := shuffledCountries[gameSession.QuestionCurrent-1]
+    correctAnswer := shuffledCountries[gameSession.QuestionCurrent-1]
 
-	if answer == correctAnswer {
-		db.Queries.AppFlagsUpdateGame(context.TODO(), queries.AppFlagsUpdateGameParams{
-			GameID:          gameId,
-			QuestionCurrent: gameSession.QuestionCurrent + 1,
-		})
-		db.Queries.AppFlagsUpsertGameAnswer(context.TODO(), queries.AppFlagsUpsertGameAnswerParams{
-			GameID:   gameId,
-			Question: gameSession.QuestionCurrent,
-			Errors:   0,
-		})
-	} else {
-		db.Queries.AppFlagsUpsertGameAnswer(context.TODO(), queries.AppFlagsUpsertGameAnswerParams{
-			GameID:   gameId,
-			Question: gameSession.QuestionCurrent,
-			Errors:   1,
-		})
-	}
+    if answer == correctAnswer {
+        db.Queries.AppFlagsUpdateGame(context.TODO(), queries.AppFlagsUpdateGameParams{
+            GameID:          gameId,
+            QuestionCurrent: gameSession.QuestionCurrent + 1,
+        })
+        db.Queries.AppFlagsUpsertGameAnswer(context.TODO(), queries.AppFlagsUpsertGameAnswerParams{
+            GameID:   gameId,
+            Question: gameSession.QuestionCurrent,
+            Errors:   0,
+        })
+    } else {
+        db.Queries.AppFlagsUpsertGameAnswer(context.TODO(), queries.AppFlagsUpsertGameAnswerParams{
+            GameID:   gameId,
+            Question: gameSession.QuestionCurrent,
+            Errors:   1,
+        })
+    }
 
-	err = db.Queries.AppFlagsUpdateQuestionCorrect(context.TODO(), gameId)
-	if err != nil {
-		return err
-	}
+    err = db.Queries.AppFlagsUpdateQuestionCorrect(context.TODO(), gameId)
+    if err != nil {
+        return err
+    }
 
-	if answer == correctAnswer {
-		return questionHandler(c, NullableUUID{}, NullableString{})
-	} else {
-		return questionHandler(c, NullableUUID{}, NullableString{valid: true, String: answer})
-	}
+    if answer == correctAnswer {
+        return questionHandler(c, NullableUUID{}, NullableString{})
+    } else {
+        return questionHandler(c, NullableUUID{}, NullableString{valid: true, String: answer})
+    }
 }
 
 func questionHandler(c *fiber.Ctx, newGame NullableUUID, prevError NullableString) error {
 
-	var gameId uuid.UUID
-	var err error
-	if newGame.valid {
-		gameId = newGame.UUID
-	} else {
-		gameId, err = uuid.Parse(c.Cookies(flagSessionCookie))
-		if err != nil {
-			return err
-		}
-	}
+    var gameId uuid.UUID
+    var err error
+    if newGame.valid {
+        gameId = newGame.UUID
+    } else {
+        gameId, err = uuid.Parse(c.Cookies(flagSessionCookie))
+        if err != nil {
+            return err
+        }
+    }
 
-	gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
-	if err != nil {
-		return err
-	}
+    gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
+    if err != nil {
+        return err
+    }
 
-	uid, err := user.GetSession(c)
-	if uid != gameSession.Uid.String {
-		utils.ClearCookie(c, flagSessionCookie)
-		return gameStartHandler(c)
-	}
+    uid, err := user.GetSession(c)
+    if uid != gameSession.Uid.String {
+        utils.ClearCookie(c, flagSessionCookie)
+        return gameStartHandler(c)
+    }
 
-	if (gameSession.QuestionAmount != 0) && (gameSession.QuestionAmount+1 == gameSession.QuestionCurrent) {
-		return gameEndHandler(c)
-	}
+    if (gameSession.QuestionAmount != 0) && (gameSession.QuestionAmount+1 == gameSession.QuestionCurrent) {
+        return gameEndHandler(c)
+    }
 
-	err, countries := filterCountriesByTags(gameSession.Tags)
-	if err != nil {
-		return err
-	}
+    err, countries := filterCountriesByTags(gameSession.Tags)
+    if err != nil {
+        return err
+    }
 
-	if int(gameSession.QuestionCurrent) == len(countries) {
-		return gameEndHandler(c)
-	}
+    if int(gameSession.QuestionCurrent) == len(countries) {
+        return gameEndHandler(c)
+    }
 
-	shuffledCountries := shuffleSlice(countries, gameSession.GameSeed.String())
-	shuffledAnswers := shuffleSlice(countries, gameSession.GameSeed.String()+string(gameSession.QuestionCurrent))
-	shuffledAnswers = shuffledAnswers[0:4]                                                                             // 4 random aswers
-	shuffledAnswers = append(shuffledAnswers, shuffledCountries[gameSession.QuestionCurrent-1])                        // add correct answer
-	shuffledAnswers = shuffleSlice(shuffledAnswers, gameSession.GameSeed.String()+string(gameSession.QuestionCurrent)) // shuffle again
+    shuffledCountries := shuffleSlice(countries, gameSession.GameSeed.String())
+    correctAnswer := shuffledCountries[gameSession.QuestionCurrent-1]
 
-	if gameSession.QuestionAmount != 0 && int(gameSession.QuestionAmount) < len(countries) {
-		shuffledCountries = shuffledCountries[0:gameSession.QuestionAmount]
-	}
+    // Filter out the correct answer from the countries list
+    filteredCountries := filterSlice(countries, correctAnswer)
 
-	var timeleft = []string{}
-	if gameSession.Seconds != 0 {
-		timeleft = append(timeleft, strconv.Itoa(int(gameSession.Seconds)-int(time.Since(gameSession.CreatedAt).Seconds())))
-	}
+    // Shuffle the filtered countries to get random answers
+    shuffledAnswers := shuffleSlice(filteredCountries, gameSession.GameSeed.String()+string(gameSession.QuestionCurrent))
 
-	flag, err := emoji.CountryFlag(shuffledCountries[gameSession.QuestionCurrent-1])
-	if err != nil {
-		return err
-	}
+    // Select 4 random answers from the shuffled list
+    shuffledAnswers = shuffledAnswers[0:4]
 
-	data := *web.Common(c)
-	data["Title"] = "tmp"
-	data["TimeLeft"] = timeleft
-	data["QuestionsLeft"] = len(shuffledCountries) - int(gameSession.QuestionCurrent) + 1
-	data["Answers"] = shuffledAnswers
-	data["Flag"] = flag
-	data["Errors"] = gameSession.QuestionsErrors
-	data["PreviousError"] = prevError.String
-	data["ShortcutKeys"] = []string{"d", "f", "h", "j", "k"}
-	return c.Render("apps/flags/question", data, "layouts/base")
+    // Add the correct answer to the list
+    shuffledAnswers = append(shuffledAnswers, correctAnswer)
+
+    // Shuffle the answers again to randomize the position of the correct answer
+    shuffledAnswers = shuffleSlice(shuffledAnswers, gameSession.GameSeed.String()+string(gameSession.QuestionCurrent))
+
+    if gameSession.QuestionAmount != 0 && int(gameSession.QuestionAmount) < len(countries) {
+        shuffledCountries = shuffledCountries[0:gameSession.QuestionAmount]
+    }
+
+    var timeleft = []string{}
+    if gameSession.Seconds != 0 {
+        timeleft = append(timeleft, strconv.Itoa(int(gameSession.Seconds)-int(time.Since(gameSession.CreatedAt).Seconds())))
+    }
+
+    flag, err := emoji.CountryFlag(shuffledCountries[gameSession.QuestionCurrent-1])
+    if err != nil {
+        return err
+    }
+
+    data := *web.Common(c)
+    data["Title"] = "tmp"
+    data["TimeLeft"] = timeleft
+    data["QuestionsLeft"] = len(shuffledCountries) - int(gameSession.QuestionCurrent) + 1
+    data["Answers"] = shuffledAnswers
+    data["Flag"] = flag
+    data["Errors"] = gameSession.QuestionsErrors
+    data["PreviousError"] = prevError.String
+    data["ShortcutKeys"] = []string{"d", "f", "h", "j", "k"}
+    return c.Render("apps/flags/question", data, "layouts/base")
 }
 
 func sharedGameHandler(c *fiber.Ctx) error {
 
-	shareKey := c.FormValue("sharekey")
-	data, err := db.Queries.AppFlagsGetSharedData(context.TODO(), shareKey)
-	if err != nil {
-		return err
-	}
+    shareKey := c.FormValue("sharekey")
+    data, err := db.Queries.AppFlagsGetSharedData(context.TODO(), shareKey)
+    if err != nil {
+        return err
+    }
 
-	return setupGame(c, data.Tags, int(data.Questions), int(data.Seconds), NullableUUID{valid: true, UUID: data.GameSeed})
+    return setupGame(c, data.Tags, int(data.Questions), int(data.Seconds), NullableUUID{valid: true, UUID: data.GameSeed})
 }
 
 func startNewGameHandler(c *fiber.Ctx) error {
-	values := c.Request().PostArgs().PeekMulti("tags")
-	var selectedTags []string
-	for _, v := range values {
-		selectedTags = append(selectedTags, string(v))
-	}
+    values := c.Request().PostArgs().PeekMulti("tags")
+    var selectedTags []string
+    for _, v := range values {
+        selectedTags = append(selectedTags, string(v))
+    }
 
-	if len(selectedTags) < 1 {
-		return c.Status(http.StatusBadRequest).SendString(i18n.GetTranslations(i18n.GetLanguage(c))["select_more_countries"])
-	}
+    if len(selectedTags) < 1 {
+        return c.Status(http.StatusBadRequest).SendString(i18n.GetTranslations(i18n.GetLanguage(c))["select_more_countries"])
+    }
 
-	err, countries := filterCountriesByTags(selectedTags)
-	if err != nil {
-		return err
-	}
+    err, countries := filterCountriesByTags(selectedTags)
+    if err != nil {
+        return err
+    }
 
-	if len(countries) < 6 {
-		return c.Status(http.StatusBadRequest).SendString(i18n.GetTranslations(i18n.GetLanguage(c))["select_more_countries"])
-	}
+    if len(countries) < 6 {
+        return c.Status(http.StatusBadRequest).SendString(i18n.GetTranslations(i18n.GetLanguage(c))["select_more_countries"])
+    }
 
-	maxQuestions, err := strconv.Atoi(c.FormValue("max_questions"))
-	if err != nil {
-		return err
-	}
+    maxQuestions, err := strconv.Atoi(c.FormValue("max_questions"))
+    if err != nil {
+        return err
+    }
 
-	seconds, err := strconv.Atoi(c.FormValue("seconds"))
-	if err != nil {
-		return err
-	}
+    seconds, err := strconv.Atoi(c.FormValue("seconds"))
+    if err != nil {
+        return err
+    }
 
-	if c.FormValue("share") != "" {
-		return createSharedGameData(c, selectedTags, maxQuestions, seconds)
-	}
+    if c.FormValue("share") != "" {
+        return createSharedGameData(c, selectedTags, maxQuestions, seconds)
+    }
 
-	return setupGame(c, selectedTags, maxQuestions, seconds, NullableUUID{})
+    return setupGame(c, selectedTags, maxQuestions, seconds, NullableUUID{})
 }
 
 func createSharedGameData(c *fiber.Ctx, tags []string, maxQuestions int, seconds int) error {
@@ -206,83 +218,86 @@ func createSharedGameData(c *fiber.Ctx, tags []string, maxQuestions int, seconds
         return c.SendStatus(http.StatusUnauthorized)
     }
 
-	shareKey := utils.RandString(4)
-	_, err = db.Queries.AppFlagsNewSharedData(context.TODO(), queries.AppFlagsNewSharedDataParams{
+    shareKey := utils.RandString(4)
+    _, err = db.Queries.AppFlagsNewSharedData(context.TODO(), queries.AppFlagsNewSharedDataParams{
         Uid: uid,
-		ShareKey:  shareKey,
-		Tags:      tags,
-		Questions: int32(maxQuestions),
-		Seconds:   int32(seconds),
-		GameSeed:  uuid.New(),
-	})
-	if err != nil {
-		return err
-	}
+        ShareKey:  shareKey,
+        Tags:      tags,
+        Questions: int32(maxQuestions),
+        Seconds:   int32(seconds),
+        GameSeed:  uuid.New(),
+    })
+    if err != nil {
+        return err
+    }
 
-	data := *web.Common(c)
-	data["Title"] = "tmp"
-	data["ShareKey"] = shareKey
-	return c.Render("apps/flags/shared", data, "layouts/base")
+    data := *web.Common(c)
+    data["Title"] = "tmp"
+    data["ShareKey"] = shareKey
+    return c.Render("apps/flags/shared", data, "layouts/base")
 }
 
 func setupGame(c *fiber.Ctx, tags []string, maxQuestions int, seconds int, gameSeed NullableUUID) error {
-	var Quid = sql.NullString{}
-	uid, err := user.GetSession(c)
-	if err == nil {
-		Quid.Valid = true
-		Quid.String = uid
-	}
+    var Quid = sql.NullString{}
+    uid, err := user.GetSession(c)
+    if err == nil {
+        Quid.Valid = true
+        Quid.String = uid
+    }
 
-	createGameParams := queries.AppFlagsCreateGameWithSeedParams{
-		Uid:            Quid,
-		Tags:           tags,
-		QuestionAmount: int32(maxQuestions),
-		Seconds:        int32(seconds),
-		GameSeed:       uuid.New(),
-	}
+    createGameParams := queries.AppFlagsCreateGameWithSeedParams{
+        Uid:            Quid,
+        Tags:           tags,
+        QuestionAmount: int32(maxQuestions),
+        Seconds:        int32(seconds),
+        GameSeed:       uuid.New(),
+    }
 
-	if gameSeed.valid {
-		createGameParams.GameSeed = gameSeed.UUID
-	}
+    if gameSeed.valid {
+        createGameParams.GameSeed = gameSeed.UUID
+    }
 
-	gameID, err := db.Queries.AppFlagsCreateGameWithSeed(context.TODO(), createGameParams)
-	if err != nil {
-		return err
-	}
+    gameID, err := db.Queries.AppFlagsCreateGameWithSeed(context.TODO(), createGameParams)
+    if err != nil {
+        return err
+    }
 
-	c.Cookie(&fiber.Cookie{
-		Name:  flagSessionCookie,
-		Value: gameID.String(),
-		//Secure: true,
-	})
+    c.Cookie(&fiber.Cookie{
+        Name:  flagSessionCookie,
+        Value: gameID.String(),
+        //Secure: true,
+    })
 
-	return questionHandler(c, NullableUUID{valid: true, UUID: gameID}, NullableString{})
+    return questionHandler(c, NullableUUID{valid: true, UUID: gameID}, NullableString{})
 }
 
 func gameEndHandler(c *fiber.Ctx) error {
-	gameId, err := uuid.Parse(c.Cookies(flagSessionCookie))
-	if err != nil {
-		return err
-	}
-	gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
-	if err != nil {
-		return err
-	}
-	data := *web.Common(c)
-	data["Title"] = "tmp"
-	data["Errors"] = gameSession.QuestionsErrors
-	return c.Render("apps/flags/end", data, "layouts/base")
+    gameId, err := uuid.Parse(c.Cookies(flagSessionCookie))
+    if err != nil {
+        return err
+    }
+    gameSession, err := db.Queries.AppFlagsGetGame(context.TODO(), gameId)
+    if err != nil {
+        return err
+    }
+    data := *web.Common(c)
+    data["Title"] = "tmp"
+    data["Errors"] = gameSession.QuestionsErrors
+    return c.Render("apps/flags/end", data, "layouts/base")
 
 }
 
 func stopGameHandler(c *fiber.Ctx) error { // exit game
-	utils.ClearCookie(c, flagSessionCookie)
-	return gameStartHandler(c)
+    utils.ClearCookie(c, flagSessionCookie)
+    return gameStartHandler(c)
 }
 
 func gameStartHandler(c *fiber.Ctx) error {
-	data := *web.Common(c)
-	data["Title"] = "tmp"
-	data["SupportedTags"] = supportedTags
-	return c.Render("apps/flags/start", data, "layouts/base")
+
+
+
+    data := *web.Common(c)
+    data["Title"] = "tmp"
+    data["SupportedTags"] = supportedTags
+    return c.Render("apps/flags/start", data, "layouts/base")
 }

internal/apps/flags/util.go

@@ -66,3 +66,13 @@ func filterCountriesByTags(tags []string) (error, []string) {
 
 	return nil, result
 }
+
+func filterSlice(slice []string, value string) []string {
+    var result []string
+    for _, v := range slice {
+        if v != value {
+            result = append(result, v)
+        }
+    }
+    return result
+}