1from src.dto.application_dto import ApplicationDto 

2from flask import request 

3from flask_restx import Resource, reqparse 

4from flask_jwt_extended import jwt_required, get_jwt_identity 

5 

6from src.service import MovieService, ContentService 

7from src.dto import MovieDto, UserDto 

8 

9api = MovieDto.api 

10data_resp = MovieDto.data_resp 

11genres_resp = UserDto.genres_resp 

12meta_resp = UserDto.meta_resp 

13 

14 

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

16class MovieResource(Resource): 

17 @api.doc( 

18 "Get list of the most popular Movies", 

19 responses={ 

20 200: ("Movie 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 Movies """ 

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 MovieService.get_popular_movies(page, user_uuid) 

34 

35 movie_additional = MovieDto.movie_additional_base 

36 

37 @api.doc( 

38 "Add additional Movie for validation", 

39 responses={ 

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

41 401: ("Authentication required"), 

42 } 

43 ) 

44 @jwt_required 

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

46 def post(self): 

47 """ Add additional Movie for validation""" 

48 user_uuid = get_jwt_identity() 

49 

50 # Grab the json data 

51 data = request.get_json() 

52 

53 return MovieService.add_additional_movie(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 MovieUserRecommendationResource(Resource): 

58 @api.doc( 

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

60 responses={ 

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

62 401: ("Authentication required"), 

63 }, 

64 ) 

65 @jwt_required 

66 def get(self): 

67 """ Get list of the recommended Movies 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 MovieService.get_recommended_movies_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 MovieGroupRecommendationResource(Resource): 

80 @api.doc( 

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

82 responses={ 

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

84 401: ("Authentication required"), 

85 }, 

86 ) 

87 @jwt_required 

88 def get(self): 

89 """ Get list of the recommended Movies 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 MovieService.get_recommended_movies_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 MovieSearchResource(Resource): 

102 @api.doc( 

103 "Search movies", 

104 responses={ 

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

106 401: ("Authentication required"), 

107 }, 

108 ) 

109 @jwt_required 

110 def get(self, search_term): 

111 """ Getlist of movie'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 MovieService.search_movie_data(search_term, page, user_uuid) 

118 

119 

120@api.route("/genres") 

121class MovieGenresResource(Resource): 

122 @api.doc( 

123 "Get movie genres", 

124 responses={ 

125 200: ("Movie genres data successfully sent", genres_resp), 

126 401: ("Authentication required"), 

127 }, 

128 ) 

129 @jwt_required 

130 def get(self): 

131 """ Get movie genres """ 

132 user_uuid = get_jwt_identity() 

133 return MovieService.get_ordered_genre(user_uuid) 

134 

135 

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

137class MovieMetaResource(Resource): 

138 @api.doc( 

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

140 responses={ 

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

142 401: ("Authentication required"), 

143 } 

144 ) 

145 @jwt_required 

146 def get(self, content_id): 

147 """ Get movie-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 movie-user (connected user) meta", 

156 responses={ 

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

158 401: ("Authentication required"), 

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

160 }, 

161 ) 

162 @jwt_required 

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

164 def patch(self, content_id): 

165 """ Update movie-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("/<int:content_id>/bad_recommendation") 

175class MovieBadRecommendation(Resource): 

176 bad_recommendation = ApplicationDto.application_bad_recommendation 

177 

178 @api.doc( 

179 "Add Movie-user (connected user) bad recommendation", 

180 responses={ 

181 200: ("Movie-User bad recommendation successfully sent", meta_resp), 

182 401: ("Authentication required"), 

183 } 

184 ) 

185 @jwt_required 

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

187 def post(self, content_id): 

188 """ Add Movie-user (connected user) bad recommendation """ 

189 user_uuid = get_jwt_identity() 

190 

191 # Grab the json data 

192 data = request.get_json() 

193 

194 return MovieService.add_bad_recommendation(user_uuid, content_id, data) 

195 

196 

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

198class MovieAdditionalResource(Resource): 

199 @api.doc( 

200 "Get list of the added Movies (by user)", 

201 responses={ 

202 200: ("Movie data successfully sent", data_resp), 

203 401: ("Authentication required"), 

204 }, 

205 ) 

206 @jwt_required 

207 def get(self): 

208 """ Get list of the added Movies (by user) """ 

209 user_uuid = get_jwt_identity() 

210 

211 parser = reqparse.RequestParser() 

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

213 args = parser.parse_args() 

214 

215 return MovieService.get_additional_movie(user_uuid, args["page"]) 

216 

217 

218@api.route("/additional/<int:movie_id>") 

219class MovieAdditionalValidationResource(Resource): 

220 @api.doc( 

221 "Validate (put) added Movies (by user)", 

222 responses={ 

223 201: ("Additional movie data successfully validated"), 

224 401: ("Authentication required"), 

225 403: ("Permission missing"), 

226 404: ("User or movie not found!"), 

227 }, 

228 ) 

229 @jwt_required 

230 def put(self, movie_id): 

231 """ Validate (put) added Movies (by user) """ 

232 user_uuid = get_jwt_identity() 

233 

234 return MovieService.validate_additional_movie(user_uuid, movie_id) 

235 

236 @api.doc( 

237 "Decline (delete) added Movies (by user)", 

238 responses={ 

239 201: ("Additional movie successfully deleted"), 

240 401: ("Authentication required"), 

241 403: ("Permission missing"), 

242 404: ("User or movie not found!"), 

243 }, 

244 ) 

245 @jwt_required 

246 def delete(self, movie_id): 

247 """ Decline (delete) added Movies (by user) """ 

248 user_uuid = get_jwt_identity() 

249 

250 return MovieService.decline_additional_movie(user_uuid, movie_id)