aboutsummaryrefslogtreecommitdiff
path: root/backend/controllers/userController.go
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--backend/controllers/userController.go286
1 files changed, 0 insertions, 286 deletions
diff --git a/backend/controllers/userController.go b/backend/controllers/userController.go
deleted file mode 100644
index 6aa77fc..0000000
--- a/backend/controllers/userController.go
+++ /dev/null
@@ -1,286 +0,0 @@
1package controllers
2
3import (
4 "net/http"
5 "os"
6 "regexp"
7 "time"
8
9 "github.com/gin-gonic/gin"
10 "github.com/pektezol/leastportalshub/backend/database"
11 "github.com/pektezol/leastportalshub/backend/models"
12)
13
14// GET Profile
15//
16// @Description Get profile page of session user.
17// @Tags users
18// @Accept json
19// @Produce json
20// @Param Authorization header string true "JWT Token"
21// @Success 200 {object} models.Response{data=models.ProfileResponse}
22// @Failure 400 {object} models.Response
23// @Failure 401 {object} models.Response
24// @Router /profile [get]
25func Profile(c *gin.Context) {
26 // Check if user exists
27 user, exists := c.Get("user")
28 if !exists {
29 c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))
30 return
31 }
32 // Retrieve singleplayer records
33 var scoresSP []models.ScoreResponse
34 sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id`
35 rows, err := database.DB.Query(sql, user.(models.User).SteamID)
36 if err != nil {
37 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
38 return
39 }
40 var recordsSP []models.RecordSP
41 for rows.Next() {
42 var mapID int
43 var record models.RecordSP
44 rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
45 // More than one record in one map
46 if len(scoresSP) != 0 && mapID == scoresSP[len(scoresSP)-1].MapID {
47 scoresSP[len(scoresSP)-1].Records = append(scoresSP[len(scoresSP)-1].Records.([]models.RecordSP), record)
48 continue
49 }
50 // New map
51 recordsSP = []models.RecordSP{}
52 recordsSP = append(recordsSP, record)
53 scoresSP = append(scoresSP, models.ScoreResponse{
54 MapID: mapID,
55 Records: recordsSP,
56 })
57 }
58 // Retrieve multiplayer records
59 var scoresMP []models.ScoreResponse
60 sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
61 WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id`
62 rows, err = database.DB.Query(sql, user.(models.User).SteamID, user.(models.User).SteamID)
63 if err != nil {
64 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
65 return
66 }
67 var recordsMP []models.RecordMP
68 for rows.Next() {
69 var mapID int
70 var record models.RecordMP
71 rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
72 // More than one record in one map
73 if len(scoresMP) != 0 && mapID == scoresMP[len(scoresMP)-1].MapID {
74 scoresMP[len(scoresMP)-1].Records = append(scoresMP[len(scoresMP)-1].Records.([]models.RecordMP), record)
75 continue
76 }
77 // New map
78 recordsMP = []models.RecordMP{}
79 recordsMP = append(recordsMP, record)
80 scoresMP = append(scoresMP, models.ScoreResponse{
81 MapID: mapID,
82 Records: recordsMP,
83 })
84 }
85 c.JSON(http.StatusOK, models.Response{
86 Success: true,
87 Message: "Successfully retrieved user scores.",
88 Data: models.ProfileResponse{
89 Profile: true,
90 SteamID: user.(models.User).SteamID,
91 UserName: user.(models.User).UserName,
92 AvatarLink: user.(models.User).AvatarLink,
93 CountryCode: user.(models.User).CountryCode,
94 ScoresSP: scoresSP,
95 ScoresMP: scoresMP,
96 },
97 })
98 return
99}
100
101// GET User
102//
103// @Description Get profile page of another user.
104// @Tags users
105// @Accept json
106// @Produce json
107// @Param id path int true "User ID"
108// @Success 200 {object} models.Response{data=models.ProfileResponse}
109// @Failure 400 {object} models.Response
110// @Failure 404 {object} models.Response
111// @Router /users/{id} [get]
112func FetchUser(c *gin.Context) {
113 id := c.Param("id")
114 // Check if id is all numbers and 17 length
115 match, _ := regexp.MatchString("^[0-9]{17}$", id)
116 if !match {
117 c.JSON(http.StatusNotFound, models.ErrorResponse("User not found."))
118 return
119 }
120 // Check if user exists
121 var user models.User
122 err := database.DB.QueryRow(`SELECT * FROM users WHERE steam_id = $1`, id).Scan(
123 &user.SteamID, &user.UserName, &user.AvatarLink, &user.CountryCode,
124 &user.CreatedAt, &user.UpdatedAt)
125 if user.SteamID == "" {
126 // User does not exist
127 c.JSON(http.StatusNotFound, models.ErrorResponse("User not found."))
128 return
129 }
130 if err != nil {
131 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
132 return
133 }
134 // Retrieve singleplayer records
135 var scoresSP []models.ScoreResponse
136 sql := `SELECT id, map_id, score_count, score_time, demo_id, record_date FROM records_sp WHERE user_id = $1 ORDER BY map_id`
137 rows, err := database.DB.Query(sql, user.SteamID)
138 if err != nil {
139 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
140 return
141 }
142 var recordsSP []models.RecordSP
143 for rows.Next() {
144 var mapID int
145 var record models.RecordSP
146 rows.Scan(&record.RecordID, &mapID, &record.ScoreCount, &record.ScoreTime, &record.DemoID, &record.RecordDate)
147 // More than one record in one map
148 if len(scoresSP) != 0 && mapID == scoresSP[len(scoresSP)-1].MapID {
149 scoresSP[len(scoresSP)-1].Records = append(scoresSP[len(scoresSP)-1].Records.([]models.RecordSP), record)
150 continue
151 }
152 // New map
153 recordsSP = []models.RecordSP{}
154 recordsSP = append(recordsSP, record)
155 scoresSP = append(scoresSP, models.ScoreResponse{
156 MapID: mapID,
157 Records: recordsSP,
158 })
159 }
160 // Retrieve multiplayer records
161 var scoresMP []models.ScoreResponse
162 sql = `SELECT id, map_id, host_id, partner_id, score_count, score_time, host_demo_id, partner_demo_id, record_date FROM records_mp
163 WHERE host_id = $1 OR partner_id = $2 ORDER BY map_id`
164 rows, err = database.DB.Query(sql, user.SteamID, user.SteamID)
165 if err != nil {
166 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
167 return
168 }
169 var recordsMP []models.RecordMP
170 for rows.Next() {
171 var mapID int
172 var record models.RecordMP
173 rows.Scan(&record.RecordID, &mapID, &record.HostID, &record.PartnerID, &record.ScoreCount, &record.ScoreTime, &record.HostDemoID, &record.PartnerDemoID, &record.RecordDate)
174 // More than one record in one map
175 if len(scoresMP) != 0 && mapID == scoresMP[len(scoresMP)-1].MapID {
176 scoresMP[len(scoresMP)-1].Records = append(scoresMP[len(scoresMP)-1].Records.([]models.RecordMP), record)
177 continue
178 }
179 // New map
180 recordsMP = []models.RecordMP{}
181 recordsMP = append(recordsMP, record)
182 scoresMP = append(scoresMP, models.ScoreResponse{
183 MapID: mapID,
184 Records: recordsMP,
185 })
186 }
187 c.JSON(http.StatusOK, models.Response{
188 Success: true,
189 Message: "Successfully retrieved user scores.",
190 Data: models.ProfileResponse{
191 Profile: true,
192 SteamID: user.SteamID,
193 UserName: user.UserName,
194 AvatarLink: user.AvatarLink,
195 CountryCode: user.CountryCode,
196 ScoresSP: scoresSP,
197 ScoresMP: scoresMP,
198 },
199 })
200 return
201}
202
203// PUT Profile
204//
205// @Description Update profile page of session user.
206// @Tags users
207// @Accept json
208// @Produce json
209// @Param Authorization header string true "JWT Token"
210// @Success 200 {object} models.Response{data=models.ProfileResponse}
211// @Failure 400 {object} models.Response
212// @Failure 401 {object} models.Response
213// @Router /profile [post]
214func UpdateUser(c *gin.Context) {
215 // Check if user exists
216 user, exists := c.Get("user")
217 if !exists {
218 c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))
219 return
220 }
221 profile, err := GetPlayerSummaries(user.(models.User).SteamID, os.Getenv("API_KEY"))
222 if err != nil {
223 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
224 return
225 }
226 // Update profile
227 _, err = database.DB.Exec(`UPDATE users SET username = $1, avatar_link = $2, country_code = $3, updated_at = $4
228 WHERE steam_id = $5`, profile.PersonaName, profile.AvatarFull, profile.LocCountryCode, time.Now().UTC(), user.(models.User).SteamID)
229 if err != nil {
230 c.JSON(http.StatusBadRequest, models.ErrorResponse(err.Error()))
231 return
232 }
233 c.JSON(http.StatusOK, models.Response{
234 Success: true,
235 Message: "Successfully updated user.",
236 Data: models.ProfileResponse{
237 Profile: true,
238 SteamID: user.(models.User).SteamID,
239 UserName: profile.PersonaName,
240 AvatarLink: profile.AvatarFull,
241 CountryCode: profile.LocCountryCode,
242 },
243 })
244}
245
246// PUT Profile/CountryCode
247//
248// @Description Update country code of session user.
249// @Tags users
250// @Accept json
251// @Produce json
252// @Param Authorization header string true "JWT Token"
253// @Param country_code query string true "Country Code [XX]"
254// @Success 200 {object} models.Response
255// @Failure 400 {object} models.Response
256// @Failure 401 {object} models.Response
257// @Router /profile [put]
258func UpdateCountryCode(c *gin.Context) {
259 // Check if user exists
260 user, exists := c.Get("user")
261 if !exists {
262 c.JSON(http.StatusUnauthorized, models.ErrorResponse("User not logged in."))
263 return
264 }
265 code := c.Query("country_code")
266 if code == "" {
267 c.JSON(http.StatusNotFound, models.ErrorResponse("Enter a valid country code."))
268 return
269 }
270 var validCode string
271 err := database.DB.QueryRow(`SELECT country_code FROM countries WHERE country_code = $1`, code).Scan(&validCode)
272 if err != nil {
273 c.JSON(http.StatusNotFound, models.ErrorResponse(err.Error()))
274 return
275 }
276 // Valid code, update profile
277 _, err = database.DB.Exec(`UPDATE users SET country_code = $1 WHERE steam_id = $2`, validCode, user.(models.User).SteamID)
278 if err != nil {
279 c.JSON(http.StatusNotFound, models.ErrorResponse(err.Error()))
280 return
281 }
282 c.JSON(http.StatusOK, models.Response{
283 Success: true,
284 Message: "Successfully updated country code.",
285 })
286}
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-09 21:06:12 +0000