def get_queryset(self):
#функция для пунтосвитчера
def fix_layout(s):
return ''.join([_trans_table.get(c, c) for c in s])
# Get the q GET parameter
q = self.request.GET.get('q')
city = self.request.GET.get('city')
if q:
results = SearchQuerySet().filter(content=q, city=city).values_list('company', flat=True)
if results.count() == 0:
#пунто свитчер
_eng_chars = "~!@#$%^&qwertyuiop[]asdfghjkl;'zxcvbnm,./QWERTYUIOP{}ASDFGHJKL:\"|ZXCVBNM<>?"
_rus_chars = "ё!\"№;%:?йцукенгшщзхъфывапролджэячсмитьбю.ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭ/ЯЧСМИТЬБЮ,"
_trans_table = dict(zip(_eng_chars, _rus_chars))
if re.fullmatch('[a-zA-Z0-9\s]*', q):
self.q_punto = fix_layout(q)
results = SearchQuerySet().filter(content=self.q_punto, city=city).values_list('company', flat=True)
if results.count() == 0:
sqs = SearchQuerySet().auto_query(self.q_punto)
self.q_spell = sqs.spelling_suggestion()
results = SearchQuerySet().filter(content=self.q_spell, city=city).values_list('company', flat=True)
if results.count() == 0:
sqs = SearchQuerySet().auto_query(q)
self.q_spell = sqs.spelling_suggestion()
results = SearchQuerySet().filter(content=self.q_spell, city=city).values_list('company', flat=True)
search_results = Company.objects.filter(pk__in=set(results)).order_by('-yellow', '-blue', '-priority', 'name')
self.count = search_results.count()
else:
search_results = ''
return search_results
def post(self, request, *args, **kwargs):
print 'post',args, kwargs
context = self.get_context_data(*args, **kwargs)
if request.POST.get('q'):
sqs = SearchQuerySet()
clean_query = sqs.query.clean(request.POST.get('q'))
results = SearchQuerySet().models(BlogEntry).filter(content__contains=AutoQuery(clean_query))
print 'results:',results
paginator = Paginator(results, 10)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("No such page of results!")
context = {
# 'form': form,
'clean_query':clean_query,
'page': page,
'paginator': paginator,
'query': query,
'search_suggestion': None,
}
if results.query.backend.include_spelling:
context['search_suggestion'] = results.spelling_suggestion(AutoQuery(clean_query))
context.update(_get_sidebar_objects(self.request, excluded_entry=[]))
return render_to_response(self.template_name, RequestContext(request, context))
def autocomplete(request):
# for datetime format
locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
args = []
models = request.GET.getlist('models')
for model in models:
args.append(apps.get_model(model))
sqs = SearchQuerySet().models(*set(args))
q = request.GET.get('q', '').split(' ')
for word in q:
word = word.strip()
if word:
sqs = sqs.filter(content_auto__contains=word)
if len(models) == 1 and models[0] == 'web.test':
sqs = sqs.order_by('-last_action_date')
result = []
if 'suggestions' in request.GET:
suggestion = sqs.spelling_suggestion()
if suggestion:
result.append({'caption': suggestion})
else:
for ele in sqs:
data = {'caption': str(ele.caption), 'id': ele.pk}
if hasattr(ele, 'closed') and ele.closed:
data['closed'] = ele.closed
result.append(data)
return JsonResponse(result, safe=False)
def get_response(project_uri, query_string, include_n3=True):
d = {
'results': list(),
}
project_graph = projects.get_project_graph(project_uri)
graph = Graph()
query_set = SearchQuerySet().models(Text).filter(
content=AutoQuery(query_string), project__exact=project_uri
)
highlighter = Highlighter(query_string, html_tag='span', css_class=CSS_RESULT_MATCH_CLASS)
title_highlighter = TitleHighlighter(query_string, html_tag='span', css_class=CSS_RESULT_MATCH_CLASS)
d['spelling_suggestion'] = query_set.spelling_suggestion()
for result in query_set:
text_uri = URIRef(result.get_stored_fields()['identifier'])
if annotations.has_annotation_link(project_graph, text_uri) or projects.is_top_level_project_resource(project_uri, text_uri):
d['results'].append(search_result_to_dict(result, project_uri, highlighter, title_highlighter))
if include_n3:
graph += utils.metadata_triples(project_graph, text_uri)
if include_n3:
d['n3'] = graph.serialize(format='n3')
return d
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_('Search'))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def search(self):
if self.is_valid():
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
else:
return []
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
def get_queryset(self):
if self.request.method in SAFE_METHODS:
# Listing/searching.
validate_request_on_app_id(self.request)
if "q" in self.request.query_params:
search_q = self.request.query_params["q"]
else:
# No query is provided. Full list is for authenticated requests only.
if not self.request.user.is_authenticated():
raise NotAuthenticated("")
return Picture.objects.order_by("item_id")
search_q = search_q.strip()
search_q = search_q.lower()
search_q = re.sub(r"\s+", " ", search_q)
search_q = search_q.replace("-", " ")
search_q = search_q.replace(".", "")
search_q = search_q.replace("'", "")
search_q = search_q.strip()
if not search_q:
return Picture.objects.none()
sqs = SearchQuerySet().models(Picture)
sqs = sqs.filter(content=AutoQuery(search_q))
pictures = [sr.object for sr in sqs.load_all()]
if not pictures:
# Auto-correction.
sugg = sqs.spelling_suggestion()
if (sugg is not None) and ("suggestion" in sugg) and sugg["suggestion"]:
sqs = SearchQuerySet().models(Picture)
sqs = sqs.filter(content=sugg["suggestion"][0])
pictures = [sr.object for sr in sqs.load_all()]
# Exclude hidden.
pictures = [picture for picture in pictures if not picture.is_hidden]
# Randomize leading good ones.
first_non_good_picture_pos = None
for i, picture in enumerate(pictures):
if not picture.is_good:
first_non_good_picture_pos = i
break
if first_non_good_picture_pos is not None:
leading_good_pictures = pictures[:first_non_good_picture_pos]
random.shuffle(leading_good_pictures)
pictures = leading_good_pictures + pictures[first_non_good_picture_pos:]
if BOOST_SEARCH_RESULTS_ON_NUM_USES:
pictures = boost_search_results_on_num_uses(pictures)
return pictures
else:
return Picture.objects.all()
def autocomplete(request):
sqs = SearchQuerySet().auto_query(request.GET.get('q', ''))
suggestions = [request.GET.get('q', '')]
result = sqs.spelling_suggestion().strip()
if result:
suggestions.append(result)
return HttpResponse(json.dumps(suggestions),
content_type='application/json')
def testpage(request):
test_results = SearchQuerySet().auto_query('SOlr')
spelling_suggestion = test_results.spelling_suggestion()
# final_spelling = spelling_suggestion.split("(")
# final_two_spelling = final_spelling[1].split(")")
return render(request, 'testpage.html', {
'spelling_suggestion': spelling_suggestion,
})
def ask_search(request, language='en', as_json=False):
if 'selected_facets' in request.GET:
return redirect_ask_search(request, language=language)
language_map = {'en': 'ask-cfpb-search-results', 'es': 'respuestas'}
sqs = SearchQuerySet().models(AnswerPage)
clean_query = Clean(request.GET.get('q', ''))
clean_qstring = clean_query.query_string.strip()
qstring = clean_qstring
query_sqs = sqs.filter(content=clean_query, language=language)
results_page = get_object_or_404(AnswerResultsPage,
language=language,
slug=language_map[language])
# If there's no query string, don't search
if not qstring:
results_page.query = ''
results_page.result_query = ''
return results_page.serve(request)
# If we have no results from our query, let's try to suggest a better one
suggestion = sqs.spelling_suggestion(qstring)
if suggestion == qstring:
suggestion = None
elif (query_sqs.count() == 0 and request.GET.get('correct', '1') == '1'
and flag_enabled('ASK_SEARCH_TYPOS', request=request)):
query_sqs = sqs.filter(content=suggestion)
qstring, suggestion = suggestion, qstring
if as_json:
results = {
'query':
clean_qstring,
'result_query':
qstring,
'suggestion':
suggestion,
'results': [{
'question': result.autocomplete,
'url': result.url,
'text': result.text
} for result in query_sqs]
}
json_results = json.dumps(results)
return HttpResponse(json_results, content_type='application/json')
else:
results_page.query = clean_qstring
results_page.result_query = qstring
results_page.suggestion = suggestion
results_page.answers = []
for result in query_sqs:
results_page.answers.append(
(result.url, result.autocomplete, result.text))
return results_page.serve(request)
class SearchForm(forms.Form):
q = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={
'type': 'search',
'id': 'local-search-input'
}),
)
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('q'):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
class SearchForm(forms.Form):
q = forms.CharField(
required=False,
label=_("Search"),
widget=forms.TextInput(attrs={"type": "search"}),
)
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop("searchqueryset", None)
self.load_all = kwargs.pop("load_all", False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get("q"):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data["q"])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data["q"])
class SzachSearchForm(forms.Form):
q = forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'class': 'form-control',
'type': 'search'}))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SzachSearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('q'):
return self.no_query_found()
#sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
print 'Searching for {}'.format(self.cleaned_data['q'])
sqs = self.searchqueryset.filter(text__startswith=self.cleaned_data['q'])
print 'Found {}'.format(len(sqs))
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
class SearchForm(forms.Form):
text_contains = forms.CharField(required=False, label='Keywords')
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet() #.models(models.Summary)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
print(1)
return self.searchqueryset.all()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('text_contains'):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(
self.cleaned_data['text_contains'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(
self.cleaned_data['text_contains'])
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_("Search"), widget=forms.TextInput(attrs={"type": "search"}))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop("searchqueryset", None)
self.load_all = kwargs.pop("load_all", False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
self.helper = helper.FormHelper(self)
self.helper.form_show_labels = False
self.helper.form_tag = False
self.helper.disable_csrf = True
self.helper.layout = layout.Layout(
layout.Div(
layout.Div(
layout.HTML(fieldtostring(
"required", "autofocus", type="text", name="q", value="",
css_class="form-control form-control-sm", style="margin-left: 0px !important"
)),
layout.HTML(valuetolabel("q", "Search users...")),
css_class="md-form md-bg form-sm",
),
),
)
@staticmethod
def no_query_found():
return EmptySearchQuerySet()
def search(self):
if not self.is_valid(): return self.no_query_found()
if not self.cleaned_data.get("q"): return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data["q"])
if self.load_all: sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid(): return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data["q"])
class SearchForm1(SearchForm):
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet().models(
ProjectPoProjects_bin)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self, project):
if not self.is_valid():
return self.no_query_found()
if self.cleaned_data['start_pay_period'] and self.cleaned_data[
'end_period']:
str_start_date = self.cleaned_data['start_pay_period']
str_end_date = self.cleaned_data['end_period']
#singles
if project:
sqs = self.searchqueryset.filter(project_name=project)
return sqs
def no_query_found(self):
return self.searchqueryset.all()
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_('Search'))
def __init__(self, *args, **kwargs):
print("come in here~!")
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('q'):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
class SearchForm1(SearchForm):
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet().models(ProjectPoProjects_bin)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self,project):
if not self.is_valid():
return self.no_query_found()
if self.cleaned_data['start_pay_period'] and self.cleaned_data['end_period']:
str_start_date=self.cleaned_data['start_pay_period']
str_end_date=self.cleaned_data['end_period']
#singles
if project:
sqs = self.searchqueryset.filter(project_name=project)
return sqs
def no_query_found(self):
return self.searchqueryset.all()
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
def autocomplete(request):
sqs = SearchQuerySet().filter(content=AutoQuery(request.GET.get('q', '')))
suggestion = sqs.spelling_suggestion()
print "Correction: ", suggestion
sqs = SearchQuerySet().autocomplete(content_auto=suggestion)
# suggestion = models.Note.objects.get(slug=slugify(suggestion))
# print "Slug: ", suggestion
# sqs = SearchQuerySet().more_like_this(suggestion)
print "sqs: ", sqs
suggestions = []
#suggestions = [result.title for result in sqs]
for i in sqs:
print i.object.title, i
suggestions.append(i.object.title)
print "suggestions: ", suggestions
# Make sure you return a JSON object, not a bare list.
# Otherwise, you could be vulnerable to an XSS attack.
the_data = json.dumps({
'results': suggestions
})
return HttpResponse(the_data, content_type='application/json')
def get_response(project_uri, query_string, include_n3=True):
d = {
'results': list(),
}
project_graph = projects.get_project_graph(project_uri)
graph = Graph()
query_set = SearchQuerySet().models(Text).filter(
content=AutoQuery(query_string), project__exact=project_uri)
highlighter = Highlighter(query_string,
html_tag='span',
css_class=CSS_RESULT_MATCH_CLASS)
title_highlighter = TitleHighlighter(query_string,
html_tag='span',
css_class=CSS_RESULT_MATCH_CLASS)
d['spelling_suggestion'] = query_set.spelling_suggestion()
for result in query_set:
text_uri = URIRef(result.get_stored_fields()['identifier'])
if annotations.has_annotation_link(
project_graph,
text_uri) or projects.is_top_level_project_resource(
project_uri, text_uri):
d['results'].append(
search_result_to_dict(result, project_uri, highlighter,
title_highlighter))
if include_n3:
graph += utils.metadata_triples(project_graph, text_uri)
if include_n3:
d['n3'] = graph.serialize(format='n3')
return d
def search(request, path=None):
place = request.GET.get("place", SearchPlaceCode.EVERYWHERE)
query = request.GET.get("q", "")
results = SearchQuerySet().filter(content=query)
suggestion = results.spelling_suggestion()
print("suggestions")
print(suggestion)
if place == SearchPlaceCode.THIS_FOLDER.value:
folder = get_folder_or_404(path)
results = SearchQuerySet().filter(content=query,
parent_ids=Exact(folder.pk))
context = browser_base_context(request)
context.update({
"back_url": request.path.split("!")[0],
"query": query,
"results": results,
})
return TemplateResponse(template="search/index.html",
request=request,
context=context)
def autocomplete(request):
# for datetime format
locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
args = []
models = request.GET.getlist('models')
for model in models:
args.append(apps.get_model(model))
sqs = SearchQuerySet().models(*set(args))
q = request.GET.get('q', '').split(' ')
for word in q:
word = word.strip()
if word:
sqs = sqs.filter(content_auto=word)
if len(models) == 1 and models[0] == 'web.test':
sqs = sqs.order_by('-last_action_date')
result = []
if 'suggestions' in request.GET:
suggestion = sqs.spelling_suggestion()
if suggestion:
result.append({'caption': suggestion})
else:
for ele in sqs:
data = {
'caption': unicode(ele.caption),
'id': ele.pk
}
if hasattr(ele, 'closed') and ele.closed:
data['closed'] = ele.closed
result.append(data)
return JsonResponse(result, safe=False)
def category_view(request, category_slug=""):
if category_slug:
category = get_object_or_404(Category, slug=category_slug)
pre_filter_product_list = products_in_category(category, Product.active)
meta_description = category.description
child_categories = category.get_children()
parent_categories = category.get_ancestors(ascending=False, include_self=False)
else:
category = None
parent_categories = None
pre_filter_product_list = Product.active.all()
meta_description = "All products for sale at %s." % settings.SITE_NAME
child_categories = Category.objects.root_nodes()
# implement a product search
search_text = _search_text(request)
spelling_suggestion = None
score_map = {}
if search_text:
sqs = SearchQuerySet().auto_query(search_text).models(Product)
spelling_suggestion = sqs.spelling_suggestion()
if isinstance(spelling_suggestion, dict):
# for some reason solr sometimes returns a dict, so we need to grab the 'suggestion' list
spelling_suggestion = spelling_suggestion['suggestion'][0]
# force the evaluation of the pre-filter product list queryset to
# avoid running expensive search sub-queries more than once
pre_filter_product_list = pre_filter_product_list.filter(id__in=[p.pk for p in sqs])
# log the search query
searchutils.store(request, search_text, sqs.count())
# build up a map of product id --> search score
for p in sqs:
score_map[int(p.pk)] = p.score
final_product_list, applied_filters = filters.filter_products(request, pre_filter_product_list)
final_product_list = final_product_list.annotate(rating=Avg('reviews__rating'))
final_product_list = final_product_list.prefetch_related('images') # product.get_thumbnail optimization
final_product_list, sort_key = _sort(request, final_product_list, score_map)
child_categories = child_categories.order_by('name')
# get a finalized list of products in the form of a subquery. This also forces the final_product_list queryset
# to be evaluated which is fine, it would be evaluated in the template regardless.
final_product_subquery = Product.objects.filter(id__in=[p.id for p in final_product_list])
# only categories with > 0 products will be preserved in this list
child_categories = add_product_count(child_categories, final_product_subquery)
# paginate the product listing
pageSize = request.GET.get('pageSize') or DEFAULT_PAGE_SIZE
showing_all_products = False
if pageSize == "All":
pageSize = max(final_product_list.count(), 1)
showing_all_products = True
# make sure pageSize is an integer. If it isn't, fall back to the default size
try:
pageSize = int(pageSize)
if pageSize < 1:
pageSize = DEFAULT_PAGE_SIZE
except:
pageSize = DEFAULT_PAGE_SIZE
paginator = Paginator(final_product_list, per_page=pageSize, allow_empty_first_page=True)
page = request.GET.get('page')
try:
products = paginator.page(page)
except PageNotAnInteger:
products = paginator.page(1)
except EmptyPage:
products = paginator.page(paginator._num_pages)
context = {
'page_sizes': [DEFAULT_PAGE_SIZE, 32, 64, 96],
'products': products,
'showing_all_products': showing_all_products,
'category': category,
'parent_categories': parent_categories,
'meta_description': meta_description,
'child_categories': child_categories,
'sort_key': sort_key,
'sorts': [
('bestselling', 'Most Popular'),
('priceMin', 'Price (Low to high)'),
('priceMax', 'Price (High to Low)'),
('nameA', 'Name (A to Z)'),
('nameZ', 'Name (Z to A)'),
('rating', 'Top Rated'),
('new', 'Recently Added'),
('bestMatch', 'Best Match'),
],
'search_text': search_text,
'spelling_suggestion': spelling_suggestion, # will be None if there was no search
'filters': applied_filters,
'brands': get_brands(pre_filter_product_list, final_product_subquery, applied_filters),
'themes': get_themes(pre_filter_product_list, final_product_subquery, applied_filters),
'prices': get_prices(pre_filter_product_list, final_product_subquery, applied_filters),
'ages': get_ages(pre_filter_product_list, final_product_subquery, applied_filters),
'features': get_features(final_product_subquery, applied_filters),
'colors': get_colors(pre_filter_product_list, final_product_subquery, applied_filters),
'countries': get_countries(pre_filter_product_list, final_product_subquery, applied_filters),
}
return render_to_response("category.html", context, context_instance=RequestContext(request))
def ask_search(request, language='en', as_json=False):
if 'selected_facets' in request.GET:
return redirect_ask_search(request, language=language)
language_map = {
'en': 'ask-cfpb-search-results',
'es': 'respuestas'
}
sqs = SearchQuerySet().models(AnswerPage)
clean_query = Clean(request.GET.get('q', ''))
clean_qstring = clean_query.query_string.strip()
qstring = clean_qstring
query_sqs = sqs.filter(
content=clean_query,
language=language
)
results_page = get_object_or_404(
AnswerResultsPage,
language=language,
slug=language_map[language]
)
# If there's no query string, don't search
if not qstring:
results_page.query = ''
results_page.result_query = ''
return results_page.serve(request)
# If we have no results from our query, let's try to suggest a better one
suggestion = sqs.spelling_suggestion(qstring)
if suggestion == qstring:
suggestion = None
elif (query_sqs.count() == 0 and
request.GET.get('correct', '1') == '1' and
flag_enabled('ASK_SEARCH_TYPOS', request=request)):
query_sqs = sqs.filter(content=suggestion)
qstring, suggestion = suggestion, qstring
if as_json:
results = {
'query': clean_qstring,
'result_query': qstring,
'suggestion': suggestion,
'results': [
{
'question': result.autocomplete,
'url': result.url,
'text': result.text
}
for result in query_sqs
]
}
json_results = json.dumps(results)
return HttpResponse(json_results, content_type='application/json')
else:
results_page.query = clean_qstring
results_page.result_query = qstring
results_page.suggestion = suggestion
results_page.answers = []
for result in query_sqs:
results_page.answers.append(
(result.url, result.autocomplete, result.text)
)
return results_page.serve(request)
def ajax_solr_search(request, kind, model, order):
"""
Return JSON results for an AJAX query.
"""
if model == 'ALL':
model = ''
try:
request_id = request.REQUEST['request_id']
except KeyError:
request_id = ''
try:
query = request.REQUEST['name']
except KeyError:
query = ''
if model == '_':
model = None
results = SearchQuerySet().using("flyover").filter(text=query).models(
Doctor, Specialty, Service).order_by('last_name', 'specialty', 'name')
count = len(results)
suggestion = results.spelling_suggestion()
if count == 0 and suggestion is not None:
suggestion = str(suggestion).split('(')[-1].strip(')')
results = SearchQuerySet().using("flyover").filter(
text=suggestion).models(Doctor, Specialty,
Service).order_by('last_name', 'specialty',
'name')
count = len(results)
result_data = dict() # [Limit, Keys, Count, More]
for result in results:
model_name = result.model_name
app_name = result.app_label
model = models.get_model(app_name, model_name)
limit = None
if result.model_name not in result_data:
result_data[result.model_name] = [limit, [], 0, False]
if not limit or result_data[result.model_name][2] < limit:
try:
live = model.is_live(result.key)
except AttributeError:
live = True
if live:
result_data[result.model_name][1].append(result)
result_data[result.model_name][2] += 1
result_groups = [
ResultGroup(key, 0, 0, result_data[key][1], '')
for key in result_data.keys()
]
t = loader.get_template('search/results.xml')
c = RequestContext(
request, {
'request_id': request_id,
'query': query,
'count': count,
'result_groups': result_groups
})
return HttpResponse(t.render(c), mimetype='application/xml')
def get_queryset(self):
if self.request.method in SAFE_METHODS:
# Listing/searching.
# Query string parameters.
validate_request_on_app_id(self.request)
if "q" in self.request.query_params:
search_q = self.request.query_params["q"]
else:
# No query is provided. Full list is for authenticated requests only.
if self.request.user.is_authenticated():
return Video.objects.order_by("item_id")
else:
raise NotAuthenticated("")
if "a" in self.request.query_params:
aspect = self.request.query_params["a"]
if aspect not in ["3x4", "9x16"]:
raise ValidationError("")
else:
raise ValidationError("")
search_q = search_q.strip()
search_q = search_q.lower()
search_q = re.sub(r"\s+", " ", search_q)
if re.search(r"\w-(?!ic_\w+)", search_q) is not None:
search_q = search_q.replace("-", " ")
search_q = search_q.replace(".", "")
search_q = search_q.replace("'", "")
search_q = search_q.strip()
# Prevent responding with full list if the search query is empty.
if not search_q:
return Video.objects.none()
sqs = SearchQuerySet().models(Video)
query_is_categorical = False
ic_pattern = r"^([=\-]ic_\w+)+$"
if re.search(ic_pattern, search_q) is None:
# A regular search query.
sqs = sqs.filter(content=AutoQuery(search_q))
videos = [sr.object for sr in sqs.load_all()]
else:
# Category or categories, e.g. =ic_categ=ic_categ-ic_categ
query_is_categorical = True
qs = Video.objects.all()
qs_methods = {
"=": "filter",
"-": "exclude",
}
feed = search_q
while True:
m = re.search(r"^(.+?)\b(ic_\w+)", feed)
if m is None:
break
feed = feed[m.end():]
qs = getattr(qs, qs_methods[m.group(1)])(tags__name=m.group(2))
videos = list(qs)
if not videos and not query_is_categorical:
# Auto-correction.
sugg = sqs.spelling_suggestion()
if (sugg is not None) and ("suggestion" in sugg) and sugg["suggestion"]:
sqs = SearchQuerySet().models(Video)
sqs = sqs.filter(content=sugg["suggestion"][0])
videos = [sr.object for sr in sqs.load_all()]
# Exclude hidden.
videos = [video for video in videos if not video.is_hidden]
# Exclude by aspect restrictions.
if aspect == "3x4":
videos = [video for video in videos if not video.only_9x16]
else: # 9x16
videos = [video for video in videos if not video.only_3x4]
if "o" in self.request.query_params:
# Exclude by overlay.
overlay_only = get_bool_query_str_param(self.request.query_params["o"])
if overlay_only:
# Overlay only.
videos = [video for video in videos if video.is_overlay]
else:
# Non-overlay only.
videos = [video for video in videos if not video.is_overlay]
# Sort on good/bad with local randomization.
videos_good = [video for video in videos if video.is_good and not video.is_bad]
videos_other = [video for video in videos if not video.is_good and not video.is_bad]
videos_bad = [video for video in videos if video.is_bad and not video.is_good]
random.shuffle(videos_good)
random.shuffle(videos_other)
random.shuffle(videos_bad)
# Join.
videos = videos_good + videos_other# + videos_bad
if BOOST_SEARCH_RESULTS_ON_NUM_USES:
videos = boost_search_results_on_num_uses(videos)
return videos
else:
return Video.objects.all()
class SearchForm(forms.Form):
client_name = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
project_name = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
project_code = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
start_pay_period = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
end_pay_period = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
CHOICES = [('on', 'on'), ('off', 'off')]
is_billable = forms.ChoiceField(required=False,
choices=CHOICES,
widget=forms.RadioSelect())
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet().models(
ProjectPoProjects_bin)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
# We want "title: Foo AND (tags:bar OR tags:moof)"
sqs = self.searchqueryset.all()
str_client = ""
str_project_name = ""
str_project_code = ""
str_start_date = ""
str_start_date = ""
bill = ""
if self.cleaned_data['client_name']:
str_client = self.cleaned_data['client_name']
if self.cleaned_data['project_name']:
str_project_name = self.cleaned_data['project_name']
if self.cleaned_data['project_code']:
str_project_code = self.cleaned_data['project_code']
if self.cleaned_data['start_pay_period'] and self.cleaned_data[
'end_period']:
str_start_date = self.cleaned_data['start_pay_period']
str_end_date = self.cleaned_data['end_period']
#singles
if str_project_name:
sqs = self.searchqueryset.filter(project_name=str_project_name)
print(str_project_name)
if str_project_code:
sqs = self.searchqueryset.filter(project_code=str_project_code)
if str_client:
sqs = self.searchqueryset.filter(client_name=str_client)
if str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#doubles
if str_project_name and str_client:
sqs = self.searchqueryset.filter(project_name=str_project_name,
client_name=str_client)
if str_project_code and str_client:
sqs = self.searchqueryset.filter(project_code=str_project_code,
client_name=str_client)
if str_project_name and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
project_name=str_project_name).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
project_code=str_project_code).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(client_name=str_client).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#triplets
if str_project_name and str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
project_name=str_project_name, client_name=str_client).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
project_code=str_project_code, client_name=str_client).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_project_name and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
project_code=str_project_code,
project_name=str_project_name).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_project_name and str_client:
sqs = self.searchqueryset.filter(
project_code=str_project_code,
project_name=str_project_name).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(client_name=str_client).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#quadrlets
if str_client and str_project_name and str_project_code and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(
client_name=str_client,
project_code=str_project_code,
project_name=str_project_name).filter(
mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),
mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
return sqs
def no_query_found(self):
return self.searchqueryset.all()
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
def get_queryset(self):
def fix_layout(s):
return ''.join([_trans_table.get(c, c) for c in s])
q = self.request.GET.get('q')
city = self.request.GET.get('city')
if q:
if city == 'Все города':
results = SearchQuerySet().filter(content=q).values_list(
'company', flat=True)
else:
results = SearchQuerySet().filter(
content=q, city=city).values_list('company', flat=True)
if results.count() == 0:
_eng_chars = "~!@#$%^&qwertyuiop[]asdfghjkl;'zxcvbnm,./QWERTYUIOP{}ASDFGHJKL:\"|ZXCVBNM<>?"
_rus_chars = "ё!\"№;%:?йцукенгшщзхъфывапролджэячсмитьбю.ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭ/ЯЧСМИТЬБЮ,"
_trans_table = dict(zip(_eng_chars, _rus_chars))
if re.fullmatch('[a-zA-Z0-9\s]*', q):
self.q_punto = fix_layout(q)
if city == 'Все города':
results = SearchQuerySet().filter(
content=self.q_punto).values_list('company',
flat=True)
else:
results = SearchQuerySet().filter(
content=self.q_punto,
city=city).values_list('company', flat=True)
if results.count() == 0:
sqs = SearchQuerySet().auto_query(self.q_punto)
self.q_spell = sqs.spelling_suggestion()
if city == 'Все города':
results = SearchQuerySet().filter(
content=self.q_spell).values_list('company',
flat=True)
else:
results = SearchQuerySet().filter(
content=self.q_spell,
city=city).values_list('company', flat=True)
if results.count() == 0:
sqs = SearchQuerySet().auto_query(q)
self.q_spell = sqs.spelling_suggestion()
if city == 'Все города':
results = SearchQuerySet().filter(
content=self.q_spell).values_list('company',
flat=True)
else:
results = SearchQuerySet().filter(
content=self.q_spell,
city=city).values_list('company', flat=True)
if results.count() == 0:
if city == 'Все города':
results = Company.objects.filter(
name__icontains=q).values_list('pk', flat=True)
else:
results = Company.objects.filter(
name__icontains=q,
address__city__name=city).values_list('pk',
flat=True)
if city == 'Все города':
temp_id = Address.objects.filter(company__in=set(
results)).values('company').distinct().annotate(
Max('id')).values_list('id__max', flat=True)
else:
temp_id = Address.objects.filter(
company__in=set(results), city__name=city).values(
'company', 'city').distinct().annotate(
Max('id')).values_list('id__max', flat=True)
search_results = Address.objects.filter(pk__in=temp_id).order_by(
'-company__yellow', '-company__blue', '-company__priority',
'company__name')
self.count = search_results.count()
else:
search_results = ''
return search_results
class SearchForm(forms.Form):
client_name = forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
project_name = forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
project_code=forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
start_pay_period = forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
end_pay_period = forms.CharField(required=False, label=_('Search'),
widget=forms.TextInput(attrs={'type': 'search'}))
CHOICES=[('on','on'),
('off','off')]
is_billable = forms.ChoiceField(required=False,choices=CHOICES, widget=forms.RadioSelect())
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet().models(ProjectPoProjects_bin)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
# We want "title: Foo AND (tags:bar OR tags:moof)"
sqs=self.searchqueryset.all()
str_client=""
str_project_name=""
str_project_code=""
str_start_date=""
str_start_date=""
bill=""
if self.cleaned_data['client_name']:
str_client=self.cleaned_data['client_name']
if self.cleaned_data['project_name']:
str_project_name=self.cleaned_data['project_name']
if self.cleaned_data['project_code']:
str_project_code=self.cleaned_data['project_code']
if self.cleaned_data['start_pay_period'] and self.cleaned_data['end_period']:
str_start_date=self.cleaned_data['start_pay_period']
str_end_date=self.cleaned_data['end_period']
#singles
if str_project_name:
sqs = self.searchqueryset.filter(project_name=str_project_name)
print(str_project_name)
if str_project_code:
sqs = self.searchqueryset.filter(project_code=str_project_code)
if str_client:
sqs = self.searchqueryset.filter(client_name=str_client)
if str_start_date and str_end_date:
sqs = self.searchqueryset.filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#doubles
if str_project_name and str_client:
sqs = self.searchqueryset.filter(project_name=str_project_name,client_name=str_client)
if str_project_code and str_client:
sqs = self.searchqueryset.filter(project_code=str_project_code,client_name=str_client)
if str_project_name and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(project_name=str_project_name).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(project_code=str_project_code).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(client_name=str_client).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#triplets
if str_project_name and str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(project_name=str_project_name,client_name=str_client).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(project_code=str_project_code,client_name=str_client).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_project_name and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(project_code=str_project_code,project_name=str_project_name).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_project_code and str_project_name and str_client:
sqs = self.searchqueryset.filter(project_code=str_project_code,project_name=str_project_name).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
if str_client and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(client_name=str_client).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
#quadrlets
if str_client and str_project_name and str_project_code and str_start_date and str_end_date:
sqs = self.searchqueryset.filter(client_name=str_client,project_code=str_project_code,project_name=str_project_name).filter(mydate__gte=TeamOpr.datFormatTimeCard(str_start_date),mydate__lt=TeamOpr.datFormatTimeCard(str_end_date))
return sqs
def no_query_found(self):
return self.searchqueryset.all()
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
