def home(request):
"""
The main page of Goose. Shows the search form, validate it
and redirect to "results" if it's correct.
"""
base_template = "base.html"
if request.method == "POST":
form = SearchForm(request.POST)
if form.is_valid():
form.clean()
user_latitude = form.cleaned_data["latitude"]
user_longitude = form.cleaned_data["longitude"]
calculated_address = form.cleaned_data["calculated_address"]
request.session["search_form"] = {
"user_latitude": user_latitude,
"user_longitude": user_longitude,
"user_address": calculated_address,
"radius": form.cleaned_data["radius"],
"search_preset_id": form.cleaned_data["search_preset"].id,
"no_private": form.cleaned_data["no_private"],
}
return redirect("results")
else:
form = SearchForm()
return render(request, "search/home.html", locals())
def index(request):
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
user_langs = get_user_languages_from_request(request)
if 'q' in request.REQUEST:
form = SearchForm(request.user, user_langs, request.REQUEST)
else:
form = SearchForm(request.user, user_langs)
qs = SearchQuerySet().none()
display_mode = 'all'
if form.is_valid():
qs = form.search_qs(SearchQuerySet().models(Video).load_all())
display_mode = form.cleaned_data.get('display', 'all')
if settings.HAYSTACK_SEARCH_ENGINE == 'dummy' and settings.DEBUG:
q = request.REQUEST.get('q', '')
qs = Video.objects.filter(title__icontains=q)
context = {
'query': request.REQUEST.get('q', ''),
'form': form,
'display_mode': display_mode
}
return object_list(request,
queryset=qs,
paginate_by=20,
template_name='search/index.html',
template_object_name='result',
extra_context=context)
def search(request):
result = []
if 'TOKEN' in request.COOKIES:
token = request.COOKIES['TOKEN']
else:
token = ""
link['token'] = token
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
category = form.cleaned_data['category']
search_keyword = form.cleaned_data['search_keyword']
if category:
result = search_category(category, search_keyword)
return render(request, 'search/index.html', {
'result': result,
'link': link
})
else:
form = SearchForm()
return render(request, 'search/index.html', {'link': link})
def search(self, rdata, user, testing=False):
sqs = SearchQuerySet().result_class(VideoSearchResult) \
.models(Video)
q = rdata.get('q')
if q:
sqs = SearchForm.apply_query(q, sqs)
form = SearchForm(rdata, sqs=sqs)
else:
form = SearchForm(rdata)
if form.is_valid():
qs = form.search_qs(sqs)
else:
qs = SearchQuerySet().none()
#result = [item.object for item in qs]
#qs1 = Video.objects.filter(title__contains=rdata['q'])
#for o in qs1:
# if not o in result:
# print o.title
display_views = form.get_display_views()
output = render_page(rdata.get('page', 1),
qs,
20,
display_views=display_views)
output['sidebar'] = render_to_string('search/_sidebar.html',
dict(form=form, rdata=rdata))
if testing:
output['sqs'] = qs
return output
def search_results(request):
if request.session.get('_simple_post'):
request.POST = request.session.get('_simple_post')
form = SearchForm(request.POST) # A form bound to the POST data
elif request.session.get('_advanced_post'):
request.POST = request.session.get('_advanced_post')
form = AdvancedSearchForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
search_words = form.cleaned_data.get('search', '').split()
all_these_words = form.cleaned_data.get('all_these_words', '').split()
this_exact_word_or_phrase = form.cleaned_data.get('this_exact_word_or_phrase', '')
any_of_these_words = form.cleaned_data.get('any_of_these_words', '').split()
none_of_these_words = form.cleaned_data.get('none_of_these_words', '').split()
queries = []
if search_words:
for word in search_words:
q = []
q.append(Q(**{'body__icontains':word}))
q.append(Q(**{'title__icontains':word}))
queries.append(reduce(operator.or_, q))
qs = WebSite.objects.filter(reduce(operator.and_, queries))
if all_these_words:
for word in all_these_words:
q = []
q.append(Q(**{'body__icontains':word}))
q.append(Q(**{'title__icontains':word}))
queries.append(reduce(operator.or_, q))
qs = WebSite.objects.filter(reduce(operator.and_, queries))
if this_exact_word_or_phrase:
q = []
q.append(Q(**{'body__icontains':this_exact_word_or_phrase}))
q.append(Q(**{'title__icontains':this_exact_word_or_phrase}))
queries.append(reduce(operator.or_, q))
qs = WebSite.objects.filter(reduce(operator.and_, queries))
if any_of_these_words:
for word in any_of_these_words:
q = []
q.append(Q(**{'body__icontains':word}))
q.append(Q(**{'title__icontains':word}))
queries.append(reduce(operator.or_, q))
qs = WebSite.objects.filter(reduce(operator.or_, queries))
if none_of_these_words:
for word in none_of_these_words:
q = []
q.append(~Q(**{'body__icontains':word}))
q.append(~Q(**{'title__icontains':word}))
queries.append(reduce(operator.and_, q))
qs = WebSite.objects.filter(reduce(operator.and_, queries))
data = []
for ws in qs:
data.append({"rank":rank_calc(ws, search_words), "id": ws.id, "url": ws.url, "pub_date": ws.pub_date, "title":ws.title, "body":ws.body} )
table = WebSiteTable(data)
RequestConfig(request).configure(table)
return render(request, 'search/search_results.html', {'table': table, 'form': form})
else:
form = SearchForm() # An unbound form
return render(request, 'search/search_results.html', {
'form': form,
})
def test_form_validation_invalid(self):
# Address and coordinates.
form_data = {
"user_latitude": "64.14624",
"user_longitude": "-21.94259",
"user_address": "Fridtjof Nansens plass, Oslo",
"radius": "800",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
self.assertFalse(form.is_valid())
# Neither address nor coordinates.
form_data = {
"user_latitude": "",
"user_longitude": "",
"user_address": "",
"radius": "800",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
# No radius.
form_data = {
"user_latitude": "",
"user_longitude": "",
"user_address": "Fridtjof Nansens plass, Oslo",
"radius": "",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
self.assertFalse(form.is_valid())
# Invalid search preset.
form_data = {
"user_latitude": "",
"user_longitude": "",
"user_address": "Fridtjof Nansens plass, Oslo",
"radius": "500",
"search_preset": "9999",
"no_private": "on"
}
form = SearchForm(form_data)
self.assertFalse(form.is_valid())
# Invalid address.
form_data = {
"user_latitude": "",
"user_longitude": "",
"user_address": "Fridof Nansens plass, Oslo",
"radius": "500",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
form.is_valid()
with self.assertRaises(ValidationError):
form.clean(mocking_parameters="invalid_address")
return
def toolbar(context, on):
request = context.get("request", None)
if request:
search_form = SearchForm(data=request.GET)
else:
search_form = SearchForm()
return {
'on': on,
'graph': context["graph"],
'node_type': context.get("node_type", None),
'search_form': search_form
}
def test_light_search(self):
form_data = {
"user_latitude": "64.14624",
"user_longitude": "-21.94259",
"user_address": "",
"radius": "500",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
if not form.is_valid():
self.fail("Validation of the form failed.")
form.clean()
response = self.client.post('/light/', data=form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "base_light.html")
self.assertContains(response, "Voici votre localisation ")
self.assertContains(response, "Latitude : 64.14624")
self.assertContains(response, "Longitude : -21.94259")
self.assertContains(response, "Adresse : ")
self.assertContains(
response, 'Recherche : "Boulangerie / Pâtisserie"')
self.assertContains(response, " dans un rayon de 500 mètres.")
self.assertContains(response, "Exclusion des résultats à accès privé.")
self.assertContains(response, "Nom : City Hall of Reykjavik")
self.assertContains(response, "Distance : 11990937 mètres")
self.assertContains(response, "Direction : 107,6° E →")
self.assertContains(response,
('Téléphone : <a href="tel:+354 411 1111">'
'+354 411 1111</a>'))
self.assertContains(response, 'Adresse estimée : ')
# Same test, but including private results.
form_data = {
"user_latitude": "64.14624",
"user_longitude": "-21.94259",
"user_address": "",
"radius": "500",
"search_preset": self.search_preset_id,
"no_private": "False"
}
form = SearchForm(form_data)
if not form.is_valid():
self.fail("Validation of the form failed.")
form.clean()
response = self.client.post('/light/', data=form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "base_light.html")
self.assertContains(response, "Inclusion des résultats à accès privé.")
return
def test_results_page(self):
form_data = {
"user_latitude": "64.14624",
"user_longitude": "-21.94259",
"user_address": "",
"radius": "500",
"search_preset": self.search_preset_id,
"no_private": "on"
}
form = SearchForm(form_data)
if not form.is_valid():
self.fail("La validation du formulaire a échoué.")
form.clean()
response = self.client.post('/', data=form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "base.html")
self.assertContains(response, "Voici votre localisation ")
self.assertContains(response, "Latitude : 64.14624")
self.assertContains(response, "Longitude : -21.94259")
self.assertContains(response, "Adresse : ")
self.assertContains(
response, 'Recherche : "Boulangerie / Pâtisserie"')
self.assertContains(response, " dans un rayon de 500 mètres.")
self.assertContains(response, "Exclusion des résultats à accès privé.")
# Same test, but including private results.
form_data = {
"user_latitude": "64.14624",
"user_longitude": "-21.94259",
"user_address": "",
"radius": "500",
"search_preset": self.search_preset_id,
"no_private": "False"
}
form = SearchForm(form_data)
if not form.is_valid():
self.fail("La validation du formulaire a échoué.")
form.clean()
response = self.client.post('/', data=form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "base.html")
self.assertContains(response, "Voici votre localisation ")
self.assertContains(response, "Latitude : 64.14624")
self.assertContains(response, "Longitude : -21.94259")
self.assertContains(response, "Adresse : ")
self.assertContains(
response, 'Recherche : "Boulangerie / Pâtisserie"')
self.assertContains(response, " dans un rayon de 500 mètres.")
self.assertContains(response, "Inclusion des résultats à accès privé.")
return
def home(request):
form = SearchForm()
topics = FoodTopic.objects.order_by('-total_collects').all()[:4]
return render(request, 'home/index.tpl', {
'search_form': form,
'topics': topics
})
def get_context_data(self, **kwargs):
context = super(BestTalksView, self).get_context_data(**kwargs)
search_form = SearchForm()
context['search_form'] = search_form
page = 1
if "page" in self.kwargs:
page = int(self.kwargs["page"])
sort = "wilsonscore_rank"
results_total, results_ids = search_talks(page=page, sort=sort)
search_results = Talk.published_objects.filter(pk__in=results_ids)
num_pages = math.ceil(results_total / self.paginate_by)
if num_pages > 500:
num_pages = 500
pagination = {
"is_paginated":
True if results_total > self.paginate_by else False,
"number": page,
"num_pages": num_pages,
"has_previous": True if page > 1 else False,
"previous_page_number": page - 1,
"has_next": True if page < num_pages else False,
"next_page_number": page + 1,
}
context['pagination'] = pagination
context['object_list'] = search_results
return context
def search(request):
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['q']
has_real_name_access = request.user.has_perm(
'demoscene.view_releaser_real_names')
page_number = request.GET.get('page', '1')
# Make sure page request is an int. If not, deliver first page.
try:
page_number = int(page_number)
except ValueError:
page_number = 1
results, page = form.search(with_real_names=has_real_name_access,
page_number=page_number)
else:
query = ''
page = None
results = None
return render(request, 'search/search.html', {
'form': form,
'query': query,
'results': results,
'page': page,
})
def search(request):
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['q']
has_real_name_access = request.user.has_perm(
'demoscene.view_releaser_real_names')
(name_results, results,
resultset) = form.search(with_real_names=has_real_name_access)
if len(name_results) == 1 and len(results) == 0:
messages.success(request, "One match found for '%s'" % query)
return HttpResponseRedirect(
name_results[0].instance.get_absolute_url())
page = get_page(results, request.GET.get('page', '1'))
else:
query = None
page = None
name_results = None
resultset = None
return render(
request, 'search/search.html', {
'form': form,
'query': query,
'global_search_query': query,
'name_results': name_results,
'page': page,
'resultset': resultset,
})
def toolbar(context, on):
request = context.get("request", None)
if request:
search_form = SearchForm(data=request.GET)
else:
search_form = SearchForm()
return {
'on': on,
'graph': context["graph"],
'node_type': context.get("node_type", None),
'nodes': context.get("nodes", None),
'csv_results': context.get("csv_results", None),
'search_form': search_form,
'ENABLE_CLONING': settings.ENABLE_CLONING,
'OPTIONS': context.get("OPTIONS", None)
}
def get_data(request):
""" This method is meant to get all results from all selected locations whitch match the searched string
:param request - request object sent by the browser
:returns Dictionary with products from every selected vendor"""
search_string = request.POST.get('search_string')
products = {}
search_data = []
search_on = request.POST.getlist('search_on')
if not search_on:
search_on = request.POST.getlist('search_on[]')
locations = SearchPlace.objects.filter(id__in=search_on)
start = time.time()
for location in locations:
url = "%s%s" % (location.url, search_string)
search_data.append([url, location])
num_cores = cpu_count()
pool = Pool(processes=num_cores)
pool_outputs = pool.map(function_wrapper, search_data)
for product in pool_outputs:
if not products:
products = product
else:
products.update(product)
stop = time.time()
print(stop - start)
return render(request, 'results.html', {
'data': products,
'form': SearchForm()
})
def thesis_list(request, id, slug):
conference = get_object_or_404(Conference, pk=id)
theses = conference.thesis_set.all()
form = ThesisFilterForm()
search_form = SearchForm(search_text='Прізвище автора або назва статті')
sort_param = None
q = request.GET.get('q', '')
thesis_message = ''
if q:
search_params = ('title', 'author__participant__user__lastname')
theses = search_objects(q, theses, search_params, sort_param)
store(request, q)
section = request.GET.get('section', '')
if section:
form = ThesisFilterForm(request.GET)
if form.is_valid():
if request.GET.get('section') != 'all':
theses = theses.filter(section=request.GET.get('section'))
number_of_search_result = str(len(theses))
if len(number_of_search_result) == 2 and number_of_search_result.startswith('1'):
thesis_message = 'доповідей'
else:
for i in thesis_message_dict.keys():
if number_of_search_result[-1] in i:
thesis_message = thesis_message_dict[i]
context = paginate(theses, 4, request, {'theses': theses}, var_name='theses')
context['conference'] = conference
context['form'] = form
context['search_form'] = search_form
context['q'] = q
context['section'] = section
context['number_of_search_results'] = number_of_search_result
context['thesis_message'] = thesis_message
return render(request, 'conference_app/thesis_list.html', context)
def index(request):
site = current_site(request)
if request.GET:
return HttpResponseRedirect(
site['BASE_URL'] + '%s#/?%s' %
(reverse('search:index'), urlencode(request.GET)))
return {'form': SearchForm(sqs=VideoIndex.public())}
def home(request):
form = SearchForm()
return render(request, "home.html", {
'form': form,
'extra': {
'hide_search_bar': True
}
})
def search(self, rdata, user, testing=False):
sqs = VideoIndex.public()
rdata['q'] = rdata['q'] or u' '
q = rdata.get('q')
if q:
sqs = SearchForm.apply_query(q, sqs)
form = SearchForm(rdata, sqs=sqs)
else:
form = SearchForm(rdata)
if form.is_valid():
qs = form.search_qs(sqs)
else:
qs = VideoIndex.public().none()
#result = [item.object for item in qs]
#qs1 = Video.objects.filter(title__contains=rdata['q'])
#for o in qs1:
# if not o in result:
# print o.title
display_views = form.get_display_views()
output = render_page(rdata.get('page', 1),
qs,
20,
display_views=display_views)
output['sidebar'] = render_to_string('search/_sidebar.html',
dict(form=form, rdata=rdata))
# Assume we're currently indexing if the number of public
# indexed vids differs from the count of video objects by
# more than 1000
is_indexing = cache.get('is_indexing')
if is_indexing is None:
is_indexing = Video.objects.all().count() - VideoIndex.public(
).count() > 1000
cache.set('is_indexing', is_indexing, 300)
output['is_indexing'] = is_indexing
if testing:
output['sqs'] = qs
return output
def search(self, rdata, user):
form = SearchForm(rdata)
output = render_page(rdata.get('page', 1), form.queryset(), 20)
output['sidebar'] = render_to_string('search/_sidebar.html', {
'form': form,
'rdata': rdata,
})
return output
def get_context_data(self, **kwargs):
context = super(DetailTalkView, self).get_context_data(**kwargs)
# Views +1 (autoplay)
talk = self.get_object()
talk.view_count += 1
# Update talk to the database
talk.updated = timezone.now()
talk.save()
watched = None
if self.request.user.is_authenticated:
try:
watched = TalkWatch.objects.get(user=self.request.user,
talk=talk)
except ObjectDoesNotExist:
pass
context['watched'] = watched
favorited = None
if self.request.user.is_authenticated:
try:
favorited = TalkFavorite.objects.get(user=self.request.user,
talk=talk)
except ObjectDoesNotExist:
pass
context['favorited'] = favorited
liked = None
if self.request.user.is_authenticated:
try:
liked = TalkLike.objects.get(user=self.request.user, talk=talk)
except ObjectDoesNotExist:
pass
context['liked'] = liked
disliked = None
if self.request.user.is_authenticated:
try:
disliked = TalkDislike.objects.get(user=self.request.user,
talk=talk)
except ObjectDoesNotExist:
pass
context['disliked'] = disliked
search_form = SearchForm()
context['search_form'] = search_form
results_total, results_ids = search_talks(page=1, sort="hacker_hot")
hot_talks = Talk.published_objects.filter(pk__in=results_ids)[:4]
context['hot_talks'] = hot_talks
results_total, results_ids = search_more_like_this(talk)
context['related_talks'] = Talk.published_objects.filter(
pk__in=results_ids)
return context
def search(request):
""" La page de recherche standard """
search_form = SearchForm(request.GET or None)
if search_form.is_valid():
return render(
request, 'search/index.html',
get_results(search_form.cleaned_data.get('q', ''), request,
search_form.cleaned_data))
return render(request, 'search/search.html', {'search_form': search_form})
def search(request):
if request.method == "GET":
form = SearchForm(request.GET)
if form.is_valid():
pass
return render(
request, "search/search.html", {
'form': form,
'categories': Category.objects.all(),
'paper_hosts': PaperHost.objects.order_by('name')
})
elif request.method == "POST":
form = SearchForm(request.POST)
return render_search_result(request, form)
return HttpResponseNotFound()
def test_search_funcionality(self):
NewsFactory(subject='Test Search')
EventFactory(title='Test Search')
response = self.client.get('search', {'query': 'search'})
self.assertEquals(200, response.status_code)
self.assertEquals(1, len(response.context['news']))
self.assertEquals(1, len(response.context['events']))
response = self.client.post('search', {'query': '1'})
from search.forms import SearchForm
form = SearchForm({'query': '1234'})
self.assertTrue(form.is_valid())
form = SearchForm({'query': '1'})
self.assertFalse(form.is_valid())
def search(request):
if request.method == 'POST': # If the form has been submitted...
request.session['_simple_post'] = request.POST
return HttpResponseRedirect('/search_results')
else:
form = SearchForm() # An unbound form
return render(request, 'search/search.html', {
'form': form,
})
def search_home_page_url(request):
form = SearchForm(
request.POST or None
) # jeśli metoda POST to renderuj ten formularz a jeśli nie ma danych to renderuj pusty formularz
if form.is_valid():
form.save(commit=True)
# form = SearchForm() # odświeża formularz, po zapisaniu będą puste pola. To już niepotrzebne, bo po wysłaniu przenosi na inną stronę
return redirect("/search/result_url")
context = {'form': form}
return render(request, "search/search.html", context)
def test_prepare_query(self):
queries = [
'сварщики по Москве', 'сварщики из москвы', 'сварщики, москва'
]
expect = 'сварщик москв'
for query in queries:
with self.subTest(query_string=query):
result = SearchForm().prepare_query(query)
self.assertEqual(result, expect)
def search_box(request):
q = request.GET.get('q', '')
category_searched = request.GET.get('category_searched', '')
active_departments = Department.active.all()
form = SearchForm({
'q': q,
'category_searched': category_searched,
})
return {'form': form, 'departments': active_departments}
def valid_search_form(db, city_model_Tel_Aviv):
return SearchForm(
data={
'city': city_model_Tel_Aviv,
'start_date': '2021-03-03',
'min_rent': 2000,
'max_rent': 3000,
'num_of_roomates': 2,
'num_of_rooms': 3,
})
def get_context_data(self, **kwargs):
context = super(TopicListView, self).get_context_data(**kwargs)
search_form = SearchForm()
context['search_form'] = search_form
topics_list = Topic.published_objects.filter(parent_topic=None)
context['object_list'] = topics_list
return context
