class ProjectView(ListView):
template_name = 'project/project.html'
model = Project
context_object_name = 'projects'
ordering = ('name', '-started_at')
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super(ProjectView, self).get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(
Q(name__icontains=self.search_data)
| Q(description__icontains=self.search_data))
return queryset
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['search_form'] = self.form
if self.search_data:
context['query'] = urlencode({'search_value': self.search_data})
return context
class ProductListView(ListView):
template_name = 'products/product-list.html'
paginate_by = 7
paginate_orphans = 2
model = Product
context_object_name = 'products'
ordering = ('category', 'name')
def get(self, request, **kwargs):
self.search_form = SearchForm(request.GET)
self.search_value = self.get_search_value()
return super().get(request, kwargs)
def get_search_value(self):
if self.search_form.is_valid():
return self.search_form.cleaned_data['search_value']
return None
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data()
context['search_form'] = self.search_form
if self.search_value:
context['query'] = urlencode({'search_value': self.search_value})
return context
def get_queryset(self):
queryset = super().get_queryset()
if self.search_value:
queryset = queryset.filter(
Q(name__icontains=self.search_value)
| Q(description__icontains=self.search_value))
return queryset.exclude(remainder=0)
class IndexView(ListView):
template_name = 'products/index.html'
model = Product
context_object_name = 'products'
paginate_by = 5
paginate_orphans = 1
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super(IndexView, self).get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(
Q(name__icontains=self.search_data) |
Q(category__icontains=self.search_data)
)
return queryset
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['search_form'] = self.form
if self.search_data:
context['query'] = urlencode({'search_value': self.search_data})
return context
class IndexView(ListView):
template_name = 'tasks/index.html'
model = List
context_object_name = 'lists'
ordering = ('-created_at', 'summary')
paginate_by = 5
paginate_orphans = 2
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super(IndexView, self).get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(
Q(summary__icontains=self.search_data)
| Q(description__icontains=self.search_data))
return queryset
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
kwargs = super().get_context_data(**kwargs)
kwargs['search_form'] = self.form
if self.search_data:
kwargs['query'] = urlencode({'search_value': self.search_data})
return kwargs
def searchStock(request):
auth = request.COOKIES.get('auth')
if not auth:
return render(request, 'error.html', {'error': 'Invalid authentication'})
if(request.method == 'POST'):
form = SearchForm(request.POST)
if(form.is_valid()):
query = form.cleaned_data.get('query')
post_data = {}
post_data['query'] = query
post_encoded = urllib.parse.urlencode(post_data).encode('utf-8')
req = urllib.request.Request(
"http://exp-api:8000/exp/stock/search", data=post_encoded, method='POST')
resp_json = urllib.request.urlopen(req).read().decode('utf-8')
resp = json.loads(resp_json)
if(len(resp['hits']['hits']) == 0):
return render(request, 'search_results.html', {'error': "No matches found"})
else:
res = []
for ele in resp['hits']['hits']:
res.append(ele['_source'])
return render(request, 'search_results.html', {'output': res})
else:
form = SearchForm()
return render(request, 'search_stock.html', {'form': form})
def get_context_data(self, *, object_list=None, **kwargs):
form = SearchForm(data=self.request.GET)
if form.is_valid():
search = form.cleaned_data['search']
kwargs['search'] = search
kwargs['form'] = form
return super().get_context_data(object_list=object_list, **kwargs)
class IndexView(ListView):
template_name = 'lists/index.html'
model = List
context_object_name = 'lists'
ordering = ('name', '-created_at')
paginate_by = 8
paginate_orphans = 0
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super().get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(Q(name__icontains=self.search_data))
return queryset
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['search_form'] = self.form
if self.search_data:
context['query'] = urlencode({'search_value': self.search_data})
return context
def get_queryset(self):
data = User.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
def get_queryset(self, **kwargs):
data = Country.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))
return data
def products_list_view(request):
products = Product.objects.filter(amount__gt=0)
form = SearchForm(request.GET)
if form.is_valid():
search_query = form.cleaned_data['search']
if search_query:
products = products.filter(name__icontains=search_query)
products = products.order_by('category', 'name')
return render(request, 'products_list.html', context={'products': products, 'form': form})
def book_search(request):
form = SearchForm(data=request.GET)
if form.is_valid():
search = form.cleaned_data['search']
books = Book.objects.filter(author__contains=search).exclude(
status='blocked').order_by('-created_at')
return render(request, 'search.html', context={'books': books})
else:
return redirect('book_index')
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_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 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 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)
class ProductByCategory(ListView):
template_name = 'products/by_category.html'
model = Product
context_object_name = 'products_by_category'
ordering = ('name')
paginate_by = 5
paginate_orphans = 2
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super().get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(
Q(name__icontains=self.search_data) |
Q(description__icontains=self.search_data)
)
return queryset.exclude(balance=0).filter(
category__name=self.kwargs.get(
'selected_category'))
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['form'] = self.form
if self.search_data:
context['query'] = urlencode({'search_value': self.search_data})
return context
class IndexView(ListView):
template_name = 'products/index.html'
model = Product
context_object_name = 'products'
ordering = ('category', 'name')
paginate_by = 5
paginate_orphans = 2
def get(self, request, **kwargs):
self.form = SearchForm(request.GET)
self.search_data = self.get_search_data()
return super(IndexView, self).get(request, **kwargs)
def get_queryset(self):
queryset = super().get_queryset()
if self.search_data:
queryset = queryset.filter(
Q(name__icontains=self.search_data) |
Q(description__icontains=self.search_data)
)
return queryset.exclude(balance=0)
def get_search_data(self):
if self.form.is_valid():
return self.form.cleaned_data['search_value']
return None
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['search_form'] = self.form
context['categories'] = Category.objects.all()
if self.search_data:
context['query'] = urlencode({'search_value': self.search_data})
return context
def search_result(request):
if request.method == 'GET':
return render(request,'search_result.html')
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
#get search details
departure = form.cleaned_data['departure']
arrival = form.cleaned_data['arrival']
date = form.cleaned_data['date']
# #get all trips
# trips = Trip()
# trips = Trip.objects.all()
#trips with only 1 connection
trips1 = Trip()
trips1 = Trip.objects.filter(departure_city=departure).filter(arrival_city=arrival).filter(departure_date=date)
for trip in trips1:
distance_dict = gmaps.distance_matrix(trip.departure_city,trip.arrival_city)
distance1 = distance_dict['rows'][0]['elements'][0]['distance']['value']
trip.distance = distance1/1000
trip.save
# #trips with 2 connections
# firstTripID = []
# secondTripID = []
# trips2_departure_match = {"id", "driver","departure_date", "departure_time", "departure_city",
# "arrival_city", "distance", "messages"}
# trips2_arrival_match = {"id", "driver","departure_date", "departure_time", "departure_city",
# "arrival_city", "distance", "messages"}
# trips2_departure_match = Trip.objects.filter(departure_city=departure).values
# trips2_arrival_match = Trip.objects.filter(arrival_city=arrival).values
# for tripDeparture in trips2_departure_match:
# for tripArrival in trips2_arrival_match:
# if tripDeparture["arrival_city"] == tripArrival["departure_city"]:
# firstTrip.append(tripDeparture["id"])
# secondTrip.append(tripArrival["id"])
# firstTrips = Trip()
# secondTrips = Trip()
# for i in firstTripID:
# trip1 = Trip.objects.filter(id=firstTripID[i])
# trip2 = Trip.objects.filter(id=secondTripID[i])
# firstTrips.append(trip1)
# secondTrips.append(trip2)
# # #get distance from google api
# # for trip in trips2FirstTrip:
# # distance_dict = gmaps.distance_matrix(trip.departure_city,trip.arrival_city)
# # distance1 = distance_dict['rows'][0]['elements'][0]['distance']['value']
# # trip.distance = distance1/1000
# # trip.save
# # for trip in trips2SecondTrip:
# # distance_dict = gmaps.distance_matrix(trip.departure_city,trip.arrival_city)
# # distance1 = distance_dict['rows'][0]['elements'][0]['distance']['value']
# # trip.distance = distance1/1000
# # trip.save
# #get total distance for 2 connections
# # totalDistance2 = []
# # for i in trips2SecondTrip.amount():
# # distance = trips2FirstTrip[i].distance + trips2SecondTrip[i].distance
# # totalDistance2.append(distance)
return render(request, 'search_result.html', {'trips1': trips1})
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())
