chore(deps): update dependency @sveltejs/kit to v2.20.2

remote/challenge-sync-airbus/api.go

@@ -14,18 +14,10 @@ import (
 type AirbusAPI struct {
 	BaseURL            string
 	Token              string
-	SessionUUID        string
+	SessionID          int64
 	InsecureSkipVerify bool
 }
 
-type AirbusAPIResponse struct {
-	Data        interface{}
-	CurrentPage int `json:"current_page"`
-	PerPage     int `json:"per_page"`
-	LastPage    int `json:"last_page"`
-	Total       int `json:"total"`
-}
-
 func (a *AirbusAPI) request(method, endpoint string, data io.Reader, out interface{}) error {
 	var req *http.Request
 	var err error
@@ -59,7 +51,7 @@ func (a *AirbusAPI) request(method, endpoint string, data io.Reader, out interfa
 		if out != nil {
 			jdec := json.NewDecoder(resp.Body)
 
-			if err := jdec.Decode(&AirbusAPIResponse{Data: out}); err != nil {
+			if err := jdec.Decode(out); err != nil {
 				return fmt.Errorf("an error occurs when trying to decode response: %w", err)
 			}
 		}
@@ -95,7 +87,7 @@ type AirbusUser struct {
 }
 
 func (a *AirbusAPI) GetUsers() (users AirbusUserData, err error) {
-	err = a.request("GET", fmt.Sprintf("/sessions/%s/users", a.SessionUUID), nil, &users)
+	err = a.request("GET", fmt.Sprintf("/sessions/%d/users", a.SessionID), nil, &users)
 	return
 }
 
@@ -145,7 +137,7 @@ type AirbusChallenge struct {
 }
 
 func (a *AirbusAPI) GetChallenges() (challenges AirbusChallengeData, err error) {
-	err = a.request("GET", fmt.Sprintf("/v1/sessions/%s/challenges", a.SessionUUID), nil, &challenges)
+	err = a.request("GET", fmt.Sprintf("/v1/sessions/%d/challenges", a.SessionID), nil, &challenges)
 	return
 }
 
@@ -165,22 +157,24 @@ func (a *AirbusAPI) GetChallengeFromName(name string) (*AirbusChallenge, error)
 }
 
 func (a *AirbusAPI) ValidateChallengeFromUser(team *AirbusTeam, challengeId AirbusChallengeId) (err error) {
-	log.Printf("ValidateChallenge: %s, %s, %s", a.SessionUUID, challengeId.String(), team.Members[0].UUID)
+	log.Printf("ValidateChallenge: %d, %s, %d", a.SessionID, challengeId.String(), team.Members[0].ID)
 	if dryRun {
 		return
 	}
 
-	err = a.request("GET", fmt.Sprintf("/v1/sessions/%s/%s/%s/validate", a.SessionUUID, challengeId.String(), team.Members[0].UUID), nil, nil)
+	err = a.request("GET", fmt.Sprintf("/v1/sessions/%d/%s/%d/validate", a.SessionID, challengeId.String(), team.Members[0].ID), nil, nil)
 	return
 }
 
 type AirbusUserAwards struct {
+	UserId  int64  `json:"gaming_user_id"`
 	Message string `json:"name"`
 	Value   int64  `json:"value"`
 }
 
 func (a *AirbusAPI) AwardUser(team *AirbusTeam, value int64, message string) (err error) {
 	awards := AirbusUserAwards{
+		UserId:  team.Members[0].ID,
 		Message: message,
 		Value:   value,
 	}
@@ -196,7 +190,7 @@ func (a *AirbusAPI) AwardUser(team *AirbusTeam, value int64, message string) (er
 		return
 	}
 
-	err = a.request("POST", fmt.Sprintf("/v1/sessions/%s/%s/awards", a.SessionUUID, team.Members[0].UUID), bytes.NewReader(marshalled), nil)
+	err = a.request("POST", fmt.Sprintf("/v1/sessions/%d/awards", a.SessionID), bytes.NewReader(marshalled), nil)
 	if err != nil {
 		return err
 	}

remote/challenge-sync-airbus/main.go

@@ -77,8 +77,12 @@ func main() {
 		fd.Close()
 	}
 
-	if v, exists := os.LookupEnv("AIRBUS_SESSION_UUID"); exists {
-		api.SessionUUID = v
+	if v, exists := os.LookupEnv("AIRBUS_SESSIONID"); exists {
+		var err error
+		api.SessionID, err = strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			log.Fatal("AIRBUS_SESSIONID is invalid: ", err.Error())
+		}
 	} else if v, exists := os.LookupEnv("AIRBUS_SESSION_NAME_FILE"); exists {
 		fd, err := os.Open(v)
 		if err != nil {
@@ -97,15 +101,15 @@ func main() {
 
 		for _, session := range sessions {
 			if session.Name == v {
-				api.SessionUUID = session.UUID
+				api.SessionID = session.ID
 				break
 			}
 		}
 
-		if api.SessionUUID == "" {
+		if api.SessionID == 0 {
 			log.Fatal("Session ID not found")
 		} else {
-			log.Println("Session ID discovered: ", api.SessionUUID)
+			log.Println("Session ID discovered: ", api.SessionID)
 		}
 	} else if v, exists := os.LookupEnv("AIRBUS_SESSION_NAME"); exists {
 		sessions, err := api.GetSessions()
@@ -113,19 +117,17 @@ func main() {
 			log.Fatal("Unable to retrieve session: ", err)
 		}
 
-		found := false
 		for _, session := range sessions {
 			if session.Name == v {
-				api.SessionUUID = session.UUID
-				found = true
+				api.SessionID = session.ID
 				break
 			}
 		}
 
-		if !found {
+		if api.SessionID == 0 {
 			log.Fatal("Session ID not found")
 		} else {
-			log.Println("Session ID discovered: ", api.SessionUUID)
+			log.Println("Session ID discovered: ", api.SessionID)
 		}
 	} else {
 		sessions, err := api.GetSessions()
@@ -136,7 +138,7 @@ func main() {
 		log.Println("Please define your AIRBUS_SESSIONID or AIRBUS_SESSION_NAME.")
 		log.Println("Existing sessions are:")
 		for _, session := range sessions {
-			log.Printf(" - %s: %q", session.UUID, session.Name)
+			log.Printf(" - %d: %q", session.ID, session.Name)
 		}
 		os.Exit(1)
 	}
@@ -152,14 +154,13 @@ func main() {
 				log.Println("Unable to retrieve teams:", err)
 				os.Exit(1)
 			}
-			log.Println(teams)
 
 			fmt.Println("## Airbus' registered teams:")
-			fmt.Println("----------------------------------------------------------------------------------")
-			fmt.Println(" UUID                                 |                 Name | Nb. | Score | Rank")
-			fmt.Println("----------------------------------------------------------------------------------")
+			fmt.Println("-------------------------------------------")
+			fmt.Println(" ID |            Name | Nb. | Score | Rank")
+			fmt.Println("-------------------------------------------")
 			for _, team := range teams {
-				fmt.Printf(" %s | % 20s | % 3d | % 5d | % 3d\n", team.UUID, team.Name, len(team.Members), team.Score, team.Rank)
+				fmt.Printf("% 2d | % 15s | % 3d | % 5d | % 3d\n", team.ID, team.Name, len(team.Members), team.Score, team.Rank)
 			}
 		case "rank":
 			teams, err := api.GetTeams()
@@ -177,11 +178,11 @@ func main() {
 			sort.Sort(sort.Reverse(ByScore(ranking)))
 
 			fmt.Println("## Airbus' ranking:")
-			fmt.Println("----------------------------------------------------------------------------")
-			fmt.Println(" Rank |                 Name | UUID                                 | Score")
-			fmt.Println("----------------------------------------------------------------------------")
+			fmt.Println("-------------------------------------")
+			fmt.Println(" Rank |            Name | ID | Score")
+			fmt.Println("-------------------------------------")
 			for _, team := range ranking {
-				fmt.Printf("% 5d | % 20s | %s | % 5d\n", team.Rank, team.Name, team.UUID, team.Score)
+				fmt.Printf("% 5d | % 15s |% 3d | % 5d\n", team.Rank, team.Name, team.ID, team.Score)
 			}
 		case "get":
 			teams, err := api.GetTeams()
@@ -190,18 +191,22 @@ func main() {
 				os.Exit(1)
 			}
 
-			teamid := args[1]
+			teamid, err := strconv.ParseInt(args[1], 10, 64)
+			if err != nil {
+				log.Println(err)
+				os.Exit(1)
+			}
 
 			for _, team := range teams {
-				if team.UUID == teamid {
-					fmt.Printf("## Airbus' registered team %s:\n\nUUID: %s\nName: %s\nScore: %d\nRank: %d\nMembers:\n", teamid, team.UUID, team.Name, team.Score, team.Rank)
+				if team.ID == teamid {
+					fmt.Printf("## Airbus' registered team %d:\n\nID: %d\nName: %s\nScore: %d\nRank: %d\nMembers:\n", teamid, team.ID, team.Name, team.Score, team.Rank)
 					for _, member := range team.Members {
-						fmt.Printf("  - UUID: %s\n    Name: %s\n    Nickname: %s\n    E-mail: %s\n", member.UUID, member.Name, member.Nickname, member.EMail)
+						fmt.Printf("  - ID: %d\n    Name: %s\n    Nickname: %s\n    E-mail: %s\n", member.ID, member.Name, member.Nickname, member.EMail)
 					}
 					os.Exit(0)
 				}
 			}
-			fmt.Printf("Team %s not found. Use 'list' to view all existing teams\n", teamid)
+			fmt.Printf("Team %d not found. Use 'list' to view all existing teams\n", teamid)
 		case "award":
 			if len(args) < 3 {
 				fmt.Println("award <TEAM_ID> <VALUE> <MESSAGE>")
@@ -214,7 +219,11 @@ func main() {
 				os.Exit(1)
 			}
 
-			teamid := args[1]
+			teamid, err := strconv.ParseInt(args[1], 10, 64)
+			if err != nil {
+				log.Println("Invalid team id", err)
+				os.Exit(1)
+			}
 
 			value, err := strconv.ParseInt(args[2], 10, 64)
 			if err != nil {
@@ -223,7 +232,7 @@ func main() {
 			}
 
 			for _, team := range teams {
-				if team.UUID == teamid {
+				if team.ID == teamid {
 					err = api.AwardUser(&team, value, strings.Join(args[3:], " "))
 					if err != nil {
 						log.Println("Unable to award team:", err)
@@ -234,7 +243,7 @@ func main() {
 					os.Exit(0)
 				}
 			}
-			fmt.Printf("Team %s not found. Use 'list' to view all existing teams\n", teamid)
+			fmt.Printf("Team %d not found. Use 'list' to view all existing teams\n", teamid)
 		}
 
 		os.Exit(0)

remote/challenge-sync-airbus/session.go

@@ -1,18 +1,12 @@
 package main
 
-import (
-	"time"
-)
+import ()
 
 type Session struct {
-	Name               string    `json:"name"`
-	QuestionValidation string    `json:"question_validation"`
-	Status             string    `json:"status"`
-	UUID               string    `json:"uuid"`
-	Mode               string    `json:"mode"`
-	Difficulty         int       `json:"difficulty"`
-	StartedAt          time.Time `json:"start_at"`
-	FinishAt           time.Time `json:"finish_at"`
+	Name   string `json:"name"`
+	Status string `json:"status"`
+	ID     int64  `json:"id"`
+	Mode   string `json:"mode"`
 }
 
 func (a *AirbusAPI) GetSessions() (ret []Session, err error) {

remote/challenge-sync-airbus/team.go

@@ -5,7 +5,7 @@ import (
 )
 
 type AirbusTeam struct {
-	UUID    string       `json:"session_uuid"`
+	ID      int64        `json:"id"`
 	Members []TeamMember `json:"members"`
 	Name    string       `json:"name"`
 	Score   int64        `json:"score"`
@@ -13,21 +13,23 @@ type AirbusTeam struct {
 }
 
 type TeamMember struct {
-	UUID     string `json:"session_uuid"`
+	ID       int64  `json:"id"`
 	Name     string `json:"name"`
 	Nickname string `json:"nickname"`
 	EMail    string `json:"email"`
 }
 
-type airbusDataTeam []AirbusTeam
+type airbusDataTeam struct {
+	Data []AirbusTeam `json:"data"`
+}
 
 func (a *AirbusAPI) GetTeams() ([]AirbusTeam, error) {
 	var data airbusDataTeam
-	err := a.request("GET", fmt.Sprintf("/v1/sessions/%s/teams", a.SessionUUID), nil, &data)
+	err := a.request("GET", fmt.Sprintf("/v1/sessions/%d/teams", a.SessionID), nil, &data)
 	if err != nil {
 		return nil, err
 	} else {
-		return data, nil
+		return data.Data, nil
 	}
 }
 

remote/challenge-sync-airbus/teams.json

@@ -1,7 +1,6 @@
 [
     {
-      "name": "#D\u00e9fendonsEnsemble",
-      "external_id": "89b35c67-1aa4-43e2-b9da-7f9e7fdfa649",
+        "name": "#D\u00e9fendonsEnsemble",
         "score": 0
     },
     {

remote/challenge-sync-airbus/treat.go

@@ -39,7 +39,7 @@ func (w *Walker) fetchTeams() error {
 
 	for tid, team := range w.Teams {
 		for i, t := range teams {
-			if team.Name == t.Name || team.ExternalId == t.Name || team.ExternalId == t.UUID {
+			if team.Name == t.Name || team.ExternalId == t.Name {
 				w.TeamBindings[tid] = &teams[i]
 				break
 			}