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 TrackService, ContentService 

6from src.dto import TrackDto, UserDto 

7 

8api = TrackDto.api 

9data_resp = TrackDto.data_resp 

10genres_resp = UserDto.genres_resp 

11meta_resp = UserDto.meta_resp 

12history_resp = TrackDto.history_resp 

13 

14 

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

16class TrackResource(Resource): 

17 @api.doc( 

18 "Get list of the most popular Tracks", 

19 responses={ 

20 200: ("Track data successfully sent", data_resp), 

21 401: ("Authentication required"), 

22 }, 

23 ) 

24 @jwt_required 

25 def get(self): 

26 """ Get list of the most popular Tracks """ 

27 user_uuid = get_jwt_identity() 

28 

29 try: 

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

31 except (ValueError, TypeError): 

32 page = 1 

33 return TrackService.get_popular_tracks(page, user_uuid) 

34 

35 track_additional = TrackDto.track_additional_base 

36 

37 @api.doc( 

38 "Add additional Track for validation", 

39 responses={ 

40 200: ("Additional track added for validation", meta_resp), 

41 401: ("Authentication required"), 

42 } 

43 ) 

44 @jwt_required 

45 @api.expect(track_additional, validate=True) 

46 def post(self): 

47 """ Add additional Track for validation""" 

48 user_uuid = get_jwt_identity() 

49 

50 # Grab the json data 

51 data = request.get_json() 

52 

53 return TrackService.add_additional_track(user_uuid, data) 

54 

55 

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

57class TrackUserRecommendationResource(Resource): 

58 @api.doc( 

59 "Get list of the recommended Tracks for the connected user", 

60 responses={ 

61 200: ("Track data successfully sent", data_resp), 

62 401: ("Authentication required"), 

63 }, 

64 ) 

65 @jwt_required 

66 def get(self): 

67 """ Get list of the recommended Tracks for the connected user """ 

68 user_uuid = get_jwt_identity() 

69 

70 parser = reqparse.RequestParser() 

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

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

73 args = parser.parse_args() 

74 

75 return TrackService.get_recommended_tracks_for_user(args["page"], user_uuid, args["reco_engine"]) 

76 

77 

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

79class TrackGroupRecommendationResource(Resource): 

80 @api.doc( 

81 "Get list of the recommended Tracks for the groups of the connected user", 

82 responses={ 

83 200: ("Track data successfully sent", data_resp), 

84 401: ("Authentication required"), 

85 }, 

86 ) 

87 @jwt_required 

88 def get(self): 

89 """ Get list of the recommended Tracks for the groups of the connected user """ 

90 user_uuid = get_jwt_identity() 

91 

92 parser = reqparse.RequestParser() 

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

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

95 args = parser.parse_args() 

96 

97 return TrackService.get_recommended_tracks_for_group(args["page"], user_uuid, args["reco_engine"]) 

98 

99 

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

101class TrackSearchResource(Resource): 

102 @api.doc( 

103 "Search tracks", 

104 responses={ 

105 200: ("Track data successfully sent", data_resp), 

106 401: ("Authentication required"), 

107 }, 

108 ) 

109 @jwt_required 

110 def get(self, search_term): 

111 """ Getlist of track's data by term """ 

112 user_uuid = get_jwt_identity() 

113 try: 

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

115 except (ValueError, TypeError): 

116 page = 1 

117 return TrackService.search_track_data(search_term, page, user_uuid) 

118 

119 

120@api.route("/genres") 

121class TrackGenresResource(Resource): 

122 @api.doc( 

123 "Get track genres", 

124 responses={ 

125 200: ("Track data successfully sent", genres_resp), 

126 401: ("Authentication required"), 

127 }, 

128 ) 

129 @jwt_required 

130 def get(self): 

131 """ Get track genres """ 

132 user_uuid = get_jwt_identity() 

133 return TrackService.get_ordered_genre(user_uuid) 

134 

135 

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

137class TrackMetaResource(Resource): 

138 @api.doc( 

139 "Get track-user (connected user) meta", 

140 responses={ 

141 200: ("Track-User meta data successfully sent", meta_resp), 

142 401: ("Authentication required"), 

143 } 

144 ) 

145 @jwt_required 

146 def get(self, content_id): 

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

148 user_uuid = get_jwt_identity() 

149 

150 return ContentService.get_meta(user_uuid, content_id) 

151 

152 content_meta = UserDto.content_meta 

153 

154 @api.doc( 

155 "Update track-user (connected user) meta", 

156 responses={ 

157 201: ("Track-User meta data successfully sent"), 

158 401: ("Authentication required"), 

159 404: "User or Track not found!", 

160 }, 

161 ) 

162 @jwt_required 

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

164 def patch(self, content_id): 

165 """ Update track-user (connected user) meta """ 

166 user_uuid = get_jwt_identity() 

167 

168 # Grab the json data 

169 data = request.get_json() 

170 

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

172 

173 

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

175class TrackHistoryResource(Resource): 

176 @api.doc( 

177 "Get the history of listened track", 

178 responses={ 

179 200: ("History of listened track data successfully sent", history_resp), 

180 401: ("Authentication required"), 

181 404: "User not found!", 

182 }, 

183 ) 

184 @jwt_required 

185 def get(self): 

186 """ Get the history of listened """ 

187 user_uuid = get_jwt_identity() 

188 

189 try: 

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

191 except (ValueError, TypeError): 

192 page = 1 

193 

194 return TrackService.get_history(user_uuid, page) 

195 

196 

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

198class TrackBadRecommendation(Resource): 

199 bad_recommendation = TrackDto.track_bad_recommendation 

200 

201 @api.doc( 

202 "Add Track-user (connected user) bad recommendation", 

203 responses={ 

204 200: ("Track-User bad recommendation successfully sent", meta_resp), 

205 401: ("Authentication required"), 

206 } 

207 ) 

208 @jwt_required 

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

210 def post(self, content_id): 

211 """ Add Track-user (connected user) bad recommendation """ 

212 user_uuid = get_jwt_identity() 

213 

214 # Grab the json data 

215 data = request.get_json() 

216 

217 return TrackService.add_bad_recommendation(user_uuid, content_id, data) 

218 

219 

220 

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

222class TrackAdditionalResource(Resource): 

223 @api.doc( 

224 "Get list of the added Tracks (by user)", 

225 responses={ 

226 200: ("Track data successfully sent", data_resp), 

227 401: ("Authentication required"), 

228 }, 

229 ) 

230 @jwt_required 

231 def get(self): 

232 """ Get list of the added Tracks (by user) """ 

233 user_uuid = get_jwt_identity() 

234 

235 parser = reqparse.RequestParser() 

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

237 args = parser.parse_args() 

238 

239 return TrackService.get_additional_track(user_uuid, args["page"]) 

240 

241 

242@api.route("/additional/<int:track_id>") 

243class TrackAdditionalValidationResource(Resource): 

244 @api.doc( 

245 "Validate (put) added Tracks (by user)", 

246 responses={ 

247 201: ("Additional track data successfully validated"), 

248 401: ("Authentication required"), 

249 403: ("Permission missing"), 

250 404: ("User or track not found!"), 

251 }, 

252 ) 

253 @jwt_required 

254 def put(self, track_id): 

255 """ Validate (put) added Tracks (by user) """ 

256 user_uuid = get_jwt_identity() 

257 

258 return TrackService.validate_additional_track(user_uuid, track_id) 

259 

260 @api.doc( 

261 "Decline (delete) added Tracks (by user)", 

262 responses={ 

263 201: ("Additional track successfully deleted"), 

264 401: ("Authentication required"), 

265 403: ("Permission missing"), 

266 404: ("User or track not found!"), 

267 }, 

268 ) 

269 @jwt_required 

270 def delete(self, track_id): 

271 """ Decline (delete) added Tracks (by user) """ 

272 user_uuid = get_jwt_identity() 

273 

274 return TrackService.decline_additional_track(user_uuid, track_id)