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

6from src.dto import SerieDto, UserDto 

7 

8api = SerieDto.api 

9data_resp = SerieDto.data_resp 

10genres_resp = UserDto.genres_resp 

11episodes_resp = SerieDto.episodes_resp 

12meta_resp = UserDto.meta_resp 

13 

14 

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

16class SerieResource(Resource): 

17 @api.doc( 

18 "Get list of the most popular Series", 

19 responses={ 

20 200: ("Serie 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 Series """ 

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 SerieService.get_popular_series(page, user_uuid) 

34 

35 serie_additional = SerieDto.serie_additional_base 

36 

37 @api.doc( 

38 "Add additional Serie for validation", 

39 responses={ 

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

41 401: ("Authentication required"), 

42 } 

43 ) 

44 @jwt_required 

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

46 def post(self): 

47 """ Add additional Serie for validation""" 

48 user_uuid = get_jwt_identity() 

49 

50 # Grab the json data 

51 data = request.get_json() 

52 

53 return SerieService.add_additional_serie(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 SerieUserRecommendationResource(Resource): 

58 @api.doc( 

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

60 responses={ 

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

62 401: ("Authentication required"), 

63 }, 

64 ) 

65 @jwt_required 

66 def get(self): 

67 """ Get list of the recommended Series 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 SerieService.get_recommended_series_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 SerieGroupRecommendationResource(Resource): 

80 @api.doc( 

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

82 responses={ 

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

84 401: ("Authentication required"), 

85 }, 

86 ) 

87 @jwt_required 

88 def get(self): 

89 """ Get list of the recommended Series 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 SerieService.get_recommended_series_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 SerieSearchResource(Resource): 

102 @api.doc( 

103 "Search series", 

104 responses={ 

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

106 401: ("Authentication required"), 

107 }, 

108 ) 

109 @jwt_required 

110 def get(self, search_term): 

111 """ Getlist of serie'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 SerieService.search_serie_data(search_term, page, user_uuid) 

118 

119 

120@api.route("/genres") 

121class SerieGenreResource(Resource): 

122 @api.doc( 

123 "Get serie genres", 

124 responses={ 

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

126 401: ("Authentication required"), 

127 } 

128 ) 

129 @jwt_required 

130 def get(self): 

131 """ Get serie genres """ 

132 user_uuid = get_jwt_identity() 

133 return SerieService.get_ordered_genre(user_uuid) 

134 

135 

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

137class SerieEpisodeResource(Resource): 

138 @api.doc( 

139 "Get series episodes", 

140 responses={ 

141 200: ("Series episodes data sent", episodes_resp), 

142 404: "Series not found!", 

143 } 

144 ) 

145 @jwt_required 

146 def get(self, content_id): 

147 """ Get series episodes """ 

148 return SerieService.get_episodes(content_id) 

149 

150 

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

152class SerieMetaResource(Resource): 

153 @api.doc( 

154 "Get serie-user (connected user) meta", 

155 responses={ 

156 200: ("Serie-User meta data successfully sent", meta_resp), 

157 401: ("Authentication required"), 

158 } 

159 ) 

160 @jwt_required 

161 def get(self, content_id): 

162 """ Get serie-user (connected user) meta """ 

163 user_uuid = get_jwt_identity() 

164 

165 return ContentService.get_meta(user_uuid, content_id) 

166 

167 content_meta = UserDto.content_meta 

168 

169 @api.doc( 

170 "Update serie-user (connected user) meta", 

171 responses={ 

172 201: ("Serie-User meta data successfully sent"), 

173 401: ("Authentication required"), 

174 404: "User or Serie not found!", 

175 }, 

176 ) 

177 @jwt_required 

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

179 def patch(self, content_id): 

180 """ Update serie-user (connected user) meta """ 

181 user_uuid = get_jwt_identity() 

182 

183 # Grab the json data 

184 data = request.get_json() 

185 

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

187 

188 

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

190class SerieBadRecommendation(Resource): 

191 bad_recommendation = SerieDto.serie_bad_recommendation 

192 

193 @api.doc( 

194 "Add Serie-user (connected user) bad recommendation", 

195 responses={ 

196 200: ("Serie-User bad recommendation successfully sent", meta_resp), 

197 401: ("Authentication required"), 

198 } 

199 ) 

200 @jwt_required 

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

202 def post(self, content_id): 

203 """ Add Serie-user (connected user) bad recommendation """ 

204 user_uuid = get_jwt_identity() 

205 

206 # Grab the json data 

207 data = request.get_json() 

208 

209 return SerieService.add_bad_recommendation(user_uuid, content_id, data) 

210 

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

212class SerieAdditionalResource(Resource): 

213 @api.doc( 

214 "Get list of the added Series (by user)", 

215 responses={ 

216 200: ("Series data successfully sent", data_resp), 

217 401: ("Authentication required"), 

218 }, 

219 ) 

220 @jwt_required 

221 def get(self): 

222 """ Get list of the added Series (by user) """ 

223 user_uuid = get_jwt_identity() 

224 

225 parser = reqparse.RequestParser() 

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

227 args = parser.parse_args() 

228 

229 return SerieService.get_additional_serie(user_uuid, args["page"]) 

230 

231 

232@api.route("/additional/<int:serie_id>") 

233class SerieAdditionalValidationResource(Resource): 

234 @api.doc( 

235 "Validate (put) added Series (by user)", 

236 responses={ 

237 201: ("Additional series data successfully validated"), 

238 401: ("Authentication required"), 

239 403: ("Permission missing"), 

240 404: ("User or series not found!"), 

241 }, 

242 ) 

243 @jwt_required 

244 def put(self, serie_id): 

245 """ Validate (put) added Series (by user) """ 

246 user_uuid = get_jwt_identity() 

247 

248 return SerieService.validate_additional_serie(user_uuid, serie_id) 

249 

250 @api.doc( 

251 "Decline (delete) added Series (by user)", 

252 responses={ 

253 201: ("Additional series successfully deleted"), 

254 401: ("Authentication required"), 

255 403: ("Permission missing"), 

256 404: ("User or series not found!"), 

257 }, 

258 ) 

259 @jwt_required 

260 def delete(self, serie_id): 

261 """ Decline (delete) added Series (by user) """ 

262 user_uuid = get_jwt_identity() 

263 

264 return SerieService.decline_additional_serie(user_uuid, serie_id)