def upcomingEpisodes(): """ This function is called when the user is trying to go on his upcoming episode page We provide the different series lists divided in 3 : * The series the user is watching but is not up to date (ex : the user last saw the episode 3 of the first season while the series last episode is S4E3 > list_series_last_episode * The user is up to date with this serie and we're expecting an episode for this show > list_series_up_to_date * The user is up-to-date with the serie but we're not expecting any next episode > list_series_finished We also change the notifications to 0 :return:render_template('upcoming_episode.html') """ l_utd, l_nutd, l_fin = current_user.check_upcoming_episodes() # We fill the list with all the series info using the Api get_serie method list_up_to_date, list_not_up_to_date, list_finished = [], [], [] for s_id in l_utd: app.logger.info(msg=f'Serie {s_id} added to up to date shows') list_up_to_date.append(Api.get_media(type_media='tv', id_media=s_id)) for s_id in l_nutd: app.logger.info(msg=f'Serie {s_id} added to not up to date shows') list_not_up_to_date.append(Api.get_media(type_media='tv', id_media=s_id)) for s_id in l_fin: app.logger.info(msg=f'Serie {s_id} added to finished shows') list_finished.append(Api.get_media(type_media='tv', id_media=s_id)) current_user.notifications = bytes(0) db.session.commit() return render_template('upcoming_episodes.html', title='Upcoming Episodes', list_next_episode=list_up_to_date, list_last_episode=list_not_up_to_date, list_finished=list_finished, tv_genres=tv_genres, movie_genres=movie_genres, user=current_user)
def view_episode(self, episode, season, serie): """ Cette methode permet de modifier le dernier episode vu par un utilisateur On remplace le dernier episode vu par l'utilisateur pour la serie d'ID "serie" par l'episode "episode" de la saison "season". On va donc remplacer le code de l'episode et de la saison dans UserMedia par les bons codes Cette methode met egalement le statut de la serie a jour (utd/fin/nutd) :param episode: (int) numero de l'episode a marquer comme vu :param season: (int) numero de la saison de cet episode :param serie: (int) identifiant de la serie :return: void """ # On recupere la serie des series de l'utilisateur show = self.user_media.filter_by(media='tv', media_id=int(serie)).first() # Si la serie n'est pas dans les series de l'utilisateur, on ne fait rien if show: # On appelle l'API pour obtenir les informations de la serie s = Api.get_media(type_media='tv', id_media=str(serie)) # On update la saison et l'episode de l'utilisateur show.season_id = season show.episode_id = episode # On recupere la saison et le numero du dernier episode sorti latest_season, latest_ep = s.latest['season_number'], s.latest[ 'episode_number'] status = '' # Si le dernier episode et lepisode vu par l'utilisateur sont les memes, on regarde si il y a un # episode qui doit sortir if not self.is_after( season=latest_season, episode=latest_ep, serie=s.id): # Si il n'y a pas d'episode a venir, la serie est terminee if s.date == '': status = 'fin' else: # Sinon on change le statut de la serie a a jour (utd) status = 'utd' else: # Sinon la serie n'est pas a jour car il reste des episodes a voir, on change le statut en nutd status = 'nutd' show.state_serie = status # On met a jour les notifications self.notifications = bytes(1) db.session.commit()
def select_episode(id, season, episode): """ Fonction utilisee pour afficher l'episode {episode} de la saison {season} dans la page serie : son image et son resume :param id: int. id de la série :param season: numéro de la saison :param episode: numéro de l'épisode :return: """ serie = Api.get_media(type_media='tv', id_media=id) similar = Api.get_similar(id, 'tv') serie.selected_episode = 'S' + str(season) + 'E' + str(episode) episode = serie.get_episode app.logger.info(msg=f'Selected Episode : Serie = {id}, Season = {season}, episode = {episode.num_episode}') return render_template('serie.html', media=serie, user=current_user, episode=episode, season=episode.num_season, type_media='tv', similar=similar, tv_genres=tv_genres, movie_genres=movie_genres)
def add_media(self, id_media, type_media): """ Cette methode permet d'ajoute un media a l'utilisateur dans la table user_media Par defaut, si le media est une serie, elle commence comme non a jour (nutd) sinon, les champs specifiques a une serie sont laisses vides On met a jour les notifications de l'utilisateur :param id_media: int :return: void """ # On commence par verifier que le media n'est pas deja dans la liste des medias de l'utilisateur if not self.is_in_medias(id_media=id_media, type_media=type_media): if type_media == 'tv': # On ajoute la serie a l'utilisatur en la marquant comme nutd et on remeta jour les notifications serie_info = Api.get_media(type_media='tv', id_media=int(id_media)) last_season, last_ep = serie_info.latest[ 'season_number'], serie_info.latest['episode_number'] status = '' # Si le dernier episode vu par l'utilisateur est le dernier episode selon l'API, on regarde si il y a un # episode attendu pour savoir si l'utilisateur est a la fin de la serie if not self.is_after( season=last_season, episode=last_ep, serie=id_media): if serie_info.date == '': # On met a jour le statut de la serie en finie (fin) status = 'fin' else: status = 'utd' else: status = 'nutd' m = UserMedia(media='tv', media_id=int(id_media), season_id=1, episode_id=1, state_serie=status, user=self, media_name=serie_info.name) self.notifications = bytes(1) else: m = UserMedia(media='movie', media_id=int(id_media), user=self) # On inscrit les changements dans la base de donnees db.session.add(m) db.session.commit()
def my_media(type_media): """ Fonction appelee pour avoir la page correspondant a la liste des films ou des series ajoutes par l'utilisateur :param type_media: string. Type du média : 'tv' ou 'movie' :return: void """ list_medias = current_user.list_media(media=type_media) list_medias_rendered =[] nb_medias = 0 if not list_medias: app.logger.info(msg=f"My{type_media}s page rendered without {type_media}s") else: for m in list_medias: nb_medias += 1 media = Api.get_media(type_media=type_media, id_media=m) list_medias_rendered.append(media) app.logger.info(msg=f'My{type_media}s page rendered') app.logger.info(msg=f'The {type_media} list has {nb_medias} {type_media}s') return render_template('myMedias.html', title=f'My{type_media}', type_media=type_media, list_medias=list_medias_rendered, nb_medias=nb_medias, tv_genres=tv_genres, movie_genres=movie_genres, user=current_user)
def media(type_media, id): ''' Route pour accéder à la page des détails d'un média (série ou film) :param type_media: string. Type du média : 'tv' ou 'movie' :param id: int. Id du média :return: ''' media = Api.get_media(type_media=type_media, id_media=id) similar = Api.get_similar(id=id, media_type=type_media) if media is None: app.logger.info(msg=f'Incorrect {type_media} id') return render_template('404.html') else: app.logger.info(msg=f'Successful query for the {type_media} id={media.id} page') if type_media == 'tv': if current_user.is_in_medias(id_media=id, type_media=type_media): media.selected_episode = current_user.get_last_episode_viewed(id) episode = media.get_episode return render_template('serie.html', media=media, episode=episode, user=current_user, type_media=type_media, tv_genres=tv_genres, movie_genres=movie_genres, similar=similar) else: return render_template('movie.html', media=media, user=current_user, type_media=type_media, tv_genres=tv_genres, movie_genres=movie_genres, similar=similar)
def update_all_upcoming_episodes(self): """ Cette methode est appelee lorsque l'user se connecte sur le site Avec cette methode, on met a jour les statuts de tous les series de l'utilisateur Pour ce faire, on parcourt la liste des series de l'utilisateur et on compare le dernier episode vu par l'utilisateur avec le dernier episode de la serie selon l'API. Si l'utilisateur est au dernier, on regarde si l'API contient un episode futur On ne lance cette methode qu'a chaque connexions de l'utilisateur afin de ne pas trop appeler l'API :return: void """ # On recupere toutes les series de l'utilisateur serie = self.user_media.filter_by(media='tv').all() for s in serie: # On recupere les infos de chaque serie grace a l'API serie_info = Api.get_media(type_media='tv', id_media=s.media_id) # On recupere les infos de l'API sur le dernier episode last_season, last_ep = serie_info.latest[ 'season_number'], serie_info.latest['episode_number'] status = '' # Si le dernier episode vu par l'utilisateur est le dernier episode selon l'API, on regarde si il y a un # episode attendu pour savoir si l'utilisateur est a la fin de la serie if not self.is_after( season=last_season, episode=last_ep, serie=s.media_id): if serie_info.date == '': # On met a jour le statut de la serie en finie (fin) status = 'fin' else: status = 'utd' else: status = 'nutd' # On met a jour le statut dans la BDD s.state_serie = status db.session.commit()