def get_images_paginated(query, origins, page_num, last_id=None): args = None queryset = Image.active.all() if last_id is not None: queryset = queryset.filter(id__lte=last_id) per_page = 20 page_num = int(page_num) if origins and len(origins)<len(Image._meta.get_field('origin').choices): origins = [Q(origin=origin) for origin in origins] args = reduce(operator.or_, origins) queryset = queryset.filter(args) if query.isdigit(): pk = int(query) image = Image.objects.get(pk=pk) images = queryset.filter(tags__in=image.tags.all()).\ annotate(num_common_tags=Count('id')).filter(num_common_tags__gte=2 ).order_by('-num_common_tags') # images = queryset.extra(select={'dist':'hamming_text(hash,%s)'}, where=['hamming_text(hash,%s)>0.6'], params=[image.hash,], # select_params=[image.hash,image.hash]).exclude(hash="").distinct() else: if query: images = watson.filter(queryset, query).distinct() else: images = watson.filter(queryset, query).order_by('-id').distinct() amount = images.count() images = images.prefetch_related('tags')[(per_page*page_num)-per_page:per_page*page_num] return images, amount
def get_images_paginated(query, origins, page_num, last_id=None): args = None queryset = Image.active.all() if last_id is not None: queryset = queryset.filter(id__lte=last_id) per_page = 20 page_num = int(page_num) if origins and len(origins)<len(Image._meta.get_field('origin').choices): origins = [Q(origin=origin) for origin in origins] args = reduce(operator.or_, origins) queryset = queryset.filter(args) if query.isdigit(): pk = int(query) image = Image.objects.get(pk=pk) images = queryset.filter(tags__in=image.tags.all()).\ annotate(num_common_tags=Count('id')).filter(num_common_tags__gte=2 ).order_by('-num_common_tags') # images = queryset.extra(select={'dist':'hamming_text(hash,%s)'}, where=['hamming_text(hash,%s)>0.6'], params=[image.hash,], # select_params=[image.hash,image.hash]).exclude(hash="").distinct() else: if query: images = watson.filter(queryset, query).order_by('-clicks').distinct() else: images = watson.filter(queryset, query).order_by('-id').distinct() amount = images.count() images = images.prefetch_related('tags')[(per_page*page_num)-per_page:per_page*page_num] return images, amount
def searching(request): search_results_facility = watson.filter(ContactOwner, request.GET.get('q')) search_results_arendator = watson.filter(Arendator, request.GET.get('q')) search_results_buyer = watson.filter(Buyer, request.GET.get('q')) search_results_makler = watson.filter(Makler, request.GET.get('q')) return render(request, 'searching/search_results.html', {'search_results_facility': search_results_facility, 'search_results_arendator': search_results_arendator, 'search_results_buyer': search_results_buyer, 'search_results_makler': search_results_makler})
def searchProject(request): query = request.GET.get('term') if request.user.is_engineer: # Restrict to only engineer's company's projects projects_list = in_university = watson.filter( models.Project.objects.filter( company=request.user.engineer.company), query) else: projects_list = in_university = watson.filter(models.Project, query) return render(request, 'projects.html', { 'projects': projects_list, })
def testFilter(self): for model in (WatsonTestModel1, WatsonTestModel2): # Test can find all. self.assertEqual(watson.filter(model, "TITLE").count(), 2) # Test can find a specific one. obj = watson.filter(WatsonTestModel1, "INSTANCE12").get() self.assertTrue(isinstance(obj, WatsonTestModel1)) self.assertEqual(obj.title, "title model1 instance12") # Test can do filter on a queryset. obj = watson.filter(WatsonTestModel1.objects.filter(title__icontains="TITLE"), "INSTANCE12").get() self.assertTrue(isinstance(obj, WatsonTestModel1)) self.assertEqual(obj.title, "title model1 instance12")
def testFilter(self): for model in (WatsonTestModel1, WatsonTestModel2, WatsonTestModel3): # Test can find all. self.assertEqual(watson.filter(model, "TITLE").count(), 2) # Test can find a specific one. obj = watson.filter(WatsonTestModel1, "INSTANCE12").get() self.assertTrue(isinstance(obj, WatsonTestModel1)) self.assertEqual(obj.title, "title model1 instance12") # Test can do filter on a queryset. obj = watson.filter(WatsonTestModel1.objects.filter(title__icontains="TITLE"), "INSTANCE12").get() self.assertTrue(isinstance(obj, WatsonTestModel1)) self.assertEqual(obj.title, "title model1 instance12")
def search(request): context = {} q = request.GET.get("q") if q is not None: search_results = watson.filter(Product, q) context = {"search_results": search_results} return render(request, "store/pages/search.html", context=context)
def get_queryset(self): query = Message.objects.filter(to__pk=self.request.user.pk, not_view=True) q = self.request.GET.get('q', '') if q: query = watson.filter(query, q) return query
def ajaxFormModelChoices(request, id): """View for select2 ajax data request""" if id not in ModelAjaxChoiceField.registered_fields: return JsonResponse({}) field = ModelAjaxChoiceField.registered_fields[id] query = field.queryset.order_by('verbose_name') search = request.GET.get('q', None) if search: config = models_config.get_config(query.model) if not config.disable_search_index: query = watson.filter(query, search, ranking=False) else: query = query.filter(verbose_name__contains=search) pages = Paginator(query, 20) page = pages.page(int(request.GET.get('page', 1))) result = [{ 'id': '', 'text': '------' }] if not isinstance(field.widget, SelectMultiple ) and not field.required and page.number == 1 else [] return JsonResponse({ 'results': result + [{ 'id': row[0], 'text': row[1], } for row in page.object_list.values_list('id', 'verbose_name')], 'pagination': { 'more': page.has_next(), } })
def search(request): did_post_pun = "" if request.method == "POST": form, did_post_pun = process_pun_form(request) else: form = PunForm() context_dict = {"new_pun_form": form, "search_form": SearchForm()} query_string = "" puns = Pun.objects.all() search_form = SearchForm(request.GET) if search_form.is_valid(): data = search_form.cleaned_data query_string = data["search"] puns = watson.filter(Pun, query_string) if puns is not None: puns = order_query_set_by_pun_score(puns) for pun in puns: pun.profile = UserProfile.objects.get(user=pun.owner) if request.user.is_authenticated(): puns = set_up_down_votes(request, puns) profile = UserProfile.objects.get(user=request.user) if not profile.show_nsfw: puns = [pun for pun in puns if pun.NSFW == False] context_dict["tags_list"] = get_all_tags_list() context_dict["query_string"] = query_string context_dict["puns"] = puns response = render_to_response("punny/search-results.html", context_dict, context_instance=RequestContext(request)) if did_post_pun is True: response.set_cookie("success", "pun posted!", max_age=3) elif did_post_pun is False: response.set_cookie("failed", "post failed", max_age=3) return response
def filter_queryset(self, qs): keyword = self.request.query_params.get(self.keyword_param, '') if not self.action == 'search' or not keyword: return super(ArticleViewSet, self).filter_queryset(qs) return watson.filter(qs, keyword)
def testRankingWithFilter(self): self.assertEqual( [entry.title for entry in watson.filter(WatsonTestModel1, "FOOO")], [ "title model1 instance11 fooo baar fooo", "title model1 instance12" ])
def reporte_buscar(request, query): '''Funcion para filtrar reportes por chofer, tiempo, fecha o distancia.''' # usamos la libreria `watson` para filtrar los clientes de acuerdo a la query de busqueda search_results = watson.filter(Reporte, query) # si no hay resultados de busqueda, se le indicara al cliente if not search_results: section = 'reportes' return render(request, 'buscar_404.html', { 'query': query, 'section': section }) # mostramos hasta 10 reusltados por pagina p = Paginator(search_results, 10) page = request.GET.get('p') if not page: page = 1 page_range = calc_page_range(int(page), p.num_pages) # finalmente mostramos los resultados al usuario return render( request, 'reportes_lista.html', { 'reportes': p.get_page(page), 'paginator': p, 'page_range': page_range, 'query': query })
def clientes_buscar(request, query): '''Buscar clientes a partir de su nombre, direccion, telefono, correo...''' # usamos la libreria `watson` para filtrar los clientes de acuerdo a la query de busqueda search_results = watson.filter(Cliente, query) # si no existen resultados para dicha query... if not search_results: # rendereamos `buscar_404.html` para decirle al usuario que su busqueda no dio resultado section = 'clientes' return render(request, 'buscar_404.html', { 'query': query, 'section': section }) # si hubo resultados, creamos un paginador para mostrar hasta 10 resultados por busqueda p = Paginator(search_results, 10) page = request.GET.get('p') if not page: page = 1 page_range = calc_page_range(int(page), p.num_pages) # mostramos la lista de clientes filtrados return render( request, 'clientes_lista.html', { 'clientes': p.get_page(page), 'paginator': p, 'page_range': page_range, 'query': query })
def get_queryset(self): """Manually filtering the qs. @ToDo: Make this use internal REST framework functions.""" queryset = Article.objects.filter( published_date__lte=timezone.now()).order_by('-published_date') month = self.request.query_params.get('month', None) year = self.request.query_params.get('year', None) tags = self.request.query_params.get('tags', None) query = self.request.query_params.get('query', None) if tags: queryset = queryset.filter( Q(tags__name__in=[tags]) | Q(tags__slug__in=[tags])) if year: if month: # Filtering on year and month queryset = queryset.filter( published_date__year=year, published_date__month=month, published_date__lte=timezone.now()).order_by( '-published_date') else: # Filtering only on year queryset = queryset.filter( published_date__year=year, published_date__lte=timezone.now()).order_by( '-published_date') if query and query != '': queryset = watson.filter(queryset, query) return queryset
def post(self, request, **kwargs): search_text = request.POST.get('q') results = watson.filter(Sujet, search_text) # logger.warning("SEARCH for %s : %s" % (search_text, results)) if results.count() == 1: return redirect(results[0].get_absolute_url()) self.queryset = results return self.get(request, **kwargs)
def get_queryset(self): """ If there is a search query provided in the request, then filter the queryset with a search. """ queryset = super(ModelSearchMixin, self).get_queryset() query = self.get_query() if query: queryset = watson.filter(queryset.model, query) return queryset
def search(request): criteria = request.GET.get('criteria') length = len(watson.search(str(request.GET.get('q')))) #if length == 0: # return if criteria == 'up': search_results = watson.filter(Upload, str(request.GET.get('q'))) return render(request, 'wpFiles/search.html', {'search_results': search_results}) elif criteria == 'de': search_results = watson.filter(Academic_dept, str(request.GET.get('q'))) return render(request, 'wpFiles/searchDept.html', {'search_results': search_results}) elif criteria == 'co': search_results = watson.filter(Academic_class, str(request.GET.get('q'))) return render(request, 'wpFiles/searchClass.html', {'search_results': search_results})
def get_queryset(self): if "q" in self.request.GET.keys(): products = Product.objects.filter(status=0).prefetch_related('images', 'category') q = self.q = strip_tags(self.request.GET['q']) search_results = watson.filter(products, q) for product in search_results: print product.name+' / '+str(product.category) return search_results
def filter_queryset(self, qs): keyword = self.request.query_params.get(self.keyword_param, '') if not self.action == 'search' or not keyword: return super(ArticleViewSet, self).filter_queryset(qs) return watson.filter( qs, keyword )
def get_queryset(self): objects = CustomUser.objects.all() search_query = self.request.GET.get('query') orderBy = self.request.GET.get('sortBy') if orderBy: objects = objects.order_by(orderBy) if search_query: objects = watson.filter(objects, search_query) return objects
def get(self, request, **kwargs): context = self.get_context_data(**kwargs) q_comida = request.GET.get("q1", "") q_comercio = request.GET.get("q2", "") q_domicilio = request.GET.get("q3", "") # q_ubicacion = request.GET.get("q4", "") results = [] if q_comercio and q_domicilio: resultes = watson.filter( Domicilio, q_domicilio).filter(comercio__nombre=q_comercio) for re in resultes: results.append(re.comercio) context[ 'search'] = "Comercio: " + q_comercio + " + Domicilio: " + q_domicilio context['search_results'] = results return self.render_to_response(context) elif q_comercio: context['search'] = "Comercio: " + q_comercio context['search_results'] = watson.filter(Comercio, q_comercio) return self.render_to_response(context) elif q_comida: resultes = watson.filter(Comida, q_comida) for re in resultes: results.append(re.comercio) context['search'] = "Comida: " + q_comida context['search_results'] = results return self.render_to_response(context) else: resultes = watson.filter(Domicilio, q_domicilio) for re in resultes: results.append(re.comercio) context['search'] = "Domicilio: " + q_domicilio context['search_results'] = results return self.render_to_response(context)
def busca(request): error = False provas = Prova.objects.all() q = request.GET.get('q', '') problemas = Problema.objects.all() if q: problemas = watson.filter(problemas, q) return render(request, 'busca/busca_form.html', {'provas': provas, 'error': error, 'problemas': problemas})
def get_queryset(self): if "q" in self.request.GET.keys(): products = Product.objects.filter(status=0).prefetch_related( 'images', 'category') q = self.q = strip_tags(self.request.GET['q']) search_results = watson.filter(products, q) for product in search_results: print product.name + ' / ' + str(product.category) return search_results
def search_products(request): if 'q' in request.GET: q = request.GET['q'] search_list = watson.filter(Product, q).annotate(min_price=Min('prices__price')) products_list = helpers.pg_records(request, search_list, 54) return render(request, 'shop/search_products.html', { 'q': q, 'products_list': products_list, 'search_list': search_list })
def get_queryset(self): queryset = Post.objects.all().order_by('id') category = self.request.query_params.get('category', None) search_query = self.request.query_params.get('q', None) if category is not None: return queryset.filter(category__slug=category) if search_query is not None: return watson.filter(Post, search_query) return queryset
def get_queryset(self): objects = WithdrawRequest.objects.all() user = self.request.user search_query = self.request.GET.get('query') orderBy = self.request.GET.get('sortBy') if orderBy: objects = objects.order_by(orderBy) if search_query: objects = watson.filter(objects, search_query) if not user.is_staff: objects = objects.filter(user=user) return objects
def get_queryset(self): """ This view should return a list of all the businesses. """ objects = Business.objects.all() search_query = self.request.GET.get('query') orderBy = self.request.GET.get('sortBy') if orderBy: objects = objects.order_by(orderBy) if search_query: objects = watson.filter(objects, search_query) return objects
def news_search(request): error = False if 'q' in request.GET: q = request.GET['q'] if not q: error = True else: search_results = watson.filter(Post, q) return render(request, 'news/search_results.html', { 'search_results': search_results, 'query': q }) return redirect('news')
def get_queryset(self): queryset = Product.objects.all() q = self.request.GET.get('q', '') if q: ''' queryset = queryset.filter( models.Q(name__icontains=q) | models.Q(category__name__icontains=q) \ | models.Q(description__icontains=q) ) ''' # search with watson librarie queryset = watson.filter(queryset, q) return queryset
def school_search(request): if (request.method == "POST"): form = SchoolSearchForm(request.POST) if (form.is_valid()): search_results = watson.filter(School, form.data['query']) else: search_results = [] else: form = SchoolSearchForm() search_results = School.objects.filter(is_active=True) return render(request, 'school/search.html', {'form': form, 'results': search_results})
def MUTANT_search(request): error = False if 'q' in request.GET: q = request.GET['q'] if not q: error = True else: search_results = watson.filter(MUTANTS, q) return render(request, 'databases/search-results.html', { 'search_results': search_results, 'query': q }) return redirect('mutant-database')
def apply_criteria(self, score_expression, filters, sorting, term=None, search_backend=None): queryset = self.all() try: queryset = self._transform_criteria_base(queryset) except NotImplementedError: pass queryset = queryset.filter(filters) if term: queryset = watson.filter(queryset, term, backend_name=search_backend) queryset, orderby = self._apply_criteria_sorting(queryset, sorting, score_expression) if orderby: queryset = queryset.order_by(*orderby) return queryset
def profile_search(request): if (request.method == "POST"): form = PlayerSearchForm(request.POST) if (form.is_valid()): search_results = watson.filter(Player, form.data['query']) return render(request, 'users/search.html', { 'form': form, 'results': search_results }) else: form = PlayerSearchForm() return render(request, 'users/search.html', {'form': form})
def search(request, exh_id=None): query = request.GET.get('q', '') if query: results = watson.filter(Exhibit, query) else: results = Exhibit.objects.none() print(exh_id) return render(request, 'search.html', { 'exhibits': results, 'query': query, 'open_exh': exh_id })
def post_search(request): if not request.method == "POST": raise Http404 text_search = request.POST['search'] post_page = None if text_search.strip(): search_results = watson.filter(Entry, text_search) post_page = search_results.filter(active=True).order_by('-date')[:30] sc = FifaScrapper() return render(request, "desktop/v2/blog/search.html", {"page": post_page, "text_search": text_search, "settings": settings, "fifa": sc})
def shop(request): if 'q' in request.GET: items = watson.filter(Item, request.GET['q']) categories = Category.objects.all() else: items = Item.objects.all().filter(user__user__graduated=False, sold=False) categories = Category.objects.all() return render(request, 'shop/shop.html', { 'items': items, 'categories': categories })
def suggestProject(request): in_name = request.GET.get('name', 'None') in_group = models.Group.objects.get(name__exact=in_name) project_recomm = models.Project.objects.none() for lang in in_group.aggregate_skills().split(", "): project_recomm = itertools.chain(watson.filter(models.Project, lang), project_recomm) project_recomm = set(project_recomm) projects_list = models.Project.objects.all() return render( request, 'project_suggestion.html', { 'projects': projects_list, 'project_recommended': project_recomm, 'Recommendation': True })
def testEmptyFilterGivesAllResults(self): for model in (WatsonTestModel1, WatsonTestModel2): self.assertEqual(watson.filter(model, "").count(), 2) self.assertEqual(watson.filter(model, " ").count(), 2)
def testRankingParamAbsentOnFilter(self): self.assertRaises( AttributeError, lambda: watson.filter(WatsonTestModel1, "TITLE", ranking=False)[0].watson_rank )
def testRankingWithFilter(self): self.assertEqual( [entry.title for entry in watson.filter(WatsonTestModel1, "FOOO")], ["title model1 instance11 fooo baar fooo", "title model1 instance12"], )
def testPrefixFilter(self): self.assertEqual(watson.filter(WatsonTestModel1, "INSTAN").count(), 2)
def get_queryset(self): filterset = self.filterset_class(self.request.GET, queryset=self.get_base_queryset()) return search.filter(filterset.qs, self.query)
def get_queryset(self): return search.filter(self.get_base_queryset(), self.query)
def testRankingParamPresentOnFilter(self): self.assertGreater(watson.filter(WatsonTestModel1, "TITLE")[0].watson_rank, 0)
def get_context_data(self, **kwargs): context = super(SearchView, self).get_context_data(**kwargs) context['form'] = SearchForm(initial={'name': context.get('query')}) results = watson.filter(Paper, context.get('query')) context['queryset'] = results return context
def find_sujet(self, nom, prenom): from sujets.models import Sujet from watson import search search_text = "%s %s" % (nom, prenom) sujet = self.cache['sujet'].get(search_text, None) while not sujet: create = False #Set to True if creation is needed at and of loop self.stdout.write(self.style.WARNING("In line %i, searching : %s. " % (self.cur_line, search_text)), ending='') results = search.filter(Sujet, search_text) if results.count() == 1: # Always ask to review result a first time sujet = results[0] self.stdout.write(self.style.SUCCESS("Found %s '%s' %s" % (sujet.nom, sujet.surnom, sujet.prenom))) action = input("Confirm ? (y/n/type new search)> ") if action == "n": sujet = None search_text = "%s %s" % (nom, prenom) elif action == "y": continue else: # In case the result is no good at all ! sujet = None search_text = action elif results.count() > 1: # Ask to find the appropriate result self.stdout.write(self.style.WARNING("Multiple results for %s" % search_text)) for i, result in enumerate(results): self.stdout.write("%i. %s '%s' %s" % (i, result.nom, result.surnom, result.prenom)) choice = input("Choose the right number - Type new search - C to create '%s %s': " % (nom, prenom)) if choice == "C": create = True else: try: sujet = results[int(choice)] except (IndexError, ValueError): search_text = str(choice) #New search continue else: # No results, try with name only, or ask for new search if search_text == "%s %s" % (nom, prenom): # Search only with nom self.stdout.write(self.style.WARNING("Nothing, trying name only..."), ending='') search_text = nom if nom else prenom continue else: self.stdout.write(self.style.ERROR("No result !")) action = input("New search or C to create '%s %s': " % (nom, prenom)) if action == "C": create = True else: search_text = str(action) if create: sujet = self.new_object( Sujet, {'nom':nom, 'prenom':prenom} ) self.stdout.write('Created, %s' % sujet) # Always store sujet in cache because it may or may not be updated, safer to save in all cases. self.cache['sujet']["%s %s" % (nom, prenom)] = sujet return sujet