1from flask import current_app 

2from flask_jwt_extended import get_jwt_claims 

3from sqlalchemy.orm import subqueryload 

4import requests 

5 

6from src import db 

7from settings import ENGINE_APIKEY, ENGINE_URL 

8from src.utils import err_resp, message, pagination_resp, internal_err_resp, Paginator 

9from src.model import ProfileModel, GenreModel, UserModel, MetaProfileContentModel, ContentModel, ApplicationModel, BookModel, GameModel, MovieModel, SerieModel, TrackModel, RecommendationLaunchedForProfileEvent, RecoLaunchedLikedGenreModel, RecoMetaModel, RecoResultModel 

10from src.schemas import ProfileBase, ProfileObject, GenreBase, MetaProfileApplicationItem, MetaProfileBookItem, MetaProfileGameItem, MetaProfileMovieItem, MetaProfileSerieItem, MetaProfileTrackItem, RecommendationLaunchedForProfileBase, RecommendationLaunchedForProfileItem, RecoMetaApplicationItem, RecoMetaBookItem, RecoMetaGameItem, RecoMetaMovieItem, RecoMetaSerieItem, RecoMetaTrackItem, RecoResultApplicationItem, RecoResultBookItem, RecoResultGameItem, RecoResultMovieItem, RecoResultSerieItem, RecoResultTrackItem, RecoLaunchedLikedGenreItem 

11 

12 

13class ProfileService: 

14 @staticmethod 

15 def get_profiles(connected_user_uuid, page): 

16 """" Get user's profile list """ 

17 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

18 return err_resp("User not found!", 404) 

19 

20 # Check permissions 

21 permissions = get_jwt_claims()['permissions'] 

22 if "access_sandbox" not in permissions: 

23 return err_resp("Permission missing", 403) 

24 

25 profiles, total_pages = Paginator.get_from( 

26 ProfileModel.query.filter_by(user_id=user.user_id), 

27 page, 

28 ) 

29 

30 try: 

31 profile_data = ProfileBase.loads(profiles) 

32 

33 return pagination_resp( 

34 message="Profile data sent", 

35 content=profile_data, 

36 page=page, 

37 total_pages=total_pages 

38 ) 

39 

40 except Exception as error: 

41 current_app.logger.error(error) 

42 return internal_err_resp() 

43 

44 @staticmethod 

45 def create_profile(data, connected_user_uuid): 

46 """ Create new profile """ 

47 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

48 return err_resp("User not found!", 404) 

49 

50 if ProfileModel.query.filter_by(user_id=user.user_id, profilename=data["profilename"]).first() is not None: 

51 return err_resp("You have already created a profile with this name!", 400) 

52 

53 try: 

54 new_profile = ProfileModel( 

55 profilename=data["profilename"], 

56 user_id=user.user_id 

57 ) 

58 

59 db.session.add(new_profile) 

60 db.session.commit() 

61 

62 profile_data = ProfileBase.load(new_profile) 

63 

64 resp = message(True, "Profile created") 

65 resp["profile"] = profile_data 

66 

67 return resp, 201 

68 

69 except Exception as error: 

70 current_app.logger.error(error) 

71 return internal_err_resp() 

72 

73 @staticmethod 

74 def get_profile_data(uuid, connected_profile_uuid): 

75 """ Get profile's data by uuid """ 

76 

77 if not (user := UserModel.query.filter_by(uuid=connected_profile_uuid).first()): 

78 return err_resp("User not found!", 404) 

79 

80 if not (profile := ProfileModel.query.filter_by(uuid=uuid).first()): 

81 return err_resp("Profile not found!", 404) 

82 

83 try: 

84 profile_data = ProfileObject.load(profile) 

85 

86 resp = message(True, "Profile data sent") 

87 resp["profile"] = profile_data 

88 return resp, 200 

89 

90 except Exception as error: 

91 current_app.logger.error(error) 

92 return internal_err_resp() 

93 

94 @staticmethod 

95 def get_genres(connected_uuid, uuid_profile): 

96 """ Get profile liked genre list """ 

97 if not (user := UserModel.query.filter_by(uuid=connected_uuid).first()): 

98 return err_resp("User not found!", 404) 

99 if not (profile := ProfileModel.query.filter_by(user_id=user.user_id, uuid=uuid_profile).first()): 

100 return err_resp("Profile not found!", 404) 

101 

102 try: 

103 genres_data = GenreBase.loads(profile.liked_genres) 

104 

105 resp = message(True, "Profile liked genre sent") 

106 resp["content"] = genres_data 

107 return resp, 200 

108 except Exception as error: 

109 current_app.logger.error(error) 

110 return internal_err_resp() 

111 

112 @staticmethod 

113 def like_genre(genre_id, user_uuid, profile_uuid): 

114 """" Like a genre """ 

115 if not (user := UserModel.query.filter_by(uuid=user_uuid).first()): 

116 return err_resp("User not found!", 404) 

117 if not (profile := ProfileModel.query.filter_by(user_id=user.user_id, uuid=profile_uuid).first()): 

118 return err_resp("Profile not found!", 404) 

119 

120 # Check permissions 

121 permissions = get_jwt_claims()['permissions'] 

122 if "access_sandbox" not in permissions: 

123 return err_resp("Permission missing", 403) 

124 

125 if not (genre := GenreModel.query.filter_by(genre_id=genre_id).first()): 

126 return err_resp("Genre not found!", 404) 

127 

128 try: 

129 profile.liked_genres.append(genre) 

130 

131 db.session.add(profile) 

132 db.session.commit() 

133 

134 resp = message(True, "Profile liked this genre") 

135 return resp, 201 

136 except Exception as error: 

137 current_app.logger.error(error) 

138 return internal_err_resp() 

139 

140 @staticmethod 

141 def unlike_genre(genre_id, user_uuid, profile_uuid): 

142 """" Unlike a genre """ 

143 if not (user := UserModel.query.filter_by(uuid=user_uuid).first()): 

144 return err_resp("User not found!", 404) 

145 if not (profile := ProfileModel.query.filter_by(user_id=user.user_id, uuid=profile_uuid).first()): 

146 return err_resp("Profile not found!", 404) 

147 

148 # Check permissions 

149 permissions = get_jwt_claims()['permissions'] 

150 if "access_sandbox" not in permissions: 

151 return err_resp("Permission missing", 403) 

152 

153 if not (genre := GenreModel.query.filter_by(genre_id=genre_id).first()): 

154 return err_resp("Genre not found!", 404) 

155 

156 if genre not in profile.liked_genres: 

157 return err_resp("You didn't like this genre", 400) 

158 

159 try: 

160 profile.liked_genres.remove(genre) 

161 

162 db.session.add(profile) 

163 db.session.commit() 

164 

165 resp = message(True, "Profile liked this genre") 

166 return resp, 201 

167 except Exception as error: 

168 current_app.logger.error(error) 

169 return internal_err_resp() 

170 

171 @staticmethod 

172 def update_profile_data(profile_uuid, connected_profile_uuid, data): 

173 """ Update profile data profilename """ 

174 

175 if not (user := UserModel.query.filter_by(uuid=connected_profile_uuid).first()): 

176 return err_resp("User not found!", 404) 

177 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

178 return err_resp("Profile not found!", 404) 

179 

180 # Check permissions 

181 permissions = get_jwt_claims()['permissions'] 

182 if "access_sandbox" not in permissions: 

183 return err_resp("Permission missing", 403) 

184 

185 if str(user.uuid) != connected_profile_uuid: 

186 return err_resp("Unable to update an account which is not your's", 403) 

187 

188 try: 

189 if 'profilename' in data.keys(): 

190 profile.profilename = data['profilename'] 

191 

192 db.session.add(profile) 

193 db.session.commit() 

194 

195 resp = message(True, "Profile updated successfully") 

196 return resp, 201 

197 

198 except Exception as error: 

199 current_app.logger.error(error) 

200 return internal_err_resp() 

201 

202 @staticmethod 

203 def delete_account(profile_uuid, connected_profile_uuid): 

204 """" Delete profile account """ 

205 

206 if not (user := UserModel.query.filter_by(uuid=connected_profile_uuid).first()): 

207 return err_resp("User not found!", 404) 

208 if not (ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

209 return err_resp("Profile not found!", 404) 

210 

211 # Check permissions 

212 permissions = get_jwt_claims()['permissions'] 

213 if "access_sandbox" not in permissions: 

214 return err_resp("Permission missing", 403) 

215 

216 if not (ProfileModel.query.filter_by(user_id=user.user_id, uuid=profile_uuid).first()): 

217 return err_resp("Unable to delete an account which is not your's", 403) 

218 

219 try: 

220 ProfileModel.query.filter_by(uuid=profile_uuid).delete() 

221 

222 db.session.commit() 

223 

224 resp = message(True, "Profile deleted successfully") 

225 return resp, 201 

226 

227 except Exception as error: 

228 current_app.logger.error(error) 

229 return internal_err_resp() 

230 

231 @staticmethod 

232 def get_profile_meta_app(profile_uuid, connected_user_uuid, page): 

233 """ Get profile meta applicaiton """ 

234 

235 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

236 return err_resp("User not found!", 404) 

237 

238 # Check permissions 

239 permissions = get_jwt_claims()['permissions'] 

240 if "access_sandbox" not in permissions: 

241 return err_resp("Permission missing", 403) 

242 

243 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

244 return err_resp("Profile not found!", 404) 

245 

246 metas, total_pages = Paginator.get_from( 

247 db.session.query(MetaProfileContentModel, ApplicationModel) 

248 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

249 .join(ApplicationModel, ApplicationModel.content_id == ContentModel.content_id) 

250 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

251 page, 

252 ) 

253 

254 try: 

255 def c_load(row): 

256 row[0].application = row[1] 

257 return row[0] 

258 

259 metas = list(map(c_load, metas)) 

260 meta_data = MetaProfileApplicationItem.loads(metas) 

261 

262 return pagination_resp( 

263 message="Profile's meta application data sent", 

264 content=meta_data, 

265 page=page, 

266 total_pages=total_pages 

267 ) 

268 

269 except Exception as error: 

270 current_app.logger.error(error) 

271 return internal_err_resp() 

272 

273 @staticmethod 

274 def get_profile_meta_book(profile_uuid, connected_user_uuid, page): 

275 """ Get profile meta book """ 

276 

277 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

278 return err_resp("User not found!", 404) 

279 

280 # Check permissions 

281 permissions = get_jwt_claims()['permissions'] 

282 if "access_sandbox" not in permissions: 

283 return err_resp("Permission missing", 403) 

284 

285 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

286 return err_resp("Profile not found!", 404) 

287 

288 metas, total_pages = Paginator.get_from( 

289 db.session.query(MetaProfileContentModel, BookModel) 

290 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

291 .join(BookModel, BookModel.content_id == ContentModel.content_id) 

292 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

293 page, 

294 ) 

295 

296 try: 

297 def c_load(row): 

298 row[0].book = row[1] 

299 return row[0] 

300 

301 metas = list(map(c_load, metas)) 

302 meta_data = MetaProfileBookItem.loads(metas) 

303 

304 return pagination_resp( 

305 message="Profile's meta book data sent", 

306 content=meta_data, 

307 page=page, 

308 total_pages=total_pages 

309 ) 

310 

311 except Exception as error: 

312 current_app.logger.error(error) 

313 return internal_err_resp() 

314 

315 @staticmethod 

316 def get_profile_meta_game(profile_uuid, connected_user_uuid, page): 

317 """ Get profile meta game """ 

318 

319 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

320 return err_resp("User not found!", 404) 

321 

322 # Check permissions 

323 permissions = get_jwt_claims()['permissions'] 

324 if "access_sandbox" not in permissions: 

325 return err_resp("Permission missing", 403) 

326 

327 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

328 return err_resp("Profile not found!", 404) 

329 

330 metas, total_pages = Paginator.get_from( 

331 db.session.query(MetaProfileContentModel, GameModel) 

332 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

333 .join(GameModel, GameModel.content_id == ContentModel.content_id) 

334 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

335 page, 

336 ) 

337 

338 try: 

339 def c_load(row): 

340 row[0].game = row[1] 

341 return row[0] 

342 

343 metas = list(map(c_load, metas)) 

344 meta_data = MetaProfileGameItem.loads(metas) 

345 

346 return pagination_resp( 

347 message="Profile's meta game data sent", 

348 content=meta_data, 

349 page=page, 

350 total_pages=total_pages 

351 ) 

352 

353 except Exception as error: 

354 current_app.logger.error(error) 

355 return internal_err_resp() 

356 

357 @staticmethod 

358 def get_profile_meta_movie(profile_uuid, connected_user_uuid, page): 

359 """ Get profile meta movie """ 

360 

361 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

362 return err_resp("User not found!", 404) 

363 

364 # Check permissions 

365 permissions = get_jwt_claims()['permissions'] 

366 if "access_sandbox" not in permissions: 

367 return err_resp("Permission missing", 403) 

368 

369 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

370 return err_resp("Profile not found!", 404) 

371 

372 metas, total_pages = Paginator.get_from( 

373 db.session.query(MetaProfileContentModel, MovieModel) 

374 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

375 .join(MovieModel, MovieModel.content_id == ContentModel.content_id) 

376 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

377 page, 

378 ) 

379 

380 try: 

381 def c_load(row): 

382 row[0].movie = row[1] 

383 return row[0] 

384 

385 metas = list(map(c_load, metas)) 

386 meta_data = MetaProfileMovieItem.loads(metas) 

387 

388 return pagination_resp( 

389 message="Profile's meta movie data sent", 

390 content=meta_data, 

391 page=page, 

392 total_pages=total_pages 

393 ) 

394 

395 except Exception as error: 

396 current_app.logger.error(error) 

397 return internal_err_resp() 

398 

399 @staticmethod 

400 def get_profile_meta_serie(profile_uuid, connected_user_uuid, page): 

401 """ Get profile meta serie """ 

402 

403 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

404 return err_resp("User not found!", 404) 

405 

406 # Check permissions 

407 permissions = get_jwt_claims()['permissions'] 

408 if "access_sandbox" not in permissions: 

409 return err_resp("Permission missing", 403) 

410 

411 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

412 return err_resp("Profile not found!", 404) 

413 

414 metas, total_pages = Paginator.get_from( 

415 db.session.query(MetaProfileContentModel, SerieModel) 

416 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

417 .join(SerieModel, SerieModel.content_id == ContentModel.content_id) 

418 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

419 page, 

420 ) 

421 

422 try: 

423 def c_load(row): 

424 row[0].serie = row[1] 

425 return row[0] 

426 

427 metas = list(map(c_load, metas)) 

428 meta_data = MetaProfileSerieItem.loads(metas) 

429 

430 return pagination_resp( 

431 message="Profile's meta serie data sent", 

432 content=meta_data, 

433 page=page, 

434 total_pages=total_pages 

435 ) 

436 

437 except Exception as error: 

438 current_app.logger.error(error) 

439 return internal_err_resp() 

440 

441 @staticmethod 

442 def get_profile_meta_track(profile_uuid, connected_user_uuid, page): 

443 """ Get profile meta track """ 

444 

445 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

446 return err_resp("User not found!", 404) 

447 

448 # Check permissions 

449 permissions = get_jwt_claims()['permissions'] 

450 if "access_sandbox" not in permissions: 

451 return err_resp("Permission missing", 403) 

452 

453 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

454 return err_resp("Profile not found!", 404) 

455 

456 metas, total_pages = Paginator.get_from( 

457 db.session.query(MetaProfileContentModel, TrackModel) 

458 .join(ContentModel, MetaProfileContentModel.content_id == ContentModel.content_id) 

459 .join(TrackModel, TrackModel.content_id == ContentModel.content_id) 

460 .filter(MetaProfileContentModel.profile_id == profile.profile_id), 

461 page, 

462 ) 

463 

464 try: 

465 def c_load(row): 

466 row[0].track = row[1] 

467 return row[0] 

468 

469 metas = list(map(c_load, metas)) 

470 meta_data = MetaProfileTrackItem.loads(metas) 

471 

472 return pagination_resp( 

473 message="Profile's meta track data sent", 

474 content=meta_data, 

475 page=page, 

476 total_pages=total_pages 

477 ) 

478 

479 except Exception as error: 

480 current_app.logger.error(error) 

481 return internal_err_resp() 

482 

483 @staticmethod 

484 def update_meta(profile_uuid, content_id, connected_user_uuid, data): 

485 """ Update metadata between a profile and a content """ 

486 

487 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

488 return err_resp("User not found!", 404) 

489 

490 if not (content := ContentModel.query.filter_by(content_id=content_id).first()): 

491 return err_resp("Content not found!", 404) 

492 

493 # Check permissions 

494 permissions = get_jwt_claims()['permissions'] 

495 if "access_sandbox" not in permissions: 

496 return err_resp("Permission missing", 403) 

497 

498 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

499 return err_resp("Profile not found!", 404) 

500 

501 try: 

502 if not (meta_profile_content := MetaProfileContentModel.query.filter_by(profile_id=profile.profile_id, content_id=content_id).first()): 

503 meta_profile_content = MetaProfileContentModel( 

504 content_id=content_id, profile_id=profile.profile_id) 

505 

506 meta_profile_content.rating = data["rating"] 

507 meta_profile_content.last_rating_date = data["last_rating_date"] 

508 meta_profile_content.review_see_count = data["review_see_count"] 

509 meta_profile_content.last_review_see_date = data["last_review_see_date"] 

510 meta_profile_content.count = data["count"] 

511 meta_profile_content.last_count_increment = data["last_count_increment"] 

512 

513 db.session.add(meta_profile_content) 

514 db.session.commit() 

515 

516 resp = message(True, "Meta successfully updated") 

517 return resp, 201 

518 

519 except Exception as error: 

520 current_app.logger.error(error) 

521 return internal_err_resp() 

522 

523 @staticmethod 

524 def launch_recommendation(profile_uuid, current_user): 

525 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=current_user.user_id).first()): 

526 return err_resp("Profile not found!", 404) 

527 

528 try: 

529 evt = RecommendationLaunchedForProfileEvent( 

530 profile_id=profile.profile_id, 

531 liked_genres=list( 

532 map( 

533 lambda x: RecoLaunchedLikedGenreModel( 

534 genre_id=x.genre_id, 

535 name=x.name, 

536 content_type=x.content_type, 

537 ), 

538 profile.liked_genres 

539 ) 

540 ), 

541 meta=list( 

542 map( 

543 lambda x: RecoMetaModel( 

544 content_id=x.content_id, 

545 rating=x.rating, 

546 last_rating_date=x.last_rating_date, 

547 review_see_count=x.review_see_count, 

548 last_review_see_date=x.last_review_see_date, 

549 count=x.count, 

550 last_count_increment=x.last_count_increment, 

551 ), 

552 profile.meta_profile_contents 

553 ) 

554 ) 

555 ) 

556 

557 db.session.add(evt) 

558 db.session.commit() 

559 

560 # Send request to reco_engine 

561 res = requests.put('%s/recommend/profile/%s/%s' % (ENGINE_URL, profile.uuid, evt.id), 

562 headers={'X-API-TOKEN': ENGINE_APIKEY}) 

563 

564 if res.status_code == 500: 

565 # TODO delete event ? 

566 pass 

567 

568 return res.json(), res.status_code, profile 

569 

570 except Exception as error: 

571 current_app.logger.error(error) 

572 return internal_err_resp() 

573 

574 @staticmethod 

575 def get_reco_history(profile_uuid, connected_user_uuid, page): 

576 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

577 return err_resp("User not found!", 404) 

578 

579 # Check permissions 

580 permissions = get_jwt_claims()['permissions'] 

581 if "access_sandbox" not in permissions: 

582 return err_resp("Permission missing", 403) 

583 

584 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

585 return err_resp("Profile not found!", 404) 

586 

587 reco_history, total_pages = Paginator.get_from( 

588 RecommendationLaunchedForProfileEvent.query 

589 .filter_by(profile_id=profile.profile_id) 

590 .order_by( 

591 RecommendationLaunchedForProfileEvent.occured_at.desc() 

592 ), 

593 page, 

594 ) 

595 

596 try: 

597 reco_history_data = RecommendationLaunchedForProfileBase.loads( 

598 reco_history) 

599 

600 return pagination_resp( 

601 message="Recommendation history data sent", 

602 content=reco_history_data, 

603 page=page, 

604 total_pages=total_pages 

605 ) 

606 

607 except Exception as error: 

608 current_app.logger.error(error) 

609 return internal_err_resp() 

610 

611 @staticmethod 

612 def get_liked_genre_history(profile_uuid, evt_id, connected_user_uuid, page): 

613 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

614 return err_resp("User not found!", 404) 

615 

616 # Check permissions 

617 permissions = get_jwt_claims()['permissions'] 

618 if "access_sandbox" not in permissions: 

619 return err_resp("Permission missing", 403) 

620 

621 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

622 return err_resp("Profile not found!", 404) 

623 

624 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

625 id=evt_id).first()): 

626 return err_resp("Event not found!", 404) 

627 

628 if event.profile_id != profile.profile_id: 

629 return err_resp("Can not access to an not owned event!", 403) 

630 

631 reco_history_genres, total_pages = Paginator.get_from( 

632 RecoLaunchedLikedGenreModel.query.filter_by(event_id=evt_id), 

633 page, 

634 ) 

635 

636 try: 

637 event_data = RecoLaunchedLikedGenreItem.loads(reco_history_genres) 

638 

639 return pagination_resp( 

640 message="Recommendation history liked genres data sent", 

641 content=event_data, 

642 page=page, 

643 total_pages=total_pages 

644 ) 

645 

646 except Exception as error: 

647 current_app.logger.error(error) 

648 return internal_err_resp() 

649 

650 @staticmethod 

651 def get_app_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

652 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

653 return err_resp("User not found!", 404) 

654 

655 # Check permissions 

656 permissions = get_jwt_claims()['permissions'] 

657 if "access_sandbox" not in permissions: 

658 return err_resp("Permission missing", 403) 

659 

660 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

661 return err_resp("Profile not found!", 404) 

662 

663 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

664 id=evt_id).first()): 

665 return err_resp("Event not found!", 404) 

666 

667 if event.profile_id != profile.profile_id: 

668 return err_resp("Can not access to an not owned event!", 403) 

669 

670 reco_result_history, total_pages = Paginator.get_from( 

671 db.session.query(RecoResultModel, ApplicationModel) 

672 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

673 .join(ApplicationModel, ApplicationModel.content_id == ContentModel.content_id) 

674 .filter(RecoResultModel.event_id == evt_id) 

675 .order_by( 

676 RecoResultModel.score.desc().nullslast(), 

677 ContentModel.popularity_score.desc().nullslast(), 

678 ), 

679 page, 

680 ) 

681 

682 try: 

683 def c_load(row): 

684 row[0].application = row[1] 

685 return row[0] 

686 

687 reco_result_history = list(map(c_load, reco_result_history)) 

688 reco_result_history_data = RecoResultApplicationItem.loads( 

689 reco_result_history) 

690 

691 return pagination_resp( 

692 message="Recommendation history data sent", 

693 content=reco_result_history_data, 

694 page=page, 

695 total_pages=total_pages 

696 ) 

697 

698 except Exception as error: 

699 current_app.logger.error(error) 

700 return internal_err_resp() 

701 

702 @staticmethod 

703 def get_app_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

704 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

705 return err_resp("User not found!", 404) 

706 

707 # Check permissions 

708 permissions = get_jwt_claims()['permissions'] 

709 if "access_sandbox" not in permissions: 

710 return err_resp("Permission missing", 403) 

711 

712 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

713 return err_resp("Profile not found!", 404) 

714 

715 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

716 id=evt_id).first()): 

717 return err_resp("Event not found!", 404) 

718 

719 if event.profile_id != profile.profile_id: 

720 return err_resp("Can not access to an not owned event!", 403) 

721 

722 reco_meta_history, total_pages = Paginator.get_from( 

723 db.session.query(RecoMetaModel, ApplicationModel) 

724 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

725 .join(ApplicationModel, ApplicationModel.content_id == ContentModel.content_id) 

726 .filter(RecoMetaModel.event_id == evt_id), 

727 page, 

728 ) 

729 

730 try: 

731 def c_load(row): 

732 row[0].application = row[1] 

733 return row[0] 

734 

735 reco_meta_history = list(map(c_load, reco_meta_history)) 

736 reco_meta_history_data = RecoMetaApplicationItem.loads( 

737 reco_meta_history) 

738 

739 return pagination_resp( 

740 message="Recommendation history data sent", 

741 content=reco_meta_history_data, 

742 page=page, 

743 total_pages=total_pages 

744 ) 

745 

746 except Exception as error: 

747 current_app.logger.error(error) 

748 return internal_err_resp() 

749 

750 @staticmethod 

751 def get_book_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

752 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

753 return err_resp("User not found!", 404) 

754 

755 # Check permissions 

756 permissions = get_jwt_claims()['permissions'] 

757 if "access_sandbox" not in permissions: 

758 return err_resp("Permission missing", 403) 

759 

760 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

761 return err_resp("Profile not found!", 404) 

762 

763 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

764 id=evt_id).first()): 

765 return err_resp("Event not found!", 404) 

766 

767 if event.profile_id != profile.profile_id: 

768 return err_resp("Can not access to an not owned event!", 403) 

769 

770 reco_result_history, total_pages = Paginator.get_from( 

771 db.session.query(RecoResultModel, BookModel) 

772 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

773 .join(BookModel, BookModel.content_id == ContentModel.content_id) 

774 .filter(RecoResultModel.event_id == evt_id) 

775 .order_by( 

776 RecoResultModel.score.desc().nullslast(), 

777 ContentModel.popularity_score.desc().nullslast(), 

778 ), 

779 page, 

780 ) 

781 

782 try: 

783 def c_load(row): 

784 row[0].book = row[1] 

785 return row[0] 

786 

787 reco_result_history = list(map(c_load, reco_result_history)) 

788 reco_result_history_data = RecoResultBookItem.loads( 

789 reco_result_history) 

790 

791 return pagination_resp( 

792 message="Recommendation history data sent", 

793 content=reco_result_history_data, 

794 page=page, 

795 total_pages=total_pages 

796 ) 

797 

798 except Exception as error: 

799 current_app.logger.error(error) 

800 return internal_err_resp() 

801 

802 @staticmethod 

803 def get_book_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

804 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

805 return err_resp("User not found!", 404) 

806 

807 # Check permissions 

808 permissions = get_jwt_claims()['permissions'] 

809 if "access_sandbox" not in permissions: 

810 return err_resp("Permission missing", 403) 

811 

812 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

813 return err_resp("Profile not found!", 404) 

814 

815 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

816 id=evt_id).first()): 

817 return err_resp("Event not found!", 404) 

818 

819 if event.profile_id != profile.profile_id: 

820 return err_resp("Can not access to an not owned event!", 403) 

821 

822 reco_meta_history, total_pages = Paginator.get_from( 

823 db.session.query(RecoMetaModel, BookModel) 

824 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

825 .join(BookModel, BookModel.content_id == ContentModel.content_id) 

826 .filter(RecoMetaModel.event_id == evt_id), 

827 page, 

828 ) 

829 

830 try: 

831 def c_load(row): 

832 row[0].book = row[1] 

833 return row[0] 

834 

835 reco_meta_history = list(map(c_load, reco_meta_history)) 

836 reco_meta_history_data = RecoMetaBookItem.loads( 

837 reco_meta_history) 

838 

839 return pagination_resp( 

840 message="Recommendation history data sent", 

841 content=reco_meta_history_data, 

842 page=page, 

843 total_pages=total_pages 

844 ) 

845 

846 except Exception as error: 

847 current_app.logger.error(error) 

848 return internal_err_resp() 

849 

850 @staticmethod 

851 def get_game_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

852 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

853 return err_resp("User not found!", 404) 

854 

855 # Check permissions 

856 permissions = get_jwt_claims()['permissions'] 

857 if "access_sandbox" not in permissions: 

858 return err_resp("Permission missing", 403) 

859 

860 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

861 return err_resp("Profile not found!", 404) 

862 

863 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

864 id=evt_id).first()): 

865 return err_resp("Event not found!", 404) 

866 

867 if event.profile_id != profile.profile_id: 

868 return err_resp("Can not access to an not owned event!", 403) 

869 

870 reco_result_history, total_pages = Paginator.get_from( 

871 db.session.query(RecoResultModel, GameModel) 

872 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

873 .join(GameModel, GameModel.content_id == ContentModel.content_id) 

874 .filter(RecoResultModel.event_id == evt_id) 

875 .order_by( 

876 RecoResultModel.score.desc().nullslast(), 

877 ContentModel.popularity_score.desc().nullslast(), 

878 ), 

879 page, 

880 ) 

881 

882 try: 

883 def c_load(row): 

884 row[0].game = row[1] 

885 return row[0] 

886 

887 reco_result_history = list(map(c_load, reco_result_history)) 

888 reco_result_history_data = RecoResultGameItem.loads( 

889 reco_result_history) 

890 

891 return pagination_resp( 

892 message="Recommendation history data sent", 

893 content=reco_result_history_data, 

894 page=page, 

895 total_pages=total_pages 

896 ) 

897 

898 except Exception as error: 

899 current_app.logger.error(error) 

900 return internal_err_resp() 

901 

902 @staticmethod 

903 def get_game_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

904 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

905 return err_resp("User not found!", 404) 

906 

907 # Check permissions 

908 permissions = get_jwt_claims()['permissions'] 

909 if "access_sandbox" not in permissions: 

910 return err_resp("Permission missing", 403) 

911 

912 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

913 return err_resp("Profile not found!", 404) 

914 

915 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

916 id=evt_id).first()): 

917 return err_resp("Event not found!", 404) 

918 

919 if event.profile_id != profile.profile_id: 

920 return err_resp("Can not access to an not owned event!", 403) 

921 

922 reco_meta_history, total_pages = Paginator.get_from( 

923 db.session.query(RecoMetaModel, GameModel) 

924 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

925 .join(GameModel, GameModel.content_id == ContentModel.content_id) 

926 .filter(RecoMetaModel.event_id == evt_id), 

927 page, 

928 ) 

929 

930 try: 

931 def c_load(row): 

932 row[0].game = row[1] 

933 return row[0] 

934 

935 reco_meta_history = list(map(c_load, reco_meta_history)) 

936 reco_meta_history_data = RecoMetaGameItem.loads( 

937 reco_meta_history) 

938 

939 return pagination_resp( 

940 message="Recommendation history data sent", 

941 content=reco_meta_history_data, 

942 page=page, 

943 total_pages=total_pages 

944 ) 

945 

946 except Exception as error: 

947 current_app.logger.error(error) 

948 return internal_err_resp() 

949 

950 @staticmethod 

951 def get_movie_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

952 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

953 return err_resp("User not found!", 404) 

954 

955 # Check permissions 

956 permissions = get_jwt_claims()['permissions'] 

957 if "access_sandbox" not in permissions: 

958 return err_resp("Permission missing", 403) 

959 

960 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

961 return err_resp("Profile not found!", 404) 

962 

963 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

964 id=evt_id).first()): 

965 return err_resp("Event not found!", 404) 

966 

967 if event.profile_id != profile.profile_id: 

968 return err_resp("Can not access to an not owned event!", 403) 

969 

970 reco_result_history, total_pages = Paginator.get_from( 

971 db.session.query(RecoResultModel, MovieModel) 

972 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

973 .join(MovieModel, MovieModel.content_id == ContentModel.content_id) 

974 .filter(RecoResultModel.event_id == evt_id) 

975 .order_by( 

976 RecoResultModel.score.desc().nullslast(), 

977 ContentModel.popularity_score.desc().nullslast(), 

978 ), 

979 page, 

980 ) 

981 

982 try: 

983 event_data = RecommendationLaunchedForProfileItem.load(event) 

984 

985 def c_load(row): 

986 row[0].movie = row[1] 

987 return row[0] 

988 

989 reco_result_history = list(map(c_load, reco_result_history)) 

990 reco_result_history_data = RecoResultMovieItem.loads( 

991 reco_result_history) 

992 

993 return pagination_resp( 

994 message="Recommendation history data sent", 

995 content=reco_result_history_data, 

996 page=page, 

997 total_pages=total_pages 

998 ) 

999 

1000 except Exception as error: 

1001 current_app.logger.error(error) 

1002 return internal_err_resp() 

1003 

1004 @staticmethod 

1005 def get_movie_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

1006 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

1007 return err_resp("User not found!", 404) 

1008 

1009 # Check permissions 

1010 permissions = get_jwt_claims()['permissions'] 

1011 if "access_sandbox" not in permissions: 

1012 return err_resp("Permission missing", 403) 

1013 

1014 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

1015 return err_resp("Profile not found!", 404) 

1016 

1017 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

1018 id=evt_id).first()): 

1019 return err_resp("Event not found!", 404) 

1020 

1021 if event.profile_id != profile.profile_id: 

1022 return err_resp("Can not access to an not owned event!", 403) 

1023 

1024 reco_meta_history, total_pages = Paginator.get_from( 

1025 db.session.query(RecoMetaModel, MovieModel) 

1026 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

1027 .join(MovieModel, MovieModel.content_id == ContentModel.content_id) 

1028 .filter(RecoMetaModel.event_id == evt_id), 

1029 page, 

1030 ) 

1031 

1032 try: 

1033 def c_load(row): 

1034 row[0].movie = row[1] 

1035 return row[0] 

1036 

1037 reco_meta_history = list(map(c_load, reco_meta_history)) 

1038 

1039 reco_meta_history_data = RecoMetaMovieItem.loads( 

1040 reco_meta_history) 

1041 

1042 return pagination_resp( 

1043 message="Recommendation history data sent", 

1044 content=reco_meta_history_data, 

1045 page=page, 

1046 total_pages=total_pages 

1047 ) 

1048 

1049 except Exception as error: 

1050 current_app.logger.error(error) 

1051 return internal_err_resp() 

1052 

1053 @staticmethod 

1054 def get_serie_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

1055 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

1056 return err_resp("User not found!", 404) 

1057 

1058 # Check permissions 

1059 permissions = get_jwt_claims()['permissions'] 

1060 if "access_sandbox" not in permissions: 

1061 return err_resp("Permission missing", 403) 

1062 

1063 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

1064 return err_resp("Profile not found!", 404) 

1065 

1066 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

1067 id=evt_id).first()): 

1068 return err_resp("Event not found!", 404) 

1069 

1070 if event.profile_id != profile.profile_id: 

1071 return err_resp("Can not access to an not owned event!", 403) 

1072 

1073 reco_result_history, total_pages = Paginator.get_from( 

1074 db.session.query(RecoResultModel, SerieModel) 

1075 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

1076 .join(SerieModel, SerieModel.content_id == ContentModel.content_id) 

1077 .filter(RecoResultModel.event_id == evt_id) 

1078 .order_by( 

1079 RecoResultModel.score.desc().nullslast(), 

1080 ContentModel.popularity_score.desc().nullslast(), 

1081 ), 

1082 page, 

1083 ) 

1084 

1085 try: 

1086 def c_load(row): 

1087 row[0].serie = row[1] 

1088 return row[0] 

1089 

1090 reco_result_history = list(map(c_load, reco_result_history)) 

1091 reco_result_history_data = RecoResultSerieItem.loads( 

1092 reco_result_history) 

1093 

1094 return pagination_resp( 

1095 message="Recommendation history data sent", 

1096 content=reco_result_history_data, 

1097 page=page, 

1098 total_pages=total_pages 

1099 ) 

1100 

1101 except Exception as error: 

1102 current_app.logger.error(error) 

1103 return internal_err_resp() 

1104 

1105 @staticmethod 

1106 def get_serie_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

1107 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

1108 return err_resp("User not found!", 404) 

1109 

1110 # Check permissions 

1111 permissions = get_jwt_claims()['permissions'] 

1112 if "access_sandbox" not in permissions: 

1113 return err_resp("Permission missing", 403) 

1114 

1115 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

1116 return err_resp("Profile not found!", 404) 

1117 

1118 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

1119 id=evt_id).first()): 

1120 return err_resp("Event not found!", 404) 

1121 

1122 if event.profile_id != profile.profile_id: 

1123 return err_resp("Can not access to an not owned event!", 403) 

1124 

1125 reco_meta_history, total_pages = Paginator.get_from( 

1126 db.session.query(RecoMetaModel, SerieModel) 

1127 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

1128 .join(SerieModel, SerieModel.content_id == ContentModel.content_id) 

1129 .filter(RecoMetaModel.event_id == evt_id), 

1130 page, 

1131 ) 

1132 

1133 try: 

1134 def c_load(row): 

1135 row[0].serie = row[1] 

1136 return row[0] 

1137 

1138 reco_meta_history = list(map(c_load, reco_meta_history)) 

1139 reco_meta_history_data = RecoMetaSerieItem.loads( 

1140 reco_meta_history) 

1141 

1142 return pagination_resp( 

1143 message="Recommendation history data sent", 

1144 content=reco_meta_history_data, 

1145 page=page, 

1146 total_pages=total_pages 

1147 ) 

1148 

1149 except Exception as error: 

1150 current_app.logger.error(error) 

1151 return internal_err_resp() 

1152 

1153 @staticmethod 

1154 def get_track_reco_result_history(profile_uuid, evt_id, connected_user_uuid, page): 

1155 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

1156 return err_resp("User not found!", 404) 

1157 

1158 # Check permissions 

1159 permissions = get_jwt_claims()['permissions'] 

1160 if "access_sandbox" not in permissions: 

1161 return err_resp("Permission missing", 403) 

1162 

1163 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

1164 return err_resp("Profile not found!", 404) 

1165 

1166 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

1167 id=evt_id).first()): 

1168 return err_resp("Event not found!", 404) 

1169 

1170 if event.profile_id != profile.profile_id: 

1171 return err_resp("Can not access to an not owned event!", 403) 

1172 

1173 reco_result_history, total_pages = Paginator.get_from( 

1174 db.session.query(RecoResultModel, TrackModel) 

1175 .join(ContentModel, RecoResultModel.content_id == ContentModel.content_id) 

1176 .join(TrackModel, TrackModel.content_id == ContentModel.content_id) 

1177 .filter(RecoResultModel.event_id == evt_id) 

1178 .order_by( 

1179 RecoResultModel.score.desc().nullslast(), 

1180 ContentModel.popularity_score.desc().nullslast(), 

1181 ), 

1182 page, 

1183 ) 

1184 

1185 try: 

1186 def c_load(row): 

1187 row[0].track = row[1] 

1188 return row[0] 

1189 

1190 reco_result_history = list(map(c_load, reco_result_history)) 

1191 reco_result_history_data = RecoResultTrackItem.loads( 

1192 reco_result_history) 

1193 

1194 return pagination_resp( 

1195 message="Recommendation history data sent", 

1196 content=reco_result_history_data, 

1197 page=page, 

1198 total_pages=total_pages 

1199 ) 

1200 

1201 except Exception as error: 

1202 current_app.logger.error(error) 

1203 return internal_err_resp() 

1204 

1205 @staticmethod 

1206 def get_track_reco_meta_history(profile_uuid, evt_id, connected_user_uuid, page): 

1207 if not (user := UserModel.query.filter_by(uuid=connected_user_uuid).first()): 

1208 return err_resp("User not found!", 404) 

1209 

1210 # Check permissions 

1211 permissions = get_jwt_claims()['permissions'] 

1212 if "access_sandbox" not in permissions: 

1213 return err_resp("Permission missing", 403) 

1214 

1215 if not (profile := ProfileModel.query.filter_by(uuid=profile_uuid, user_id=user.user_id).first()): 

1216 return err_resp("Profile not found!", 404) 

1217 

1218 if not (event := RecommendationLaunchedForProfileEvent.query.filter_by( 

1219 id=evt_id).first()): 

1220 return err_resp("Event not found!", 404) 

1221 

1222 if event.profile_id != profile.profile_id: 

1223 return err_resp("Can not access to an not owned event!", 403) 

1224 

1225 reco_meta_history, total_pages = Paginator.get_from( 

1226 db.session.query(RecoMetaModel, TrackModel) 

1227 .join(ContentModel, RecoMetaModel.content_id == ContentModel.content_id) 

1228 .join(TrackModel, TrackModel.content_id == ContentModel.content_id) 

1229 .filter(RecoMetaModel.event_id == evt_id), 

1230 page, 

1231 ) 

1232 

1233 try: 

1234 def c_load(row): 

1235 row[0].track = row[1] 

1236 return row[0] 

1237 

1238 reco_meta_history = list(map(c_load, reco_meta_history)) 

1239 reco_meta_history_data = RecoMetaTrackItem.loads( 

1240 reco_meta_history) 

1241 

1242 return pagination_resp( 

1243 message="Recommendation history data sent", 

1244 content=reco_meta_history_data, 

1245 page=page, 

1246 total_pages=total_pages 

1247 ) 

1248 

1249 except Exception as error: 

1250 current_app.logger.error(error) 

1251 return internal_err_resp()