1from flask import request 

2from flask_restx import Resource, reqparse 

3from flask_jwt_extended import jwt_required, get_jwt_identity 

4 

5from src.service import GameService, ContentService 

6from src.dto import GameDto, UserDto 

7 

8api = GameDto.api 

9data_resp = GameDto.data_resp 

10genres_resp = UserDto.genres_resp 

11meta_resp = UserDto.meta_resp 

12 

13 

14@api.route("", doc={"params": {"page": {"in": "query", "type": "int", "default": 1}}}) 

15class GameResource(Resource): 

16 @api.doc( 

17 "Get list of the most popular Games", 

18 responses={ 

19 200: ("Game data successfully sent", data_resp), 

20 401: ("Authentication required"), 

21 }, 

22 ) 

23 @jwt_required 

24 def get(self): 

25 """ Get list of the most popular Games """ 

26 user_uuid = get_jwt_identity() 

27 

28 try: 

29 page = int(request.args.get('page')) 

30 except (ValueError, TypeError): 

31 page = 1 

32 return GameService.get_popular_games(page, user_uuid) 

33 

34 game_additional = GameDto.game_additional_base 

35 

36 @api.doc( 

37 "Add additional Game for validation", 

38 responses={ 

39 200: ("Additional game added for validation", meta_resp), 

40 401: ("Authentication required"), 

41 } 

42 ) 

43 @jwt_required 

44 @api.expect(game_additional, validate=True) 

45 def post(self): 

46 """ Add additional Game for validation""" 

47 user_uuid = get_jwt_identity() 

48 

49 # Grab the json data 

50 data = request.get_json() 

51 

52 return GameService.add_additional_game(user_uuid, data) 

53 

54 

55@api.route("/user", doc={"params": {"page": {"in": "query", "type": "int", "default": 1}, "reco_engine": {"in": "query", "type": "str", "default": None}}}) 

56class GameUserRecommendationResource(Resource): 

57 @api.doc( 

58 "Get list of the recommended Games for the connected user", 

59 responses={ 

60 200: ("Game data successfully sent", data_resp), 

61 401: ("Authentication required"), 

62 }, 

63 ) 

64 @jwt_required 

65 def get(self): 

66 """ Get list of the recommended Games for the connected user """ 

67 user_uuid = get_jwt_identity() 

68 

69 parser = reqparse.RequestParser() 

70 parser.add_argument('page', type=int, default=1) 

71 parser.add_argument('reco_engine', type=str, default=None) 

72 args = parser.parse_args() 

73 

74 return GameService.get_recommended_games_for_user(args["page"], user_uuid, args["reco_engine"]) 

75 

76 

77@api.route("/groups", doc={"params": {"page": {"in": "query", "type": "int", "default": 1}, "reco_engine": {"in": "query", "type": "str", "default": None}}}) 

78class GameGroupRecommendationResource(Resource): 

79 @api.doc( 

80 "Get list of the recommended Games for the groups of the connected user", 

81 responses={ 

82 200: ("Game data successfully sent", data_resp), 

83 401: ("Authentication required"), 

84 }, 

85 ) 

86 @jwt_required 

87 def get(self): 

88 """ Get list of the recommended Games for the groups of the connected user """ 

89 user_uuid = get_jwt_identity() 

90 

91 parser = reqparse.RequestParser() 

92 parser.add_argument('page', type=int, default=1) 

93 parser.add_argument('reco_engine', type=str, default=None) 

94 args = parser.parse_args() 

95 

96 return GameService.get_recommended_games_for_group(args["page"], user_uuid, args["reco_engine"]) 

97 

98 

99@api.route("/search/<string:search_term>", doc={"params": {"page": {"in": "query", "type": "int", "default": 1}}}) 

100class GameSearchResource(Resource): 

101 @api.doc( 

102 "Search games", 

103 responses={ 

104 200: ("Game data successfully sent", data_resp), 

105 401: ("Authentication required"), 

106 }, 

107 ) 

108 @jwt_required 

109 def get(self, search_term): 

110 """ Getlist of game's data by term """ 

111 user_uuid = get_jwt_identity() 

112 try: 

113 page = int(request.args.get('page')) 

114 except (ValueError, TypeError): 

115 page = 1 

116 return GameService.search_game_data(search_term, page, user_uuid) 

117 

118 

119@api.route("/genres") 

120class GameGenresResource(Resource): 

121 @api.doc( 

122 "Get game genres", 

123 responses={ 

124 200: ("Game genres data successfully sent", genres_resp), 

125 401: ("Authentication required"), 

126 }, 

127 ) 

128 @jwt_required 

129 def get(self): 

130 """ Get game genres """ 

131 user_uuid = get_jwt_identity() 

132 return GameService.get_ordered_genre(user_uuid) 

133 

134 

135@api.route("/<int:content_id>/meta") 

136class GameMetaResource(Resource): 

137 @api.doc( 

138 "Get game-user (connected user) meta", 

139 responses={ 

140 200: ("Game-User meta data successfully sent", meta_resp), 

141 401: ("Authentication required"), 

142 } 

143 ) 

144 @jwt_required 

145 def get(self, content_id): 

146 """ Get track-user (connected user) meta """ 

147 user_uuid = get_jwt_identity() 

148 

149 return ContentService.get_meta(user_uuid, content_id) 

150 

151 content_meta = UserDto.content_meta 

152 

153 @api.doc( 

154 "Update game-user (connected user) meta", 

155 responses={ 

156 201: ("Game-User meta data successfully sent"), 

157 401: ("Authentication required"), 

158 404: "User or Game not found!", 

159 }, 

160 ) 

161 @jwt_required 

162 @api.expect(content_meta, validate=True) 

163 def patch(self, content_id): 

164 """ Update game-user (connected user) meta """ 

165 user_uuid = get_jwt_identity() 

166 

167 # Grab the json data 

168 data = request.get_json() 

169 

170 return ContentService.update_meta(user_uuid, content_id, data) 

171 

172 

173@api.route("/<int:content_id>/bad_recommendation") 

174class GameBadRecommendation(Resource): 

175 bad_recommendation = GameDto.game_bad_recommendation 

176 

177 @api.doc( 

178 "Add Game-user (connected user) bad recommendation", 

179 responses={ 

180 200: ("Game-User bad recommendation successfully sent", meta_resp), 

181 401: ("Authentication required"), 

182 } 

183 ) 

184 @jwt_required 

185 @api.expect(bad_recommendation, validate=True) 

186 def post(self, content_id): 

187 """ Add Game-user (connected user) bad recommendation """ 

188 user_uuid = get_jwt_identity() 

189 

190 # Grab the json data 

191 data = request.get_json() 

192 

193 return GameService.add_bad_recommendation(user_uuid, content_id, data) 

194 

195 

196@api.route("/additional", doc={"params": {"page": {"in": "query", "type": "int", "default": 1}}}) 

197class GameAdditionalResource(Resource): 

198 @api.doc( 

199 "Get list of the added Game (by user)", 

200 responses={ 

201 200: ("Game data successfully sent", data_resp), 

202 401: ("Authentication required"), 

203 }, 

204 ) 

205 @jwt_required 

206 def get(self): 

207 """ Get list of the added Games (by user) """ 

208 user_uuid = get_jwt_identity() 

209 

210 parser = reqparse.RequestParser() 

211 parser.add_argument('page', type=int, default=1) 

212 args = parser.parse_args() 

213 

214 return GameService.get_additional_game(user_uuid, args["page"]) 

215 

216 

217@api.route("/additional/<int:game_id>") 

218class GameAdditionalValidationResource(Resource): 

219 @api.doc( 

220 "Validate (put) added Games (by user)", 

221 responses={ 

222 201: ("Additional game data successfully validated"), 

223 401: ("Authentication required"), 

224 403: ("Permission missing"), 

225 404: ("User or game not found!"), 

226 }, 

227 ) 

228 @jwt_required 

229 def put(self, game_id): 

230 """ Validate (put) added Games (by user) """ 

231 user_uuid = get_jwt_identity() 

232 

233 return GameService.validate_additional_game(user_uuid, game_id) 

234 

235 @api.doc( 

236 "Decline (delete) added Games (by user)", 

237 responses={ 

238 201: ("Additional game successfully deleted"), 

239 401: ("Authentication required"), 

240 403: ("Permission missing"), 

241 404: ("User or game not found!"), 

242 }, 

243 ) 

244 @jwt_required 

245 def delete(self, game_id): 

246 """ Decline (delete) added Games (by user) """ 

247 user_uuid = get_jwt_identity() 

248 

249 return GameService.decline_additional_game(user_uuid, game_id)