def test_enable_flag_boolean_exists(self): FlagState.objects.create( name="DB_FLAG", condition="boolean", value="False" ) self.assertFalse(flag_enabled("DB_FLAG")) enable_flag("DB_FLAG") self.assertTrue(flag_enabled("DB_FLAG"))
def create(self, **obj_data): obj = super().create(**obj_data) if flag_enabled('PUSHING_SUBDOMAIN_TO_ROUTE53'): if obj.subdomain: self.push_to_route53(obj) if flag_enabled('GIVING_DEFAULT_ITEMS_WHEN_PROFILE_CREATED'): self.give_items(obj) return obj
def get_context_data(self, **kwargs): context = super(ComplaintLandingView, self).get_context_data(**kwargs) ccdb_status_json = self.get_ccdb_status_json() context.update(self.is_ccdb_out_of_date(ccdb_status_json)) context.update({ 'technical_issues': flag_enabled('CCDB_TECHNICAL_ISSUES'), 'ccdb_content_updates': flag_enabled('CCDB_CONTENT_UPDATES') }) return context
def create_flag(request): """ Create a new flag. This will add a FlagState object with a custom name and a boolean: False condition """ if request.method == 'POST': form = NewFlagForm(request.POST, initial={ 'condition': 'path matches', 'value': '/foo', 'required': False, }) if form.is_valid(): form.save() if flag_enabled('WAGTAILFLAGS_ADMIN_BIG_LIST'): return redirect('{flags_list}#{flag_name}'.format( flags_list=resolve_url('wagtailflags:list'), flag_name=form.instance.name)) else: return redirect('wagtailflags:flag_index', name=form.instance.name) else: form = NewFlagForm() context = dict(form=form) return render(request, 'wagtailflags/flags/create_flag.html', context)
def edit_condition(request, name, condition_pk=None): flag = get_flags().get(name) try: condition = FlagState.objects.get(pk=condition_pk) except FlagState.DoesNotExist: condition = None if request.method == 'POST': form = FlagStateForm(request.POST, initial={'name': name}, instance=condition) if form.is_valid(): form.save() if flag_enabled('WAGTAILFLAGS_ADMIN_BIG_LIST'): return redirect('{flags_list}#{flag_name}'.format( flags_list=resolve_url('wagtailflags:list'), flag_name=form.instance.name)) else: return redirect('wagtailflags:flag_index', name=form.instance.name) else: form = FlagStateForm(initial={'name': name}, instance=condition) context = { 'flag': flag, 'form': form, 'condition_str': str(condition), 'condition_pk': condition_pk, } return render(request, 'wagtailflags/flags/edit_condition.html', context)
def get_page_set(self): if flag_enabled('ELASTICSEARCH_FILTERABLE_LISTS'): categories = self.cleaned_data.get('categories') # If no categories are submitted by the form if categories == []: # And we have defined a prexisting set of categories # to limit results by Using CategoryFilterableMixin if self.filterable_categories not in ([], None): # Search for results only within the provided categories categories = ref.get_category_children( self.filterable_categories) return FilterablePagesDocumentSearch( prefix=self.filterable_root, topics=self.cleaned_data.get('topics'), categories=categories, authors=self.cleaned_data.get('authors'), to_date=self.cleaned_data.get('to_date'), from_date=self.cleaned_data.get('from_date'), title=self.cleaned_data.get('title'), archived=self.cleaned_data.get('archived'), order_by=self.get_order_by()).search() else: query = self.generate_query() return self.filterable_pages.filter(query).distinct().order_by( '-date_published' )
def user_successfully_activated(sender, user, request, **kwargs): logger.info("Received user activation signal for %s", user.username) # Log the user in, if this isn't the result of a password reset # The password reset form automatically logs the user in and activates. # But when it does so, it sends None for the request. # So when the user activates without resetting the password, the behavior # should be the same - the user should be automatically logged in. if request: auth_login(request, user) if flag_enabled("SEND_WELCOME_EMAIL"): text_body_template = loader.get_template( "emails/welcome_email_body.txt") text_body_message = text_body_template.render() html_body_template = loader.get_template( "emails/welcome_email_body.html") html_body_message = html_body_template.render() subject_template = loader.get_template( "emails/welcome_email_subject.txt") subject_message = subject_template.render() # Send welcome email message = EmailMultiAlternatives( subject=subject_message.rstrip(), body=text_body_message, from_email=settings.DEFAULT_FROM_EMAIL, to=[user.email], reply_to=[settings.DEFAULT_FROM_EMAIL], ) message.attach_alternative(html_body_message, "text/html") message.send()
def suggest(self, request): suggestion = SearchQuerySet().spelling_suggestion(self.search_term) if (suggestion and suggestion != self.search_term and request.GET.get('correct', '1') == '1' and flag_enabled('ASK_SEARCH_TYPOS', request=request)): self.queryset = self.query_base.filter(content=suggestion) self.search_term, self.suggestion = suggestion, self.search_term
def populate(cls, upc): product_data = None if flag_enabled('USE_LIMITED_API_CALLS'): API_klass_list = [ Open_Food_Facts, ] else: API_klass_list = [ Open_Food_Facts, UPC_Database, EAN_Data, EAN_Search ] if settings.MOCK_API_CALLS: API_klass_list = [ Mock_API, ] for klass in API_klass_list: try: product_data = klass(upc=upc).execute() break except ProductNotFoundException: print('not found') except Exception as err: print(err) # continue anyway if product_data is None: print('not found anywhere - create placeholder') product_data = cls.create_placeholder_product(upc) p = Product(**product_data) p.save() return p
def importar_csv(request): #Importa datos de análisis context = {} error_log = {} if request.method != 'POST': #Si no se envía un post, el acceso es denegado raise Http404 user_logged = IFCUsuario.objects.get(user = request.user) # Obtener el usuario logeado #Si el rol del usuario no es servicio al cliente, director o superusuario, el acceso es denegado if not ('importar_csv' in request.session['permissions']): raise Http404 response_code = 0 if request.method == 'POST': if flag_enabled('Importar_Analisis', request=request): form = ImportarAnalisisForm(request.POST, request.FILES) if form.is_valid(): error_log, aux = handle_upload_document(request.FILES['csv_analisis'],) else: raise Http404 error_count = len(error_log) context = { 'error_count' : error_count, 'error_log' : error_log, } return render(request, 'ventas/importar_csv_resultado.html', context)
def flag_index(request, name): flag = get_flags().get(name) # If there's a database boolean condition, fetch it and treat it as a # on/off switch if 'enable' in request.GET or 'disable' in request.GET: db_boolean_condition = next( (c for c in flag.conditions if c.condition == 'boolean' and getattr(c, 'obj', None) is not None), None) if db_boolean_condition is None: boolean_condition_obj = FlagState.objects.create( name=name, condition='boolean', value='True') else: boolean_condition_obj = db_boolean_condition.obj if 'enable' in request.GET and not bool_enabled(flag): boolean_condition_obj.value = True elif 'disable' in request.GET and bool_enabled(flag): boolean_condition_obj.value = False boolean_condition_obj.save() if flag_enabled('WAGTAILFLAGS_ADMIN_BIG_LIST'): return redirect('{flags_list}#{flag_name}'.format( flags_list=resolve_url('wagtailflags:list'), flag_name=name)) else: return redirect('wagtailflags:flag_index', name=name) context = { 'flag': flag, } return render(request, 'wagtailflags/flags/flag_index.html', context)
def is_ccdb_out_of_date(self, res_json): """Parse JSON describing CCDB status to determine if it is out of date. Returns a dict with two keys: data_down and narratives_down. Values for both of these are booleans. """ data_down = flag_enabled('CCDB_TECHNICAL_ISSUES') narratives_down = False # show notification starting fifth business day data has not been # updated M-Th, data needs to have been updated 6 days ago; F-S, # preceding Monday now = datetime.now() weekday = datetime.weekday(now) delta = weekday if weekday > 3 else 6 four_business_days_ago = (now - timedelta(delta)).strftime("%Y-%m-%d") try: if res_json['_meta']['last_indexed'] < four_business_days_ago: data_down = True elif (res_json['_meta']['last_updated'] < four_business_days_ago): narratives_down = True except (TypeError, KeyError): logger.exception("CCDB JSON status not in expected format.") return { 'data_down': data_down, 'narratives_down': narratives_down, }
def get_context(self, request, *args, **kwargs): context = super().get_context(request, *args, **kwargs) form_data, has_active_filters = self.get_form_data(request.GET) queryset = self.get_filterable_queryset() # flag check to enable or disable archive filter options if flag_enabled('HIDE_ARCHIVE_FILTER_OPTIONS', request=request): has_archived_posts = False else: has_archived_posts = queryset.filter(is_archived='yes').count() > 0 form = self.get_form_class()( form_data, filterable_pages=queryset, wagtail_block=self.get_filterable_list_wagtail_block(), filterable_root=self.get_filterable_root(), filterable_categories=self.filterable_categories) context.update({ 'filter_data': self.process_form(request, form), 'get_secondary_nav_items': get_secondary_nav_items, 'has_active_filters': has_active_filters, 'has_archived_posts': has_archived_posts, }) return context
def suggest(self, request): suggestion = SearchQuerySet().spelling_suggestion(self.search_term) if (suggestion and suggestion != self.search_term and request.GET.get('correct', '1') == '1' and flag_enabled('ASK_SEARCH_TYPOS', request=request)): self.queryset = self.query_base.filter(content=suggestion) self.search_term, self.suggestion = suggestion, self.search_term
def is_ccdb_out_of_date(self, res_json): """Parse JSON describing CCDB status to determine if it is out of date. Returns a dict with two keys: data_down and narratives_down. Values for both of these are booleans. """ data_down = flag_enabled('CCDB_TECHNICAL_ISSUES') narratives_down = False # show notification starting fifth business day data has not been # updated M-Th, data needs to have been updated 6 days ago; F-S, # preceding Monday now = datetime.now() weekday = datetime.weekday(now) delta = weekday if weekday > 3 else 6 four_business_days_ago = (now - timedelta(delta)).strftime("%Y-%m-%d") try: if res_json['stats']['last_updated'] < four_business_days_ago: data_down = True elif (res_json['stats']['last_updated_narratives'] < four_business_days_ago): narratives_down = True except KeyError: logger.exception("CCDB JSON status not in expected format.") return { 'data_down': data_down, 'narratives_down': narratives_down, }
def get_edit_handler(cls): if hasattr(cls, 'edit_handler'): return cls.edit_handler.bind_to(model=cls) editor_panels = [ ObjectList(cls.content_panels + [ AdminOnlyFieldPanel('coa_global', classname="admin-only-field") ], heading='Content'), ObjectList(cls.notes_content_panel, heading='Notes') ] try: if flag_enabled('SHOW_EXTRA_PANELS'): editor_panels += (PermissionObjectList(cls.promote_panels, heading='SEO'), PermissionObjectList(cls.settings_panels, heading='Settings')) except ProgrammingError as e: print("some problem, maybe with flags") pass edit_handler = TabbedInterface(editor_panels) return edit_handler.bind_to(model=cls)
def _get_meta(): # Hard code noon Eastern Time zone since that is where it is built body = { # size: 0 here to prevent taking too long since we only needed max_date "size": 0, "aggs": { "max_date": { "max": { "field": "date_received", "format": "yyyy-MM-dd'T'12:00:00-05:00" } }, "max_indexed_date": { "max": { "field": "date_indexed", "format": "yyyy-MM-dd'T'12:00:00-05:00" } }, "max_narratives": { "filter": { "term": { "has_narrative": "true" } }, "aggs": { "max_date": { "max": { "field": ":updated_at", } } } } } } max_date_res = _get_es().search(index=_COMPLAINT_ES_INDEX, body=body) count_res = _get_es().count(index=_COMPLAINT_ES_INDEX, doc_type=_COMPLAINT_DOC_TYPE) result = { "license": "CC0", "last_updated": max_date_res["aggregations"]["max_date"]["value_as_string"], "last_indexed": max_date_res["aggregations"]["max_indexed_date"]["value_as_string"], "total_record_count": count_res["count"], "is_data_stale": _is_data_stale( max_date_res["aggregations"]["max_date"]["value_as_string"]), "is_narrative_stale": _is_data_stale( from_timestamp(max_date_res["aggregations"]["max_narratives"] ["max_date"]["value"])), "has_data_issue": bool(flag_enabled('CCDB_TECHNICAL_ISSUES')) } return result
def request_site_recrawl(sender, **kwargs): try: if flag_enabled('PING_GOOGLE_ON_PUBLISH'): response = requests.get(GOOGLE_URL, {'sitemap': SITEMAP_URL}) response.raise_for_status() logger.info('Pinged Google after job page publication.') except Exception: logger.exception('Pinging Google after job page publication failed.')
def render_to_response(self, context, **response_kwargs): response = super(CCDB5MainView, self).render_to_response(context, **response_kwargs) show_trends = flag_enabled('CCDB5_TRENDS') response.set_cookie('showTrends', 'show' if show_trends else 'hide') return response
def get_messaging_emails(self, request): if not self.email and flag_enabled("MESSAGING_FLAG", request=request): return [ user.email for user in self.organisers.all() if user.profile.allow_messaging ] elif self.email: return [self.email]
def get_context_data(self, **kwargs): context = super(ComplaintLandingView, self).get_context_data(**kwargs) complaint_source = getattr(settings, 'COMPLAINT_LANDING_STATS_SOURCE', None) if complaint_source: ccdb_status_json = self.get_ccdb_status_json(complaint_source) context.update(self.is_ccdb_out_of_date(ccdb_status_json)) context.update({ 'technical_issues': flag_enabled('CCDB_TECHNICAL_ISSUES'), 'ccdb_content_updates': flag_enabled('CCDB_CONTENT_UPDATES'), }) return context
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 portal_topic_page(self, request): self.portal_category = None if flag_enabled('ELASTICSEARCH_DSL_ASK'): self.query_base = AnswerPageDocument.search().filter( 'match', portal_topics=self.portal_topic.heading) return self.get_results_es7(request) else: self.query_base = SearchQuerySet().filter( portal_topics=self.portal_topic.heading, language=self.language) return self.get_results(request)
def get_context_data(self, **kwargs): context = super(LandingView, self).get_context_data(**kwargs) context['base_template'] = BASE_TEMPLATE if 'demo_json' in kwargs: res_json = get_narratives_json(demo_json=kwargs['demo_json']) else: res_json = get_narratives_json() context['stats'] = get_stats(res_json) (context['data_down'], context['narratives_down']) = is_data_not_updated(res_json) context['technical_issues'] = flag_enabled('CCDB_TECHNICAL_ISSUES') return context
def lista_empresas(request): empresas = {} context = {} user_logged = IFCUsuario.objects.get(user=request.user) # obtener usuario que inició sesión #if not(user_logged.rol.nombre == "Ventas" or user_logged.rol.nombre=="SuperUser" or user_logged.rol.nombre == "Director"): # verificar que el usuario pertenezca al grupo con permisos if not ('visualizar_empresa' in request.session['permissions']): raise Http404 if flag_enabled('Modulo_Empresas', request=request): empresas = Empresa.objects.filter(estado=True) context = {'empresas':empresas} return render(request, 'cuentas/lista_empresas.html', context)
def request_site_recrawl(sender, **kwargs): try: if flag_enabled('PING_GOOGLE_ON_PUBLISH'): response = requests.get(GOOGLE_URL, {'sitemap': SITEMAP_URL}) response.raise_for_status() logger.info( 'Pinged Google after job page publication.' ) except Exception: logger.exception( 'Pinging Google after job page publication failed.' )
def exportar_datos(request): user_logged = IFCUsuario.objects.get(user=request.user) # Obtener el tipo de usuario logeado if not ('descargar_csv' in request.session['permissions']): raise Http404 if request.session.get('success_code',None) == None: request.session['success_code'] = 0 context = {'success_code': request.session['success_code'],} request.session['success_code'] = 0 if flag_enabled('Modulo_Catalogo', request=request): context = {'success_code': request.session['success_code'], } else: context = {} return render(request, 'ventas/exportar_datos.html',context)
def email_popup(request): for label, urls in settings.EMAIL_POPUP_URLS.items(): if request.path not in urls: continue feature_flag = 'EMAIL_POPUP_{}'.format(label.upper()) if not flag_enabled(feature_flag, request=request): continue template = 'organisms/email-popup/{}.html'.format(label) context = {'popup_label': label} return mark_safe(render_to_string(template, context=context)) return ''
def email_popup(request): for label, urls in settings.EMAIL_POPUP_URLS.items(): if request.path not in urls: continue feature_flag = 'EMAIL_POPUP_{}'.format(label.upper()) if not flag_enabled(feature_flag, request=request): continue template = 'organisms/email-popup/{}.html'.format(label) context = {'popup_label': label, 'request': request} return mark_safe(render_to_string(template, context=context)) return ''
def get_context_data(self, **kwargs): context = super(ComplaintLandingView, self).get_context_data(**kwargs) complaint_source = getattr( settings, 'COMPLAINT_LANDING_STATS_SOURCE', None ) if complaint_source: ccdb_status_json = self.get_ccdb_status_json(complaint_source) context.update(self.is_ccdb_out_of_date(ccdb_status_json)) context['technical_issues'] = flag_enabled('CCDB_TECHNICAL_ISSUES') return context
def get_page_set(self): if flag_enabled('ELASTICSEARCH_FILTERABLE_LISTS'): return EventFilterablePagesDocumentSearch( prefix=self.filterable_root, topics=self.cleaned_data.get('topics'), categories=self.cleaned_data.get('categories'), authors=self.cleaned_data.get('authors'), to_date=self.cleaned_data.get('to_date'), from_date=self.cleaned_data.get('from_date'), title=self.cleaned_data.get('title'), order_by=self.get_order_by()).search() else: query = self.generate_query() return self.filterable_pages.filter(query).distinct().order_by( '-date_published' )
def get_page_set(self): if flag_enabled('ELASTICSEARCH_FILTERABLE_LISTS'): return EnforcementActionFilterablePagesDocumentSearch( prefix=self.filterable_root, topics=self.cleaned_data.get('topics'), categories=self.cleaned_data.get('categories'), authors=self.cleaned_data.get('authors'), to_date=self.cleaned_data.get('to_date'), from_date=self.cleaned_data.get('from_date'), title=self.cleaned_data.get('title'), statuses=self.cleaned_data.get('statuses'), products=self.cleaned_data.get('products')).search() else: query = self.generate_query() return self.filterable_pages.filter(query).distinct().order_by( '-initial_filing_date' )
def delete_condition(request, name, condition_pk): flag = get_flags().get(name) condition = get_object_or_404(FlagState, pk=condition_pk) if request.method == 'POST': condition.delete() if flag_enabled('WAGTAILFLAGS_ADMIN_BIG_LIST'): return redirect('{flags_list}#{flag_name}'.format( flags_list=resolve_url('wagtailflags:list'), flag_name=name)) else: return redirect('wagtailflags:flag_index', name=name) context = { 'flag': flag, 'condition_str': str(condition), 'condition_pk': condition.pk, } return render(request, 'wagtailflags/flags/delete_condition.html', context)
def ver_catalogo(request): context = {} if request.session.get('success_code', None) == None: request.session['success_code'] = 0 user_logged = IFCUsuario.objects.get(user = request.user) # Obtener el tipo de usuario logeado #if user_logged.rol.nombre == "Director" or user_logged.rol.nombre == "SuperUser" or user_logged.rol.nombre == "Ventas": if 'consultar_catalogo_analisis' in request.session['permissions']: if flag_enabled('Modulo_Catalogo', request=request): analisis = Analisis.objects.all().exclude(nombre="Otro") paises = Pais.objects.all() context = { 'analisis': analisis, 'success_code' : request.session['success_code'], 'paises' : paises } request.session['success_code'] = 0 return render(request, 'ventas/catalogo.html', context) else: # Si el rol del usuario no es ventas no puede entrar a la página raise Http404
def ver_cotizaciones(request): #Vista de cotizaciones del cliente. Esta funcion muestra todas las cotizaciones consultadas en una tabla. context = {} if request.session._session: usuario_log = IFCUsuario.objects.filter(user=request.user).first() #Obtener usuario que inició sesión #if usuario_log.rol.nombre == "Cliente" or usuario_log.rol.nombre == "Ventas" or usuario_log.rol.nombre == "Director" or usuario_log.rol.nombre == "SuperUser": if ('consultar_cotizacion' in request.session['permissions'] or 'visualizar_cotizacion' in request.session['permissions'] ): if flag_enabled('Modulo_Cotizaciones', request=request): if usuario_log.rol.nombre == "Ventas": cotizaciones = Cotizacion.objects.filter(usuario_v=usuario_log) #Obtener cotizaciones de usuario ventas analisis = Analisis.objects.all().exclude(nombre="Otro") clientes = IFCUsuario.objects.filter(rol__nombre="Cliente") #Obtener usuarios tipo cliente context = { 'analisis': analisis, 'cotizaciones': cotizaciones, 'clientes': clientes } elif usuario_log.rol.nombre == "Cliente": cotizaciones = Cotizacion.objects.filter(usuario_c=usuario_log) #Obtener cotizaciones de usuario cliente context = { 'cotizaciones': cotizaciones, } elif usuario_log.rol.nombre == "SuperUser" or usuario_log.rol.nombre == "Director" or usuario_log.rol.nombre == "Soporte" or usuario_log.rol.nombre == "Gerente" or usuario_log.rol.nombre == "Facturacion": cotizaciones = Cotizacion.objects.all() analisis = Analisis.objects.all() clientes = IFCUsuario.objects.filter(rol__nombre="Cliente") #Obtener usuarios tipo cliente context = { 'analisis': analisis, 'cotizaciones': cotizaciones, 'clientes': clientes } return render(request, 'ventas/cotizaciones.html', context) else: raise Http404
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': {'slug': 'ask-cfpb-search-results', 'query': SearchQuerySet().models(EnglishAnswerProxy)}, 'es': {'slug': 'respuestas', 'query': SearchQuerySet().models(SpanishAnswerProxy)} } _map = language_map[language] sqs = _map['query'] clean_query = Clean(request.GET.get('q', '')) clean_qstring = clean_query.query_string.strip() qstring = clean_qstring query_sqs = sqs.filter(content=clean_query) results_page = get_object_or_404( AnswerResultsPage, language=language, slug=_map['slug'] ) # 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)