def get(self, request, *args, **kwargs):
"""
Get method with params
:param request:
:param args:
:param kwargs:
:return:
"""
query = request.GET['q']
if query == '':
return redirect('tube:index')
ids_response = []
ids_response_videos = []
response = raw_search(Channel, query)
response_video = raw_search(Video, query)
for val in response['hits']:
ids_response.append(val.get('objectID'))
for val in response_video['hits']:
ids_response_videos.append(val.get('objectID'))
if (len(ids_response)) > 0:
channels = Channel.objects.filter(id__in=ids_response)
else:
channels = ''
if (len(ids_response_videos)) > 0:
videos = Video.objects.filter(id__in=ids_response_videos)
else:
videos = ''
return render(request, self.template_name, {
'q': query,
'channels': channels,
'videos': videos
})
def get(self, request, *args, **kwargs):
context = dict()
if request.GET.get('page'):
query = request.session['query']
params = {
"hitsPerPage": self.no_of_item,
"page": request.GET.get('page')
}
else:
query = request.GET.get('address')
params = {"hitsPerPage": self.no_of_item}
request.session['query'] = query
a = raw_search(Property, query, params)
b = raw_search(Property, query, {"hitsPerPage": 2000})
property_list = Property.objects.filter(
id__in=[int(w.get('objectID')) for w in a.get('hits')])
if property_list.exists():
context = self.get_context(property_list)
pageNo = a.get('nbPages')
context['last_page'] = pageNo
context['pageNo'] = range(0, pageNo)
context['no_of_properties_for_sales'] = a.get('nbHits')
context['result'] = True
context['query'] = query
else:
context = self.get_context(get_feature())
context['result'] = True
return render(request, 'main/search.html', context)
def test_save_signal(self):
Website.objects.create(name='Algolia', url='https://www.algolia.com')
Website.objects.create(name='Google', url='https://www.google.com')
Website.objects.create(name='Facebook', url='https://www.facebook.com')
time.sleep(10) # FIXME: Expose last task's ID so we can waitTask instead of sleeping
self.assertEqual(raw_search(Website)['nbHits'], 3)
def test_save_signal(self):
Website.objects.create(name='Algolia', url='https://www.algolia.com')
Website.objects.create(name='Google', url='https://www.google.com')
Website.objects.create(name='Facebook', url='https://www.facebook.com')
time.sleep(5)
self.assertEqual(raw_search(Website)['nbHits'], 3)
def search(request):
"""Search story by title """
search_query = request.GET.get('title')
params = {"hitsPerPage": 5}
response = raw_search(models.Compose, search_query, params)
if response['nbHits'] == 0:
return JsonResponse({"error": "No search Found"},
status=status.HTTP_404_NOT_FOUND)
return JsonResponse(response, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
context = dict()
mortage_query = request.POST.get('mortage_query')
params = {"hitsPerPage": 50}
a = raw_search(Mortage, mortage_query, params)
mortage_list = Mortage.objects.filter(
id__in=[int(w.get('objectID')) for w in a.get('hits')])
if mortage_list.exists():
context['mortages'] = mortage_list
return render(request, 'main/lenders.html', context)
def search(self, term: str) -> 'QuerySet':
"""
Search by term using algolia search engine, filter results using ids from DB
:param term: search term
:return:
"""
params = {"hitsPerPage": 100}
response = raw_search(self.model, term, params)
self.search_result_ids = [hit['objectID'] for hit in response['hits']]
return self.filter(id__in=self.search_result_ids)
def search_query(request):
try:
queryset = Products.objects.all()
query = request.GET.get('q')
if query:
params = {"hitsPerPage": 15}
queryset = raw_search(Products, query, params)
return JsonResponse({'results': queryset['hits']})
except:
return HttpResponse('nothing')
def test_delete_signal(self):
Website.objects.create(name='Algolia', url='https://www.algolia.com')
Website.objects.create(name='Google', url='https://www.google.com')
Website.objects.create(name='Facebook', url='https://www.facebook.com')
Website.objects.get(name='Algolia').delete()
Website.objects.get(name='Facebook').delete()
time.sleep(10)
result = raw_search(Website)
self.assertEqual(result['nbHits'], 1)
self.assertEqual(result['hits'][0]['name'], 'Google')
def resolve_strands(self, info, query='', size=100, page=0):
if query:
# TODO: Incorporate permissions into indices for efficiency
results = raw_search(Strand,
query=query,
params={
'hitsPerPage': size,
'page': page
})
return Strand.objects.filter(
id__in=map(lambda x: x['objectID'], results['hits'])).all()
return Strand.objects.all()
def article_search(request):
query = request.GET.get('query', '')
response = raw_search(Article, query)
ids = [article['objectID'] for article in response['hits']]
# Allow to get the articles in the specific sequence of ids we gave, thanks to case when id = x then pos=1…
whens = Case(*[When(id=id, then=Value(pos)) for (pos, id) in enumerate(ids)])
# We prefer to have real django orm objects instead of algolia objects, to be able to use the paginator
articles = Article.objects.filter(id__in=ids).order_by(whens)
p = Paginator(articles, 4)
page = request.GET.get('page', 1)
return render(request, 'article/search.html', {'page': p.get_page(page), 'query': query})
def test_update_records(self):
Website.objects.create(name='Algolia', url='https://www.algolia.com')
Website.objects.create(name='Google', url='https://www.google.com')
Website.objects.create(name='Facebook', url='https://www.facebook.com')
Website.objects.create(name='Facebook', url='https://www.facebook.fr')
Website.objects.create(name='Facebook', url='https://fb.com')
qs = Website.objects.filter(name='Facebook')
update_records(Website, qs, url='https://facebook.com')
qs.update(url='https://facebook.com')
time.sleep(10)
result = raw_search(Website, 'Facebook')
self.assertEqual(result['nbHits'], qs.count())
for res, url in zip(result['hits'], qs.values_list('url', flat=True)):
self.assertEqual(res['url'], url)
def search(request):
segmentos = Segmento.objects.all().order_by('descricao')
areas = Area.objects.all().order_by('descricao')
qs = request.GET.get('qs', '')
id_area = request.GET.get('area', '')
page = request.GET.get('page', '0')
results = None
area_descricao = ''
previous_page = ''
next_page = ''
if page:
next_page = int(page) + 1
previous_page = int(page) - 1
if qs:
params = {'hitsPerPage': 2, 'page': page}
results = algoliasearch.raw_search(Profissional, qs, params)
if id_area:
area = get_object_or_404(Area, id=id_area)
area_descricao = area.descricao
results = Profissional.objects.filter(area=area).order_by('nome')
paginator = Paginator(results, 5)
page = request.GET.get('page', 1)
try:
results = paginator.page(page)
except PageNotAnInteger:
results = paginator.page(1)
except EmptyPage:
results = paginator.page(paginator.num_pages)
context = {
'segmentos': segmentos,
'areas': areas,
'results': results,
'area_descricao': area_descricao,
'qs': qs,
'previous_page': previous_page,
'next_page': next_page,
'id_area': id_area,
}
return render(request, 'contratou/profissional_search.html', context)
def search(request):
categories = Category.objects.filter(hidden=False,
parent__isnull=True).order_by('name')
qs = request.GET.get('qs', '')
str_category = request.GET.get('category', '')
page = request.GET.get('page', "0")
results = None
cat_name = ""
next_page = ""
previous_page = ""
if page:
next_page = int(page) + 1
previous_page = int(page) - 1
if qs:
params = {"hitsPerPage": 1, "page": page}
results = algoliasearch.raw_search(Product, qs, params)
if str_category:
cat = get_object_or_404(Category, slug=str_category)
cat_name = cat.name
results = Product.objects.filter(categories=cat)
paginator = Paginator(results, 1)
page = request.GET.get('page', 1)
try:
results = paginator.page(page)
except PageNotAnInteger:
results = paginator.page(1)
except EmptyPage:
results = paginator.page(paginator.num_pages)
context = {
'categories': categories,
'results': results,
'cat_name': cat_name,
'qs': qs,
'next_page': next_page,
'previous_page': previous_page,
'str_category': str_category
}
return render(request, 'portal/product_search.html', context)
def search_query(request, slug):
try:
queryset = Products.objects.filter(shop_rel__slug=slug)
query = request.GET.get("q")
if query:
params = {"hitsPerPage": 15}
queryset = raw_search(Products, query, params)
queryset = [x for x in queryset["hits"] if x["shop_slug"] == slug]
else:
queryset = ProductSerializer(queryset, many=True)
return Response(
data={"results": queryset if query else queryset.data},
status=status.HTTP_200_OK,
)
except queryset.DoesNotExist:
return Response(data={"nothing": "nothing"},
status=status.HTTP_404_NOT_FOUND)
def search(request):
context = {}
query_string = request.GET.get('q')
if query_string:
# setting custom search result
results = Service.objects.filter(Q(name__icontains=query_string) |
Q(description__icontains=query_string) |
Q(provider__first_name__contains=query_string) |
Q(provider__last_name__contains=query_string)).distinct()
context['results'] = results
# adding algolia search result
algolia_results = raw_search(Service, query_string)
context["algolia_results"] = algolia_results
form = SearchForm(request.GET or None)
context['form'] = form
return render(request, 'website/search_result.html', context)
def search(request):
categories = models.Category.objects.filter(
parent__isnull=True).order_by('name')
qs = request.GET.get('q', '')
str_category = request.GET.get('categoria', '')
page = request.GET.get('page', 0)
results = None
if qs:
params = {'hitsPerPage': 1, 'page': page}
results = algoliasearch.raw_search(models.Product, qs, params)
if str_category:
category = get_object_or_404(models.Category, slug=str_category)
result = models.Product.objects.filter(category=category)
paginator = Paginator(result, 1)
page = request.GET.get('page', 1)
try:
results = paginator.page(page)
except EmptyPage:
results = paginator.page(paginator.num_pages)
try:
totalpages = range(results['nbPages'])
except:
totalpages = range(1)
context = {
'categories': categories,
'results': results,
'q': qs,
'page': page,
'previous_page': int(page) - 1,
'next_page': int(page) + 1,
'nPages': totalpages,
}
return render(request, 'portal/search.html', context)
def post(self, request, *args, **kwargs):
filter_string = ''
if request.is_ajax():
context = dict()
if request.POST.get('page'):
if request.POST.get('filter_string'):
search_params = build_search_string(
filter_string=request.POST.get('filter_string'),
page=request.POST.get('page'))
else:
search_params = build_search_string(
page=request.POST.get('page'))
else:
params_dict = build_params_dict(request)
filter_string = get_filter_string(request, params_dict)
search_params = build_search_string(filter_string)
query = request.session['query']
a = raw_search(Property, query, search_params)
pageNo = a.get('nbPages')
context['property_list'] = Property.objects.filter(
id__in=[int(w.get('objectID')) for w in a.get('hits')])
if not context['property_list'].exists():
context['result'] = True
pageNo = range(0, pageNo)
#pdb.set_trace()
query = request.session['query']
pagination = render_to_string('main/includes/navigation.html',
{'pageNo': pageNo})
result = render_to_string('main/includes/result.html', context)
return JsonResponse({
'status': 'success',
'result': result,
'pagination': pagination,
'filter_string': filter_string
})
