272 lines
12 KiB
Python
272 lines
12 KiB
Python
from .forms import CommentiForms,SegnalazioneFilmForm,CreaFilm
|
|
from core.models import Profilo
|
|
from django.core import serializers
|
|
from django.urls.base import reverse, reverse_lazy
|
|
from django.core.exceptions import ValidationError
|
|
from django.shortcuts import render,redirect,get_object_or_404
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.forms import modelformset_factory
|
|
from django.core.paginator import Paginator
|
|
from django.views.generic.edit import DeleteView
|
|
from django.contrib import messages
|
|
from django.http import HttpResponse,JsonResponse,HttpResponseRedirect,HttpResponseBadRequest
|
|
from utils.utils import get_configuration,get_film,get_genre
|
|
from utils.download_image import get_image
|
|
from .models import GenereFilm,Film,Commento,Immagini
|
|
from SerieTV.models import SerieTV
|
|
from django.db.models import Q
|
|
from django.contrib.admin.views.decorators import staff_member_required
|
|
from itertools import chain
|
|
from django.urls import reverse
|
|
import random
|
|
|
|
def crea_film(request):
|
|
ImmaginiFormSet = modelformset_factory(Immagini,fields=('immagini',),extra=6)
|
|
if request.method == "POST":
|
|
formset = ImmaginiFormSet(request.POST or None,request.FILES or None)
|
|
form = CreaFilm(request.POST or None, request.FILES or None)
|
|
if form.is_valid() and formset.is_valid():
|
|
film = form.save()
|
|
for immages in formset:
|
|
try:
|
|
foto = Immagini(film=film,immagini=immages.cleaned_data['immagini'])
|
|
foto.save()
|
|
except Exception as e:
|
|
break
|
|
return HttpResponseRedirect(film.get_absolute_url())
|
|
else:
|
|
form = CreaFilm()
|
|
formset = ImmaginiFormSet(queryset=Immagini.objects.none())
|
|
context = {"form":form,"formset":formset}
|
|
return render(request,'add-film.html',context)
|
|
|
|
|
|
|
|
|
|
def lista_generi(request):
|
|
generi_film = GenereFilm.objects.all()
|
|
context = {"generi_film":generi_film}
|
|
return render(request,'lista_generi_film.html',context)
|
|
|
|
def film_genere(request,genere):
|
|
genere_film = get_object_or_404(GenereFilm,genere=genere)
|
|
film = Film.objects.filter(genere=genere_film)
|
|
context = {"genere":genere_film,"film":film}
|
|
return render(request,'films_genere.html',context)
|
|
|
|
|
|
def film_youmightlike(genres,film):
|
|
random_picked_genre = random.sample(genres,1)
|
|
film_same_genres = Film.objects.filter(genere__in=random_picked_genre).values("titolo")
|
|
current_film = film.titolo
|
|
film_with_same_genre = Film.objects.exclude(titolo=current_film)
|
|
number_film_with_same_genre = Film.objects.filter(genere__in=random_picked_genre).count()
|
|
# random_film_list = random.randint(1,number_film_with_same_genre)
|
|
# rand_film = random.sample(list(film_with_same_genre),min(random_film_list, len(film_with_same_genre))) # funzionamento precedente
|
|
rand_film = random.sample(list(film_with_same_genre),number_film_with_same_genre if number_film_with_same_genre < 8 else 8) # seleziona casualmente degli elementi univoci nel database
|
|
return rand_film
|
|
|
|
|
|
def countviews(film):
|
|
film.visualizzazioni += 1
|
|
return film.save()
|
|
|
|
|
|
def film_detail(request,slug):
|
|
# if 'term' in request.GET:
|
|
# termine_cerca = request.GET.get('term')
|
|
# media = chain(Film.objects.filter(Q(titolo__icontains=termine_cerca)),SerieTV.objects.filter(Q(titolo__icontains=termine_cerca)))
|
|
# # film = Film.objects.filter(titolo__icontains=termine_cerca)
|
|
# # serietv = SerieTV.objects.filter(titolo__icontains=termine_cerca)
|
|
# titles = list()
|
|
# description = list()
|
|
# img_url = list()
|
|
# for streaming_media in media:
|
|
# titles.append(streaming_media.titolo)
|
|
# description.append(streaming_media.descrizione)
|
|
# print(titles)
|
|
# print(description)
|
|
# print(img_url)
|
|
# return JsonResponse(titles,safe=False)
|
|
film = get_object_or_404(Film,slug=slug)
|
|
immagini_film = Immagini.objects.filter(film=film)
|
|
countviews(film)
|
|
commenti = Commento.objects.filter(media=film).order_by('-data_commento')
|
|
commenta = CommentiForms()
|
|
generi = film.genere.all() # Lista generi dei film per generare tramite Machine Learning (in futuro) film consigliati tramite le proprio preferenze!
|
|
is_favorite = False
|
|
watch_later = False
|
|
if request.user.is_authenticated:
|
|
profilo = get_object_or_404(Profilo,user=request.user)
|
|
preferito = film.preferito.filter(user=profilo.user)
|
|
guarda = film.guarda_dopo.filter(user=profilo.user)
|
|
if preferito.exists():
|
|
is_favorite = True
|
|
if guarda.exists():
|
|
watch_later = True
|
|
else:
|
|
is_favorite = False
|
|
watch_later = False
|
|
if request.method == "POST":
|
|
segnala_film_form = SegnalazioneFilmForm(request.POST)
|
|
if segnala_film_form.is_valid():
|
|
segnala_film_form.save(commit=False)
|
|
segnala_film_form.instance.film = film
|
|
segnala_film_form.save()
|
|
return HttpResponseRedirect(film.get_absolute_url())
|
|
else:
|
|
segnala_film_form = SegnalazioneFilmForm()
|
|
genres = list(generi)
|
|
you_migth_like = film_youmightlike(genres,film)
|
|
context = {"film":film,"commenti":commenti,"commenta":commenta,"is_favorite":is_favorite,"watch_later":watch_later,"segnala_film_form":segnala_film_form,"you_migth_like":you_migth_like,"immagini_film":immagini_film}
|
|
return render(request,'details1.html',context)
|
|
|
|
def film_list(request):
|
|
film = Film.objects.all().order_by("titolo")
|
|
generi = GenereFilm.objects.all()
|
|
paginator = Paginator(film, 100)
|
|
numero_pagina = request.GET.get('pagina')
|
|
films = paginator.get_page(numero_pagina)
|
|
context = {"films":films,"generi":generi}
|
|
return render(request,'film.html',context)
|
|
|
|
# def autocomplete(request):
|
|
# if 'terms' in request.GET:
|
|
# termine_cerca = request.GET.get('terms')
|
|
# film = Film.objects.filter(titol__icontains=termine_cerca)
|
|
# titles = list()
|
|
# for movies in film:
|
|
# titles.append(movies.titolo)
|
|
# return JsonResponse()
|
|
@staff_member_required
|
|
def cerca(request):
|
|
return render(request,"film_cerca.html")
|
|
|
|
@staff_member_required
|
|
def cerca_film(request):
|
|
if "film" in request.GET:
|
|
film = request.GET.get("film")
|
|
if len(film) == 0:
|
|
return redirect("cerca-film/")
|
|
api_key = "7aa61de81426820176ddbd64dca0485f"
|
|
endpoint = "https://api.themoviedb.org/3/search/movie?"
|
|
configuration_url = "https://api.themoviedb.org/3/configuration?"
|
|
genre_url = "https://api.themoviedb.org/3/genre/movie/list?"
|
|
try:
|
|
config_data = get_configuration(configuration_url,api_key)
|
|
genre_data = get_genre(genre_url,api_key)
|
|
nome_film,descrizione_film,generi_film,poster_image,background_image,data_uscita = get_film(endpoint,film,api_key,config_data,genre_data)
|
|
lista_generi_film = ", "
|
|
lista_generi_film = lista_generi_film.join(generi_film)
|
|
context = {"nome_film":nome_film,"descrizione_film":descrizione_film,"lista_generi_film":lista_generi_film,"poster_image":poster_image,"film_cercato":film}
|
|
return render(request,"cerca-film.html",context)
|
|
except:
|
|
nome_film = None
|
|
context = {"nome_film":nome_film}
|
|
return render(request,"cerca-film.html",context)
|
|
else:
|
|
return render(request,"cerca-film.html")
|
|
|
|
|
|
|
|
|
|
@staff_member_required
|
|
def save_film(request,titolo):
|
|
if request.method == "GET":
|
|
# titolo = request.POST.get("titolo")
|
|
print(titolo)
|
|
api_key = "7aa61de81426820176ddbd64dca0485f"
|
|
endpoint = "https://api.themoviedb.org/3/search/movie?"
|
|
configuration_url = "https://api.themoviedb.org/3/configuration?"
|
|
genre_url = "https://api.themoviedb.org/3/genre/movie/list?"
|
|
config_data = get_configuration(configuration_url,api_key)
|
|
genre_data = get_genre(genre_url,api_key)
|
|
nome_film,descrizione_film,lista_generi_film,poster_image,background_image,data_uscita = get_film(endpoint,titolo,api_key,config_data,genre_data)
|
|
immagine_background = get_image(background_image)
|
|
immagine_poster = get_image(poster_image)
|
|
film = Film()
|
|
if Film.objects.filter(titolo=nome_film).exists():
|
|
return HttpResponse("Film giá esistente Nel DB!")
|
|
else:
|
|
film.titolo = nome_film
|
|
film.descrizione = descrizione_film
|
|
film.immagine_poster = immagine_poster
|
|
film.immagine_background = immagine_background
|
|
film.data_uscita = data_uscita
|
|
film.save()
|
|
for genres in lista_generi_film:
|
|
print(genres)
|
|
if GenereFilm.objects.filter(genere=genres).exists():
|
|
genere = GenereFilm.objects.get(genere=genres)
|
|
film.genere.add(genere)
|
|
else:
|
|
GenereFilm.objects.get_or_create(genere=genres)
|
|
genere = GenereFilm.objects.get(genere=genres)
|
|
film.genere.add(genere)
|
|
# film.generi.add(genres)
|
|
return HttpResponseRedirect(film.get_absolute_url())
|
|
# return HttpResponse("Film salvato nel DB!")
|
|
# if not Film.objects.filter(titolo=titolo).exists():
|
|
# Film.objects.create(titolo=titolo)
|
|
|
|
@login_required
|
|
def aggiungiCommento(request,slug):
|
|
film = get_object_or_404(Film,slug=slug)
|
|
url = reverse('film-detail',kwargs={'slug':slug})
|
|
if request.method == 'POST':
|
|
form = CommentiForms(request.POST)
|
|
if form.is_valid():
|
|
form.save(commit=False)
|
|
form.instance.media = film
|
|
utente = request.user
|
|
profilo = Profilo.objects.get(user=utente)
|
|
form.instance.utente = profilo
|
|
if Commento.objects.filter(utente=profilo,media=film).exists():
|
|
return HttpResponseRedirect(url)
|
|
else:
|
|
form.save()
|
|
return HttpResponseRedirect(url)
|
|
else:
|
|
form = CommentiForms()
|
|
print(form.errors)
|
|
return HttpResponseRedirect(url)
|
|
|
|
|
|
def preferiti(request,slug):
|
|
film = get_object_or_404(Film,slug=slug)
|
|
user = request.user
|
|
profilo = get_object_or_404(Profilo,user=user)
|
|
preferito = film.preferito.filter(user=profilo.user)
|
|
if preferito.exists(): # Controllo se il ManyToManyField esiste filtrandolo con l'id dell'utente che esegue la richiesta
|
|
film.preferito.remove(profilo) # Se esiste rimuovo dai preferiti
|
|
messages.error(request, 'Film tolto dai preferiti correttamente!') # Mostro il messaggio
|
|
else:
|
|
film.preferito.add(profilo) # Se il ManyToManyField non esiste lo creo aggiungendo ai preferiti l'id dell'utente che esegue la richiesta
|
|
messages.success(request, 'Film aggiunto ai preferiti correttamente!') # Mostro il messaggio
|
|
return HttpResponseRedirect(film.get_absolute_url()) # Ritorno l'absolute url del film
|
|
|
|
def guarda_dopo(request,slug):
|
|
film = get_object_or_404(Film,slug=slug)
|
|
user = request.user
|
|
profilo = get_object_or_404(Profilo,user=user)
|
|
guarda_dopo = film.guarda_dopo.filter(user=profilo.user)
|
|
if guarda_dopo.exists():
|
|
film.guarda_dopo.remove(profilo)
|
|
else:
|
|
film.guarda_dopo.add(profilo)
|
|
return HttpResponseRedirect(film.get_absolute_url())
|
|
|
|
def lista_preferiti(request):
|
|
user = Profilo.objects.get(id=request.user.id)
|
|
lista_preferiti = user.preferiti.all()
|
|
watch_later = user.watch_later.all()
|
|
print(watch_later)
|
|
context = {"lista_preferiti":lista_preferiti,"watch_later":watch_later}
|
|
return render(request,"preferiti.html",context)
|
|
|
|
class DeleteComment(DeleteView):
|
|
model = Commento
|
|
|
|
def get_success_url(self):
|
|
film = self.get_object().media
|
|
return reverse_lazy('film-detail', kwargs={'slug': film.slug}) |