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()
