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
