1 files changed, 149 insertions, 5 deletions
diff --git a/backend/controllers/userController.go b/backend/controllers/userController.go
index ab29e32..6fd5049 100644
--- a/backend/controllers/userController.go
+++ b/backend/controllers/userController.go
@@ -16,15 +16,88 @@ func Profile(c *gin.Context) {
                c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))
                return
        }
+        // Retrieve singleplayer records
+        var scoresSP []models.ScoreResponse
+        sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id;`
+        rows, err := database.DB.Query(sql, user.(models.User).SteamID)
+        if err != nil {
+                c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
+                return
+        }
+        i := 0
+        var recordsSP []models.RecordSP
+        for rows.Next() {
+                var mapID int
+                var record models.RecordSP
+                rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
+                if i == 0 {
+                        recordsSP = append(recordsSP, record)
+                        scoresSP = append(scoresSP, models.ScoreResponse{
+                                MapID:   mapID,
+                                Records: recordsSP,
+                        })
+                        continue
+                }
+                // More than one record in one map
+                if mapID == scoresSP[i-1].MapID {
+                        scoresSP[i-1].Records = append(scoresSP[i-1].Records.([]models.RecordSP), record)
+                        continue
+                }
+                // New map
+                recordsSP = append(recordsSP, record)
+                scoresSP = append(scoresSP, models.ScoreResponse{
+                        MapID:   mapID,
+                        Records: recordsSP,
+                })
+                i++
+        }
+        // Retrieve multiplayer records
+        var scoresMP []models.ScoreResponse
+        sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
+        WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id;`
+        rows, err = database.DB.Query(sql, user.(models.User).SteamID, user.(models.User).SteamID)
+        if err != nil {
+                c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
+                return
+        }
+        j := 0
+        var recordsMP []models.RecordMP
+        for rows.Next() {
+                var mapID int
+                var record models.RecordMP
+                rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
+                if j == 0 {
+                        recordsMP = append(recordsMP, record)
+                        scoresMP = append(scoresMP, models.ScoreResponse{
+                                MapID:   mapID,
+                                Records: recordsMP,
+                        })
+                        continue
+                }
+                // More than one record in one map
+                if mapID == scoresMP[j-1].MapID {
+                        scoresMP[j-1].Records = append(scoresMP[j-1].Records.([]models.RecordMP), record)
+                        continue
+                }
+                // New map
+                recordsMP = append(recordsMP, record)
+                scoresMP = append(scoresMP, models.ScoreResponse{
+                        MapID:   mapID,
+                        Records: recordsMP,
+                })
+                j++
+        }
        c.JSON(http.StatusOK, models.Response{
                Success: true,
-                Message: "",
+                Message: "Successfully retrieved user scores.",
                Data: models.ProfileResponse{
                        Profile:     true,
                        SteamID:     user.(models.User).SteamID,
                        Username:    user.(models.User).Username,
                        AvatarLink:  user.(models.User).AvatarLink,
                        CountryCode: user.(models.User).CountryCode,
+                        ScoresSP:    scoresSP,
+                        ScoresMP:    scoresMP,
                },
        })
        return
@@ -52,17 +125,88 @@ func FetchUser(c *gin.Context) {
                c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
                return
        }
-        // Target user exists
+        // Retrieve singleplayer records
-        _, exists := c.Get("user")
+        var scoresSP []models.ScoreResponse
+        sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id;`
+        rows, err := database.DB.Query(sql, user.SteamID)
+        if err != nil {
+                c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
+                return
+        }
+        i := 0
+        var recordsSP []models.RecordSP
+        for rows.Next() {
+                var mapID int
+                var record models.RecordSP
+                rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
+                if i == 0 {
+                        recordsSP = append(recordsSP, record)
+                        scoresSP = append(scoresSP, models.ScoreResponse{
+                                MapID:   mapID,
+                                Records: recordsSP,
+                        })
+                        continue
+                }
+                // More than one record in one map
+                if mapID == scoresSP[i-1].MapID {
+                        scoresSP[i-1].Records = append(scoresSP[i-1].Records.([]models.RecordSP), record)
+                        continue
+                }
+                // New map
+                recordsSP = append(recordsSP, record)
+                scoresSP = append(scoresSP, models.ScoreResponse{
+                        MapID:   mapID,
+                        Records: recordsSP,
+                })
+                i++
+        }
+        // Retrieve multiplayer records
+        var scoresMP []models.ScoreResponse
+        sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
+        WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id;`
+        rows, err = database.DB.Query(sql, user.SteamID, user.SteamID)
+        if err != nil {
+                c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
+                return
+        }
+        j := 0
+        var recordsMP []models.RecordMP
+        for rows.Next() {
+                var mapID int
+                var record models.RecordMP
+                rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
+                if j == 0 {
+                        recordsMP = append(recordsMP, record)
+                        scoresMP = append(scoresMP, models.ScoreResponse{
+                                MapID:   mapID,
+                                Records: recordsMP,
+                        })
+                        continue
+                }
+                // More than one record in one map
+                if mapID == scoresMP[j-1].MapID {
+                        scoresMP[j-1].Records = append(scoresMP[j-1].Records.([]models.RecordMP), record)
+                        continue
+                }
+                // New map
+                recordsMP = append(recordsMP, record)
+                scoresMP = append(scoresMP, models.ScoreResponse{
+                        MapID:   mapID,
+                        Records: recordsMP,
+                })
+                j++
+        }
        c.JSON(http.StatusOK, models.Response{
                Success: true,
-                Message: "",
+                Message: "Successfully retrieved user scores.",
                Data: models.ProfileResponse{
-                        Profile:     exists,
+                        Profile:     true,
                        SteamID:     user.SteamID,
                        Username:    user.Username,
                        AvatarLink:  user.AvatarLink,
                        CountryCode: user.CountryCode,
+                        ScoresSP:    scoresSP,
+                        ScoresMP:    scoresMP,
                },
        })
        return

diff --git a/backend/controllers/userController.go b/backend/controllers/userController.go index ab29e32..6fd5049 100644 --- a/backend/controllers/userController.go +++ b/backend/controllers/userController.go
@@ -16,15 +16,88 @@ func Profile(c *gin.Context) {
16	c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))	16	c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))
17	return	17	return
18	}	18	}
		19	// Retrieve singleplayer records
		20	var scoresSP []models.ScoreResponse
		21	sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id;`
		22	rows, err := database.DB.Query(sql, user.(models.User).SteamID)
		23	if err != nil {
		24	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
		25	return
		26	}
		27	i := 0
		28	var recordsSP []models.RecordSP
		29	for rows.Next() {
		30	var mapID int
		31	var record models.RecordSP
		32	rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
		33	if i == 0 {
		34	recordsSP = append(recordsSP, record)
		35	scoresSP = append(scoresSP, models.ScoreResponse{
		36	MapID: mapID,
		37	Records: recordsSP,
		38	})
		39	continue
		40	}
		41	// More than one record in one map
		42	if mapID == scoresSP[i-1].MapID {
		43	scoresSP[i-1].Records = append(scoresSP[i-1].Records.([]models.RecordSP), record)
		44	continue
		45	}
		46	// New map
		47	recordsSP = append(recordsSP, record)
		48	scoresSP = append(scoresSP, models.ScoreResponse{
		49	MapID: mapID,
		50	Records: recordsSP,
		51	})
		52	i++
		53	}
		54	// Retrieve multiplayer records
		55	var scoresMP []models.ScoreResponse
		56	sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
		57	WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id;`
		58	rows, err = database.DB.Query(sql, user.(models.User).SteamID, user.(models.User).SteamID)
		59	if err != nil {
		60	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
		61	return
		62	}
		63	j := 0
		64	var recordsMP []models.RecordMP
		65	for rows.Next() {
		66	var mapID int
		67	var record models.RecordMP
		68	rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
		69	if j == 0 {
		70	recordsMP = append(recordsMP, record)
		71	scoresMP = append(scoresMP, models.ScoreResponse{
		72	MapID: mapID,
		73	Records: recordsMP,
		74	})
		75	continue
		76	}
		77	// More than one record in one map
		78	if mapID == scoresMP[j-1].MapID {
		79	scoresMP[j-1].Records = append(scoresMP[j-1].Records.([]models.RecordMP), record)
		80	continue
		81	}
		82	// New map
		83	recordsMP = append(recordsMP, record)
		84	scoresMP = append(scoresMP, models.ScoreResponse{
		85	MapID: mapID,
		86	Records: recordsMP,
		87	})
		88	j++
		89	}
19	c.JSON(http.StatusOK, models.Response{	90	c.JSON(http.StatusOK, models.Response{
20	Success: true,	91	Success: true,
21	Message: "",	92	Message: "Successfully retrieved user scores.",
22	Data: models.ProfileResponse{	93	Data: models.ProfileResponse{
23	Profile: true,	94	Profile: true,
24	SteamID: user.(models.User).SteamID,	95	SteamID: user.(models.User).SteamID,
25	Username: user.(models.User).Username,	96	Username: user.(models.User).Username,
26	AvatarLink: user.(models.User).AvatarLink,	97	AvatarLink: user.(models.User).AvatarLink,
27	CountryCode: user.(models.User).CountryCode,	98	CountryCode: user.(models.User).CountryCode,
		99	ScoresSP: scoresSP,
		100	ScoresMP: scoresMP,
28	},	101	},
29	})	102	})
30	return	103	return
@@ -52,17 +125,88 @@ func FetchUser(c *gin.Context) {
52	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))	125	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
53	return	126	return
54	}	127	}
55	// Target user exists	128	// Retrieve singleplayer records
56	_, exists := c.Get("user")	129	var scoresSP []models.ScoreResponse
		130	sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id;`
		131	rows, err := database.DB.Query(sql, user.SteamID)
		132	if err != nil {
		133	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
		134	return
		135	}
		136	i := 0
		137	var recordsSP []models.RecordSP
		138	for rows.Next() {
		139	var mapID int
		140	var record models.RecordSP
		141	rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
		142	if i == 0 {
		143	recordsSP = append(recordsSP, record)
		144	scoresSP = append(scoresSP, models.ScoreResponse{
		145	MapID: mapID,
		146	Records: recordsSP,
		147	})
		148	continue
		149	}
		150	// More than one record in one map
		151	if mapID == scoresSP[i-1].MapID {
		152	scoresSP[i-1].Records = append(scoresSP[i-1].Records.([]models.RecordSP), record)
		153	continue
		154	}
		155	// New map
		156	recordsSP = append(recordsSP, record)
		157	scoresSP = append(scoresSP, models.ScoreResponse{
		158	MapID: mapID,
		159	Records: recordsSP,
		160	})
		161	i++
		162	}
		163	// Retrieve multiplayer records
		164	var scoresMP []models.ScoreResponse
		165	sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
		166	WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id;`
		167	rows, err = database.DB.Query(sql, user.SteamID, user.SteamID)
		168	if err != nil {
		169	c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
		170	return
		171	}
		172	j := 0
		173	var recordsMP []models.RecordMP
		174	for rows.Next() {
		175	var mapID int
		176	var record models.RecordMP
		177	rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
		178	if j == 0 {
		179	recordsMP = append(recordsMP, record)
		180	scoresMP = append(scoresMP, models.ScoreResponse{
		181	MapID: mapID,
		182	Records: recordsMP,
		183	})
		184	continue
		185	}
		186	// More than one record in one map
		187	if mapID == scoresMP[j-1].MapID {
		188	scoresMP[j-1].Records = append(scoresMP[j-1].Records.([]models.RecordMP), record)
		189	continue
		190	}
		191	// New map
		192	recordsMP = append(recordsMP, record)
		193	scoresMP = append(scoresMP, models.ScoreResponse{
		194	MapID: mapID,
		195	Records: recordsMP,
		196	})
		197	j++
		198	}
57	c.JSON(http.StatusOK, models.Response{	199	c.JSON(http.StatusOK, models.Response{
58	Success: true,	200	Success: true,
59	Message: "",	201	Message: "Successfully retrieved user scores.",
60	Data: models.ProfileResponse{	202	Data: models.ProfileResponse{
61	Profile: exists,	203	Profile: true,
62	SteamID: user.SteamID,	204	SteamID: user.SteamID,
63	Username: user.Username,	205	Username: user.Username,
64	AvatarLink: user.AvatarLink,	206	AvatarLink: user.AvatarLink,
65	CountryCode: user.CountryCode,	207	CountryCode: user.CountryCode,
		208	ScoresSP: scoresSP,
		209	ScoresMP: scoresMP,
66	},	210	},
67	})	211	})
68	return	212	return