def get_queryset(self):
data = Project.objects.all()
form = SearchForm(data=self.request.GET)
if form.is_valid():
search = form.cleaned_data['search']
if search:
data = data.filter(
Q(name__icontains=search)
| Q(description__icontains=search))
return data.order_by('-date_start')
def get_queryset(self):
data = Tasks.objects.all()
form = SearchForm(data=self.request.GET)
if form.is_valid():
search = form.cleaned_data['search']
if search:
data = data.filter(
Q(summary__icontains=search)
| Q(description__icontains=search))
return data.order_by('-task_create')
def book_search_view(request, *args, **kwargs):
form = SearchForm(data=request.GET)
if form.is_valid():
text = form.cleaned_data['search']
if len(text) > 0:
books = Books.objects.filter(name_author__contains=text, status="active").order_by("-created_at")
print(text)
print(books)
return render(request, 'index.html', context={'books': books})
else:
return redirect('index')
return redirect('index')
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data(**kwargs)
nom_nom = self.get_object()
form = SearchForm(data=self.request.GET)
data = Coin.objects.filter(Q(currency__pk=nom_nom.currency.pk) & Q(nominal=nom_nom.nominal))
if form.is_valid():
search = form.cleaned_data['search']
if search:
data = data.filter(Q(year_of_issue__icontains=search))
kwargs['search'] = search
context['form'] = form
context['coins'] = data.order_by('year_of_issue')
return context
def musicians_list_view(request):
musicians = Musician.objects.filter(position__gt=0)
form = SearchForm(request.GET)
if form.is_valid():
search_query = form.cleaned_data['search']
if search_query:
musicians = musicians.filter(author__icontains=search_query)
musicians = musicians.order_by('position', 'author')
return render(request,
'musicians_list.html',
context={
'musicians': musicians,
'form': form
})
def index_view(request, *args, **kwargs):
if request.method == 'GET':
form = SearchForm()
if request.GET:
r = request.GET.get('query')
records = Record.objects.order_by('-created_at').filter(
author__contains=r, status='active')
else:
records = Record.objects.order_by('-created_at').filter(
status='active')
return render(request,
'index.html',
context={
'records': records,
'form': form
})
def index():
form = SearchForm()
if form.validate_on_submit():
method = form.methods.data
content = form.content.data
if method == 1:
return redirect(
url_for('result.result_title', content=content, page=1))
elif method == 2:
return redirect(
url_for('result.result_author', content=content, page=1))
elif method == 3:
return redirect(url_for('result.result_ISBN', content=content))
else:
return None
return render_template('index.html', form=form)
def get_context_data(self, *, object_list=None, **kwargs):
form = SearchForm(data=self.request.GET)
user = User.objects.get(pk=self.request.user.pk)
collection_coins = Coin_in_Collection.objects.filter(owner=user)
offers = []
for coin in collection_coins:
if coin.offers:
for offer in coin.offers.all():
offers.append(offer)
if form.is_valid():
search = form.cleaned_data['search']
kwargs['search'] = search
kwargs['form'] = form
kwargs['offers'] = offers
kwargs['user'] = user
return super().get_context_data(object_list=object_list, **kwargs)
def index():
search = SearchForm()
if search.validate_on_submit():
sent = str(search.search.data)
word_list = sent.split()
results = []
for x in word_list:
places = retrievePlaces(x)
if places is not None:
for place in places:
results.append(place)
return render_template('results.html',
results=results,
name=search.search.data)
return render_template('index.html',
form=search,
current_user=current_user)
def get_search_form(self):
return SearchForm(self.request.GET)
def index_view(request):
notes = Note.objects.all().filter(
status=DEFAULT_STATUS).order_by('-created_at')
search_form = SearchForm()
context = {'notes': notes, 'search_form': search_form}
return render(request, 'index.html', context)
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super(IndexViewProject, self).get(request, **kwargs)
def search_query(request, query, page_number=1):
#Nous allons dans cette fonction lancer les méthodes pour obtenir les résultats
#de la recherche d'un utilisateur pour pouvoir les afficher selon le nombre de pages
form = SearchForm()
page = page_number
previous_page = page - 1
next_page = page + 1
envoi = True
try:
#Création des threads :
# 1) Trouver les séries liés à la recheche
# 2) Trouver le nombre total de résultats de la recherche
# 3) Trouver le nombre de pages de la recherche
respT = SearchThread(Search.get_serie_by_name_with_space, query,
page)
number_resultsT = SearchThread(Search.get_number_of_result, query,
page)
number_pagesT = SearchThread(Search.get_number_of_pages, query,
page)
#Lancement des threads
respT.start()
number_resultsT.start()
number_pagesT.start()
#Attente jusqu'à la fin de l'exécution de tous les threads
respT.join()
number_resultsT.join()
number_pagesT.join()
#Récupération des résultats des threads
resp = respT.result()
number_results = number_resultsT.result()
number_pages = number_pagesT.result()
#Si il y a une erreur dans la recherche : exception, on renvoie la page d'erreur
except:
error_message = "The search did not succeed."
return render(request, 'webapp/error.html', locals())
#Gestion des favoris: idem
try:
this_user = request.user.profil
if this_user.favorites == '[]':
dict_soon = {}
dict_now = {}
else:
dict_soon = {}
dict_now = {}
for item in this_user.favorites[1:-1].split(','):
item = int(item)
this_serie = Serie.objects.get(id=item)
if this_serie.alert < 4 and this_serie.alert > 1:
dict_soon[item] = this_serie
elif this_serie.alert < 2:
dict_now[item] = this_serie
except:
dict_soon = {}
dict_now = {}
nb_soon = len(dict_soon)
nb_now = len(dict_now)
nb_total = nb_soon + nb_now
#On redirige les éléments calculés vers le modèle html qui va l'afficher (cf code HTML)
return render(request, 'webapp/search_result.html', locals())
def search(request):
#On s'assure de la validité de la recherche entrée sinon on renvoie le formulaire de recherche
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
query = form.cleaned_data.get('query')
envoi = True
return redirect('/search/' + query + '/1')
else:
form = SearchForm()
#Mise à jour des séries favorites
#Tout d'abord nous récupérons le profil de l'utilisateur avec this_user
this_user = request.user.profil
#S'il n'a pas de séries favorites rien n'est mis à jour
if this_user.favorites == '[]':
dict_series = {}
#Sinon nous traitons à la fois la mise à jour des informations sur ses séries favorites et les notifications
else:
#Nous récupérons au bon format (nombre) les ids des séries favorites de l'utilisateur
favorite_seriesid = [
int(item) for item in this_user.favorites[1:-1].split(',')
]
#Nous créons une liste qui va contenir nos threads lancés pour chaque ids
threads = []
#Pour chaque ids, nous créons un thread qui va récupérer les informations de l'épisode avec un appel à l'API
#Puis nous lançons le thread et l'enregistrons dans threads
for ids in favorite_seriesid:
update_serie = SearchThread(Search.get_attributes_for_serie,
ids)
update_serie.start()
threads.append(update_serie)
#Nous attendons que tous les threads se soient exécutés
for thread in threads:
thread.join()
#Nous récupérons tous les résultats des threads dans dict_séries qui contient toutes les informations actualisées des séries favorites de l'utilisateur
dict_series = [thread.result() for thread in threads]
#Nous actualisons ensuite notre base de donnée en faisant appel à update_serie
for el in dict_series:
if el != None:
this_serie = Serie.objects.get(id=el['id'])
this_serie = this_serie.update_serie(
el['nb_episodes'], el['nb_seasons'],
el['last_episode_date'], el['last_episode'],
el['next_episode_date'], el['next_episode'],
el['seasons'], el['video'], el['alert'])
this_serie.save()
#Gestion des notifications: idem
try:
dict_soon = {}
dict_now = {}
for item in favorite_seriesid:
this_serie = Serie.objects.get(id=item)
if this_serie.alert < 4 and this_serie.alert > 1:
dict_soon[item] = this_serie
elif this_serie.alert < 2:
dict_now[item] = this_serie
except:
dict_soon = {}
dict_now = {}
nb_soon = len(dict_soon)
nb_now = len(dict_now)
nb_total = nb_soon + nb_now
#On redirige les éléments calculés vers le modèle html qui va l'afficher (cf code HTML)
return render(request, 'webapp/search_result.html', locals())
def book_view(request, *args, **kwargs):
guest_book = GuestBook.objects.filter(
status='active').order_by('-date_of_creation')
form = SearchForm()
context = {'guest_book': guest_book, 'form': form}
return render(request, 'index.html', context)
def get(self, request, **kwargs):
self.search_form = SearchForm(request.GET)
self.search_value = self.get_search_value()
return super().get(request, kwargs)
def main():
form = SearchForm()
if form.validate_on_submit():
return render_template('index.html', page_title="Good", form=form)
return render_template('index.html', page_title="Форму обошли", form=form)
def search_form(request):
form = SearchForm(request.GET)
return {'search_form': form}
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super().get(request, **kwargs)
def before_request():
g.search_form = SearchForm()
g.tags = Tag.query.limit(20).all()
g.is_login = hasattr(current_user, 'id') # 是否登录