def get(self, request): # pylint: disable=E1101 # Instance of <class> has no <member> # pylint: disable=W0142 # Used * or ** magic # import from selectable locally so it's not a hard dependency from selectable.forms import AutoCompleteWidget from selectable.registry import registry data = request.GET model_class = get_model(data['app_label'], data['model_name']) if not model_class: raise Http404('"{0}" model not found'.format(data['model_name'])) lookup_name = data.get('lookup', None) if lookup_name: lookup_class = registry.get(lookup_name) else: lookup_class_name = u'Flyedit{app_label}{model_name}Lookup'.format( app_label=data['app_label'].title(), model_name=model_class._meta.object_name) lookup_name = ('flyedit-{0}'.format(lookup_class_name.lower())) lookup_class = registry.get(lookup_name) if not lookup_class: # create a default lookup class on the fly from selectable.base import ModelLookup first_charfield = (f for f in model_class._meta.fields if isinstance(f, CharField)).next() search_field = '{0}__icontains'.format(first_charfield.name) lookup_class = type( lookup_class_name.encode('ascii'), (ModelLookup,), {'model': model_class, 'search_fields': [search_field]}) registry.register(lookup_class) print lookup_class.model print lookup_class.search_fields # Use a dummy form class to render just the auto-complete field class Form(forms.Form): autocomplete = forms.CharField( label=u'', widget=AutoCompleteWidget(lookup_class)) return HttpResponse(Form()._html_output( normal_row='<li class="new item">%(field)s</li>', error_row='', row_ender='', help_text_html='', errors_on_separate_row=False))
def get_productos_lookup_widget(ruc_empresa): """ Construye un widget lookup para autobus """ print 'get_productos_lookup_widget - Para empresa', ruc_empresa class ProductoLookup(ModelLookup): model = core_models.Producto search_fields = ('nombre__icontains', 'titulo__icontains', 'codigo_sku__icontains') filters = {'estado': estado_activo, 'ruc_empresa':ruc_empresa} def get_item_label(self, item): return u'%s, %s' % (item.codigo_sku, item.nombre) try: registry.register(ProductoLookup) except Exception as e: print 'SELECTABLE ERROR', e return selectable.AutoCompleteSelectWidget(lookup_class=ProductoLookup, attrs={'placeholder': __.PH_PRODUCTO, 'class':'form-control'})
def get_cliente_lookup_widget(ruc_empresa): """ Construye un widget lookup para autobus """ print 'get_cliente_lookup_widget - Para empresa', ruc_empresa class ClienteLookup(ModelLookup): model = impd_models.ImpdCliente search_fields = ('identificacion__icontains', 'razon_social__icontains') filters = {'estado': estado_activo, 'ruc_empresa':ruc_empresa} def get_item_label(self, item): return u'%s, %s' % (item.identificacion, item.razon_social) try: registry.register(ClienteLookup) except: pass return ClientSearchWidget(lookup_class=ClienteLookup, attrs={'placeholder': __.PH_CLIENTE, 'class':'search_input', 'size':'30'})
def get_factura_config_lookup_widget(ruc_empresa): """ Construye un widget lookup para autobus """ print 'get_factura_config_lookup_widget - Para empresa', ruc_empresa class FacturaConfigLookup(ModelLookup): model = impd_models.ImpdFacturaConfiguracion search_fields = ('descripcion__icontains', 'establecimiento__icontains') filters = {'estado': estado_activo, 'ruc_empresa':ruc_empresa} def get_item_label(self, item): return u'%s, %s' % (item.establecimiento, item.descripcion) try: registry.register(FacturaConfigLookup) except: pass return ConfigSearchWidget(lookup_class=FacturaConfigLookup, attrs={'placeholder': __.PH_CONFIG, 'class':'search_input', 'size':'30'})
def get_destinatario_lookup_widget(ruc_empresa): """ Construye un widget lookup para autobus """ print 'get_destinatario_lookup_widget - Para empresa', ruc_empresa class DestinarioLookup(ModelLookup): model = impd_models.ImpdGRDestinatario search_fields = ('identificacion_destinatario__icontains', 'razon_social_destinatario__icontains') filters = {'estado': estado_activo, 'ruc_empresa':ruc_empresa} def get_item_label(self, item): return u'%s' % item.get_descripcion() try: registry.unregister(DestinarioLookup) except: pass registry.register(DestinarioLookup) return DestinatarioSearchWidget(lookup_class=DestinarioLookup, attrs={'placeholder': __.PH_DESTINATARIO, 'class':'big-field', 'size':'30'})
def formfield_for_dbfield(self, db_field, **kwargs): if isinstance(db_field, models.ForeignKey): request = kwargs.get("request") related_modeladmin = self.admin_site._registry.get(db_field.rel.to) can_change_related = bool(related_modeladmin and related_modeladmin.has_add_permission(request)) if (isinstance(db_field, models.ForeignKey) and db_field.name in self.related_search_fields): class_name = self.__class__.__name__.lower() model_name = db_field.name name = u'%s-%s' % (class_name, model_name) class Lookup(ModelLookup): model = db_field.rel.to search_fields = ['%s__icontains' % f for f in self.related_search_fields[db_field.name]] def _name(cls): return name name = classmethod(_name) def get_query(self, request, term): qs = self.get_queryset() if term: for bit in term.split(): or_queries = [models.Q(**{field_name: smart_str(bit)}) for field_name in self.search_fields] qs = qs.filter(reduce(operator.or_, or_queries)) return qs try: registry.register(Lookup) except LookupAlreadyRegistered: pass if db_field.name in self.related_combobox: kwargs['widget'] = AutoComboboxSelectEditWidget(db_field.rel, self.admin_site, Lookup, can_change_related=can_change_related) else: kwargs['widget'] = AutoCompleteSelectEditWidget(db_field.rel, self.admin_site, Lookup, can_change_related=can_change_related) #elif isinstance(db_field, models.ForeignKey): #kwargs['widget'] = SelectEditWidget(db_field.rel, self.admin_site, #can_change_related=can_change_related) return super(SelectableAdminMixin, self).formfield_for_dbfield(db_field, **kwargs)
def get_producto_factura_lookup_widget(ruc_empresa): """ Construye un widget lookup para autobus """ print 'get_productos_lookup_widget - Para empresa', ruc_empresa class ProductoFacturaLookup(ModelLookup): model = impd_models.ImpdProducto search_fields = ('descripcion__icontains', 'codigo_principal__icontains', 'codigo_secundario__icontains') filters = {'estado': estado_activo, 'ruc_empresa':ruc_empresa} def get_item_label(self, item): return u'%s, %s' % (item.codigo_principal, item.descripcion) try: registry.unregister(ProductoFacturaLookup) except: pass try: registry.register(ProductoFacturaLookup) except: pass return ProductSearchWidget(lookup_class=ProductoFacturaLookup, attrs={'placeholder': __.PH_PRODUCTO, 'class':'big-field', 'size':'30'})
from selectable.base import ModelLookup from selectable.registry import registry from localidade.models import Cidade class CidadeChainedLookup(ModelLookup): model = Cidade search_fields = ('nome__icontains', ) def get_query(self, request, term): results = super(CidadeChainedLookup, self).get_query(request, term) estado = request.GET.get('estado', '') if estado: results = results.filter(estado=estado) return results # def get_item_label(self, item): # return "%s, %s" % (item.nome, item.estado) registry.register(CidadeChainedLookup)
for result_type, lookup in self.lookups.items(): for item in lookup.get_query(request, q)[:10]: label = lookup.get_item_label(item) value = lookup.get_item_value(item) results.append(SearchResult(result_type, item, label, value)) results.sort(key=lambda a: a.value) return results def get_item_label(self, item): return item.label def get_item_id(self, item): return '{0}-{1}'.format(item.result_type, item.item.pk) def get_item(self, value): try: result_type, pk = value.split('-', 1) return self.lookups[result_type].get_item(pk) except (ValueError, KeyError): return None def get_item_value(self, item): return item.value if item else '' registry.register(BusinessLookup) registry.register(ProjectLookup) registry.register(UserLookup) registry.register(QuickLookup)
search_fields = ('code__icontains', ) filters = {'donor_code_type': DonorCode.T1, } class T3DonorCodeLookup(ModelLookup): model = DonorCode search_fields = ('code__icontains', ) filters = {'donor_code_type': DonorCode.T3, } class ItemCategoryLookup(ModelLookup): model = ItemCategory search_fields = ('name__icontains', ) class CatalogItemLookup(ModelLookup): model = CatalogItem search_fields = ('item_code__icontains', 'description__icontains') def get_item_label(self, item): if item.donor_id: return '{} ({})'.format(item.description, item.donor) else: return item.description registry.register(T1DonorCodeLookup) registry.register(T3DonorCodeLookup) registry.register(ItemCategoryLookup) registry.register(CatalogItemLookup)
return suggestions(idiom=IDIOM_GRISCHUN, direction=SEARCH_DIRECTION_RUM_DEU, term=term, limit=10) class LookupBidirGri(LookupBase): def get_query(self, request, term): suggRum = suggestions(idiom=IDIOM_GRISCHUN, direction=SEARCH_DIRECTION_RUM_DEU, term=term, limit=7) suggDeu = suggestions(idiom=IDIOM_GRISCHUN, direction=SEARCH_DIRECTION_DEU_RUM, term=term, limit=7) sugg = suggRum + suggDeu sugg.sort() return sugg registry.register(LookupDeuVal) registry.register(LookupValDeu) registry.register(LookupBidirVal) registry.register(LookupDeuPut) registry.register(LookupPutDeu) registry.register(LookupBidirPut) registry.register(LookupDeuGri) registry.register(LookupGriDeu) registry.register(LookupBidirGri)
from selectable.base import ModelLookup from selectable.registry import registry from models import School class SchoolLookup(ModelLookup): model = School search_field = 'name__icontains' registry.register(SchoolLookup)
model = models.Endpoint search_fields = ('name__icontains', ) related_filter = 'assessment_id' def get_query(self, request, term): return super().get_query(request, term)\ .distinct('name') class EndpointIdByAssessmentLookup(EndpointByAssessmentLookup): def get_item_value(self, obj): return obj.id registry.register(ExperimentByStudyLookup) registry.register(AnimalGroupByExperimentLookup) registry.register(RelatedExperimentCASLookup) registry.register(RelatedAnimalGroupLifestageExposedLookup) registry.register(RelatedAnimalGroupLifestageAssessedLookup) registry.register(RelatedEndpointSystemLookup) registry.register(RelatedEndpointOrganLookup) registry.register(RelatedEndpointEffectLookup) registry.register(RelatedEndpointEffectSubtypeLookup) registry.register(ExpChemicalLookup) registry.register(ExpCasLookup) registry.register(ExpChemSourceLookup) registry.register(ExpGlpLookup) registry.register(EndpointSystemLookup) registry.register(EndpointOrganLookup)
from selectable.base import ModelLookup from selectable.registry import registry from catalog.models import City, County class CityLookup(ModelLookup): model = City search_fields = ('name__icontains', ) class CountyLookup(ModelLookup): model = County search_fields = ('name__icontains', ) registry.register(CityLookup) registry.register(CountyLookup)
class AnimalStudyLookup(StudyLookup): filters = { 'bioassay': True, } class EpiStudyLookup(StudyLookup): filters = { 'epi': True, } class EpimetaStudyLookup(StudyLookup): filters = { 'epi_meta': True, } class InvitroStudyLookup(StudyLookup): filters = { 'in_vitro': True, } registry.register(StudyLookup) registry.register(AnimalStudyLookup) registry.register(EpiStudyLookup) registry.register(EpimetaStudyLookup) registry.register(InvitroStudyLookup)
## """override buggy method from SelectWidget""" ## old_values = [ unicode(i) for i in (initial or [u''])] ## new_values = [ unicode(i) for i in (data or [u''])] ## return not set(new_values) == set(old_values) class DnaLookup(ModelLookup): """Lookup definition for selectable auto-completion fields""" model = M.DnaComponent search_fields = ('displayId__startswith', 'name__icontains') def get_item_id(self, item): return item.pk registry.register(DnaLookup) class OligoLookup(ModelLookup): model = M.OligoComponent search_fields = ('displayId__startswith', 'name__icontains') def get_item_id(self, item): return item.pk registry.register(OligoLookup) class SequencingOligoLookup(OligoLookup): filters = {'componentType': T.ocSequencing}
from django.contrib.admin import ModelAdmin, site, register from django.contrib.auth.models import User from selectable.base import ModelLookup from selectable.forms import AutoCompleteSelectWidget, AutoCompleteSelectField from selectable.registry import registry from . import models class UserLookup(ModelLookup): model = User search_fields = ('username__icontains', ) registry.register(UserLookup) class LibraryAdminForm(forms.ModelForm): user = AutoCompleteSelectField( UserLookup, widget=AutoCompleteSelectWidget(UserLookup), required=True, ) owner = AutoCompleteSelectField( UserLookup, widget=AutoCompleteSelectWidget(UserLookup), required=True, ) class Meta(object):
from selectable.base import ModelLookup from selectable.registry import registry from busca.models import Busca class BuscaLookup(ModelLookup): model = Busca search_fields = ('email__icontains', ) registry.register(BuscaLookup)
try: item = Edition.objects.get(pk=value) except (ValueError, Edition.DoesNotExist): item = None return item class SubjectLookup(ModelLookup): model = Subject search_fields = ('name__icontains',) def get_query(self, request, term): return super(SubjectLookup, self).get_query( request, term ).annotate(Count('works')).order_by('-works__count') class EditionNoteLookup(ModelLookup): model = EditionNote search_fields = ('note__icontains',) def create_item(self, value): new_note, created = EditionNote.objects.get_or_create(note=value) new_note.save() return new_note registry.register(OwnerLookup) registry.register(WorkLookup) registry.register(PublisherNameLookup) registry.register(EditionLookup) registry.register(SubjectLookup) registry.register(EditionNoteLookup) registry.register(EbookLookup)
from selectable.base import ModelLookup from selectable.registry import registry from users.models import Profile class ProfileLookup(ModelLookup): model = Profile search_fields = ( 'name__icontains', 'user__email__icontains', ) def get_item_value(self, item): """Display for currently selected item""" return item.display_name def get_item_label(self, item): """Display for choice listings""" return item.display_name def get_queryset(self): qs = super(ProfileLookup, self).get_queryset() qs.order_by('name') return qs registry.register(ProfileLookup)
from django.contrib.auth.models import User from selectable.base import ModelLookup from selectable.registry import registry from example.core.models import Fruit, City class FruitLookup(ModelLookup): model = Fruit search_fields = ('name__icontains', ) registry.register(FruitLookup) class OwnerLookup(ModelLookup): model = User search_fields = ('username__icontains', ) registry.register(OwnerLookup) class CityLookup(ModelLookup): model = City search_fields = ('name__icontains', ) def get_query(self, request, term): results = super(CityLookup, self).get_query(request, term) state = request.GET.get('state', '') if state:
term = functools.reduce( lambda x, y: re.sub(y[0], y[1], x), self.sub_patterns, term, ) term = self.join_pattern.join(term) return super(FlexModelLookup, self).get_query(request, term) class DepartmentLookup(ModelLookup): model = Department search_fields = ('name__icontains',) class InstitutionLookup(FlexModelLookup): model = Institution search_fields = ('name__iregex',) sub_patterns = [ ['[\s\-,]', ''], ] join_pattern = '[\s\-,]*' for lookup in [DepartmentLookup, InstitutionLookup]: try: registry.register(lookup) except LookupAlreadyRegistered: pass
def get_query(self, request, term): try: pk = int(request.GET.get('assessment_id')) self.filters = {'assessment_id': pk} except Exception: return self.model.objects.none() return super(EndpointByAssessmentLookup, self).get_query(request, term) def get_item_label(self, obj): return u"{} | {} | {} | {}".format(obj.animal_group.experiment.study, obj.animal_group.experiment, obj.animal_group, obj) def get_item_value(self, obj): return '<a href="{}" target="_blank">{}</a>'.format( obj.get_absolute_url(), self.get_item_label(obj)) registry.register(SpeciesLookup) registry.register(StrainLookup) registry.register(ExperimentCASLookup) registry.register(AnimalGroupLifestageExposedLookup) registry.register(AnimalGroupLifestageAssessedLookup) registry.register(DoseUnitsLookup) registry.register(EndpointSystemLookup) registry.register(EndpointOrganLookup) registry.register(EndpointEffectLookup) registry.register(EndpointStatisticalTestLookup) registry.register(EndpointByStudyLookup) registry.register(EndpointByAssessmentLookup)
print u'No results' return results def get_item_label(self, item): return unicode(item) # name_flat = ' '.join(item.givenName) # surname_flat = ' '.join(item.surname) # return u'%s %s' % (name_flat, surname_flat) def get_item_id(self, item): return item.id class ValidationReportLookup(LookupBase): pass registry.register(PersonLookup) registry.register(ValidationReportLookup) from django import forms class MetadataForm(forms.ModelForm): class Meta: model = metadataInfoType_model widgets = {'metadataCreator' : AutoCompleteSelectMultipleWidget(lookup_class=PersonLookup)} class MetadataInline(ReverseInlineModelAdmin): form = MetadataForm class ResourceForm(forms.ModelForm): class Meta: model = resourceInfoType_model
from selectable.base import ModelLookup from selectable.registry import registry from nc.models import Agency class AgencyLookup(ModelLookup): model = Agency search_fields = ( 'name__icontains', ) registry.register(AgencyLookup)
from selectable.base import ModelLookup from selectable.registry import registry from cities.models import Region class RegionLookup(ModelLookup): model = Region search_fields = ('name__icontains', ) filters = {'country__code': "CA", } def get_item_value(self, item): return item.name def get_item_id(self, item): return item.id if not 'event-regionlookup' in registry._registry: registry.register(RegionLookup)
return results def get_item_label(self, item): return u"%s, %s" % (item, item.parent) class MeasureLookup(SimpleNameLookup): model = Measure class WorkTypeLookup(ModelLookup): model = WorkType search_fields = ('name__icontains',) def get_query(self, request, term): results = super(WorkTypeLookup, self).get_query(request, term) results = results.exclude(parent=None) return results def get_item_label(self, item): return u"%s, %s" % (item, item.parent) try: registry.register(PartnerTypeLookup) registry.register(WorkTypeLookup) registry.register(GearLookup) registry.register(QualityLookup) registry.register(ExperienceLookup) registry.register(PartnerLookup) registry.register(CitizenshipLookup) registry.register(PartnerIdLookup) registry.register(MeasureLookup) registry.register(GoodsLookup) registry.register(DevProfileIdLookup) except LookupAlreadyRegistered: pass
search_fields = ('label__icontains', 'reference__icontains') class MediumLookup(ModelLookup): model = ContactMedium search_fields = ('label__icontains', ) class ActivityLookup(ModelLookup): model = ActivityNomenclature search_fields = ('path__icontains', ) filters = {'level': settings.ACTIVITY_NOMENCLATURE_LOOKUP_LEVEL} try: registry.register(LocationLookup) except LookupAlreadyRegistered: pass try: registry.register(AreaLookup) except LookupAlreadyRegistered: pass try: registry.register(MediumLookup) except LookupAlreadyRegistered: pass try: registry.register(ActivityLookup) except LookupAlreadyRegistered: pass
from selectable.base import ModelLookup from selectable.registry import registry from sabr.models import Master class FruitLookup(ModelLookup): model = Fruit search_field = 'name__icontains' class PlayerLookup(ModelLookup) model = Master search_field = 'playerid__icontains' registry.register(PlayerLookup)
from selectable.base import LookupBase from selectable.registry import registry from .models import Neighbourhood, City class NeighbourhoodLookup(LookupBase): def get_query(self, request, term): neighbourhoods = Neighbourhood.objects.all() cities = City.objects.all() if term.strip() != '': neighbourhoods = neighbourhoods.filter(name__icontains=term) cities = cities.filter(name__icontains=term) cities = [city for city in cities] neighbourhoods = [neighbourhood for neighbourhood in neighbourhoods] locations = cities + neighbourhoods return locations registry.register(NeighbourhoodLookup)
from selectable.base import ModelLookup from selectable.registry import registry from demo.prpv.models import TOrganismeTaxo, Fruit class ScientificNameLookup(ModelLookup): model = TOrganismeTaxo search_field = 'nom_scientifique__icontains' class FruitLookup(ModelLookup): model = Fruit search_field = 'name__icontains' registry.register(FruitLookup) #registry.register(ScientificNameLookup)
search_fields = ("health_outcome__icontains", ) related_filter = "protocol__study__assessment_id" class MetaResultExposureNameLookup(RelatedDistinctStringLookup): model = models.MetaResult distinct_field = "exposure_name" search_fields = ("exposure_name__icontains", ) related_filter = "protocol__study__assessment_id" class MetaProtocolLookup(RelatedLookup): model = models.MetaProtocol search_fields = ("name__icontains", ) related_filter = "study__assessment_id" class ExposureLookup(RelatedDistinctStringLookup): model = models.MetaResult distinct_field = "exposure_name" search_fields = ("exposure_name__icontains", ) related_filter = "protocol__study__assessment_id" registry.register(MetaResultByStudyLookup) registry.register(MetaResultByAssessmentLookup) registry.register(MetaResultHealthOutcomeLookup) registry.register(MetaResultExposureNameLookup) registry.register(MetaProtocolLookup) registry.register(ExposureLookup)
from selectable.base import ModelLookup from selectable.registry import registry, LookupAlreadyRegistered from app import models class BeerTypeLookup(ModelLookup): model = models.BeerType search_fields = ('name__icontains',) class BrewerLookup(ModelLookup): model = models.Brewer search_fields = ('name__icontains',) try: registry.register(BeerTypeLookup) except LookupAlreadyRegistered: pass try: registry.register(BrewerLookup) except LookupAlreadyRegistered: pass
# -*- coding: utf-8 -*- from selectable.base import ModelLookup from selectable.registry import registry from chercheurs.models import Chercheur class ChercheurLookup(ModelLookup): model = Chercheur search_field = 'nom__icontains' registry.register(ChercheurLookup)
obj.animal_group.experiment.study, obj.animal_group.experiment, obj.animal_group, obj ) def get_item_value(self, obj): return self.get_item_label(obj) class EndpointByAssessmentLookupHtml(EndpointByAssessmentLookup): def get_item_value(self, obj): return '<a href="{}" target="_blank">{}</a>'.format( obj.get_absolute_url(), self.get_item_label(obj) ) registry.register(ExperimentCASLookup) registry.register(AnimalGroupLifestageExposedLookup) registry.register(AnimalGroupLifestageAssessedLookup) registry.register(EndpointSystemLookup) registry.register(EndpointOrganLookup) registry.register(EndpointEffectLookup) registry.register(EndpointEffectSubtypeLookup) registry.register(EndpointStatisticalTestLookup) registry.register(EndpointByStudyLookup) registry.register(EndpointByAssessmentLookup) registry.register(EndpointByAssessmentLookupHtml)
from __future__ import unicode_literals from selectable.base import ModelLookup from selectable.registry import registry from .models import Element class ElementLookup(ModelLookup): model = Element search_fields = ('text__icontains', ) registry.register(ElementLookup)
from selectable.base import ModelLookup from selectable.registry import registry from .models import Taxonomy class TaxonomyLookup(ModelLookup): model = Taxonomy search_fields = ('name__icontains', ) registry.register(TaxonomyLookup)
return self.model.objects.none() return super(EndpointByAssessmentLookup, self).get_query(request, term) def get_item_label(self, obj): return u"{} | {} | {} | {}".format( obj.animal_group.experiment.study, obj.animal_group.experiment, obj.animal_group, obj ) def get_item_value(self, obj): return '<a href="{}" target="_blank">{}</a>'.format( obj.get_absolute_url(), self.get_item_label(obj) ) registry.register(SpeciesLookup) registry.register(StrainLookup) registry.register(ExperimentCASLookup) registry.register(AnimalGroupLifestageExposedLookup) registry.register(AnimalGroupLifestageAssessedLookup) registry.register(DoseUnitsLookup) registry.register(EndpointSystemLookup) registry.register(EndpointOrganLookup) registry.register(EndpointEffectLookup) registry.register(EndpointStatisticalTestLookup) registry.register(EndpointByStudyLookup) registry.register(EndpointByAssessmentLookup)
from selectable.base import ModelLookup from selectable.registry import registry from .models import User class UserLookup(ModelLookup): model = User search_fields = ('email__icontains', 'name__icontains') registry.register(UserLookup)
from django.contrib.auth.models import User from selectable.base import ModelLookup from selectable.registry import registry from core.models import Fruit, City class FruitLookup(ModelLookup): model = Fruit search_fields = ('name__icontains', ) registry.register(FruitLookup) class OwnerLookup(ModelLookup): model = User search_fields = ('username__icontains', ) registry.register(OwnerLookup) class CityLookup(ModelLookup): model = City search_fields = ('name__icontains', ) def get_query(self, request, term): results = super().get_query(request, term) state = request.GET.get('state', '')