def search(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
qs = model._default_manager.all()
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
data = ''.join([u'%s|%s\n' % (f.__unicode__(), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
try:
term = model.autocomplete_term_adjust(term)
except AttributeError:
pass
try:
search_fields = model.autocomplete_search_fields()
except AttributeError:
search_fields = AUTOCOMPLETE_SEARCH_FIELDS[model._meta.app_label][
model._meta.module_name]
except KeyError:
search_fields = ()
for word in term.split():
search = [
models.Q(**{smart_bytes(item): smart_bytes(word)})
for item in search_fields
]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
return qs
def autocomplete_lookup(request):
if not (request.user.is_active and request.user.is_staff):
return HttpResponseForbidden('<h1>Permission denied</h1>')
data = []
if request.method == 'GET':
if request.GET.has_key('term') and request.GET.has_key('app_label') and request.GET.has_key('model_name'):
term = request.GET.get("term")
app_label = request.GET.get('app_label')
model_name = request.GET.get('model_name')
model = models.get_model(app_label, model_name)
filters = {}
# FILTER
if request.GET.get('query_string', None):
for item in request.GET.get('query_string').split("&"):
if item.split("=")[0] != "t":
filters[smart_str(item.split("=")[0])]=smart_str(item.split("=")[1])
# SEARCH
qs = model._default_manager.all()
for bit in term.split():
search = [models.Q(**{smart_str(item):smart_str(bit)}) for item in model.autocomplete_search_fields()]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs = qs & search_qs
data = [{"value":f.pk,"label":u'%s' % get_label(f)} for f in qs[:10]]
label = ungettext(
'%(counter)s result',
'%(counter)s results',
len(data)) % {
'counter': len(data),
}
#data.insert(0, {"value":None,"label":label})
return HttpResponse(simplejson.dumps(data), mimetype='application/javascript')
data = [{"value":None,"label":_("Server error")}]
return HttpResponse(simplejson.dumps(data), mimetype='application/javascript')
def search (query):
contactos = Contacto.objects.filter (
reduce (operator.or_, [ models.Q(dato__icontains = bit) for bit in query.split() ])
)
search_fields = [
'nombre__icontains',
'apellidos__icontains',
'documento_identificacion__icontains',
'lugar_nacimiento__icontains',
'nacionalidad__icontains',
] # your search fields here
personasEncontradas = QuerySet(Persona)
for bit in query.split ():
or_queries = [models.Q(**{field_name: bit}) for field_name in search_fields]
other_qs = QuerySet(Persona)
other_qs.dup_select_related(personasEncontradas)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
personasEncontradas = personasEncontradas & other_qs
pe = []
for p in personasEncontradas:
pe.append (p)
for c in contactos:
if c.persona not in pe:
pe.append (c.persona)
return pe
def appquery(self, djp):
'''This function implements the search query.
The query is build using the search fields specifies in
:attr:`djpcms.views.appsite.ModelApplication.search_fields`.
It returns a queryset.
'''
qs = super(SearchView,self).appquery(djp)
request = djp.request
slist = self.appmodel.opts.search_fields
if request.method == 'GET':
data = dict(request.GET.items())
else:
data = dict(request.POST.items())
search_string = data.get(self.search_text,None)
if slist and search_string:
bits = smart_split(search_string)
#bits = search_string.split(' ')
for bit in bits:
bit = isexact(bit)
if not bit:
continue
or_queries = [Q(**{construct_search(field_name): bit}) for field_name in slist]
other_qs = QuerySet(self.appmodel.modelsearch())
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
return qs
def search (query, user):
datos_contactos = DatoContacto.objects.filter (
reduce (operator.or_, [ models.Q(dato__icontains = bit, contacto__usuario = user) for bit in query.split() ])
)
search_fields = ['domicilio', 'codPostal', 'poblacion', 'provincia', 'pais']
direccion_contactos = QuerySet(Direccion)
for bit in query.split ():
or_queries = [models.Q(**{'%s__icontains' % field_name: bit, 'contacto__usuario': user}) for field_name in search_fields]
other_qs = QuerySet(Direccion)
other_qs.dup_select_related(direccion_contactos)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
direccion_contactos = direccion_contactos & other_qs
search_fields = ['nombre', 'apellidos', ] # your search fields here
personasEncontradas = QuerySet(Contacto)
for bit in query.split ():
or_queries = [models.Q(**{'%s__icontains' % field_name: bit, 'usuario': user}) for field_name in search_fields]
other_qs = QuerySet(Contacto)
other_qs.dup_select_related(personasEncontradas)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
personasEncontradas = personasEncontradas & other_qs
pe = []
for p in personasEncontradas:
pe.append(p)
for c in datos_contactos:
if c.contacto not in pe:
pe.append(c.contacto)
for d in direccion_contactos:
if d.contacto not in pe:
pe.append(d.contacto)
return pe
def search(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
qs = model._default_manager.all()
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
data = ''.join([u'%s|%s\n' % (f.__unicode__(), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def get_query_set(self):
qs = self.manager.get_query_set()
lookup_params = self.params.copy() # a dictionary of the query string
for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
if i in lookup_params:
del lookup_params[i]
for key, value in lookup_params.items():
if not isinstance(key, str):
# 'key' will be used as a keyword argument later, so Python
# requires it to be a string.
del lookup_params[key]
lookup_params[smart_str(key)] = value
# Apply lookup parameters from the query string.
qs = qs.filter(**lookup_params)
# Use select_related() if one of the list_display options is a field
# with a relationship.
if self.lookup_opts.admin.list_select_related:
qs = qs.select_related()
else:
for field_name in self.lookup_opts.admin.list_display:
try:
f = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(f.rel, models.ManyToOneRel):
qs = qs.select_related()
break
# Set ordering.
if self.order_field:
qs = qs.order_by('%s%s' % ((self.order_type == 'desc' and '-' or ''), self.order_field))
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
if self.lookup_opts.admin.search_fields and self.query:
for bit in self.query.split():
or_queries = [models.Q(**{construct_search(field_name): bit}) for field_name in self.lookup_opts.admin.search_fields]
other_qs = QuerySet(self.model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
if self.opts.one_to_one_field:
qs = qs.complex_filter(self.opts.one_to_one_field.rel.limit_choices_to)
return qs
def foreignkey_autocomplete(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = [
models.Q(
**{
construct_search(smart_str(field_name)):
smart_str(bit)
}) for field_name in search_fields.split(',')
]
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_,
or_queries))
queryset = queryset & other_qs
data = ''.join([
six.u('%s|%s\n' % (to_string_function(f), f.pk))
for f in queryset
])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(data)
return HttpResponseNotFound()
def foreignkey_autocomplete(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = \
self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query
or object_pk):
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return '%s__istartswith' % field_name[1:]
elif field_name.startswith('='):
return '%s__iexact' % field_name[1:]
elif field_name.startswith('@'):
return '%s__search' % field_name[1:]
else:
return '%s__icontains' % field_name
model = models.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = \
[models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_,
or_queries))
queryset = queryset & other_qs
data = ''.join([u'%s|%s\n' % (to_string_function(f),
f.pk) for f in queryset])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(data)
return HttpResponseNotFound()
def foreignkey_autocomplete(self, request):
def _restrict_queryset(queryset, search_fields):
for bit in search_fields.split(','):
if bit[0] == '#':
key, val = bit[1:].split('=')
queryset = queryset.filter(**{key: val})
return queryset
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = []
for field_name in search_fields.split(','):
if field_name[0] == "#":
continue
or_queries.append(
models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)}))
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
queryset = _restrict_queryset(queryset, search_fields)
data = ''.join([u'%s|%s\n' % (
to_string_function(f), f.pk) for f in queryset])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(data)
return HttpResponseNotFound()
def get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
for word in term.split():
search = [models.Q(**{smart_str(item): smart_str(word)}) for item in model.autocomplete_search_fields()]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
return qs
def foreignkey_autocomplete(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = []
if query:
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
if len(queryset) > 0:
for f in queryset:
label = to_string_function(f)
thumb = f.get_thumbnail()
id = f.pk
data.append({'id': id, 'label': label, 'thumb': thumb})
else:
data.append({'id': '', 'label': 'No results found', 'thumb': ''})
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(simplejson.dumps(data), content_type="application/json")
return HttpResponseNotFound()
def foreignkey_autocomplete(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
# as of Django 1.1 there is an Admin Specific record filter:
# https://docs.djangoproject.com/en/1.1/ref/contrib/admin/#django.contrib.admin.ModelAdmin.queryset
try:
# See if there is a custom admin queryset:
queryset = model.queryset(request)
except:
# If not, then make our own:
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = [models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)}) for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
data = ''.join([six.u('%s|%s\n' % (to_string_function(f), f.pk)) for f in queryset])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(data)
return HttpResponseNotFound()
def get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
for word in term.split():
search = [
models.Q(**{smart_str(item): smart_str(word)})
for item in model.autocomplete_search_fields()
]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
return qs
def get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
try:
search_fields = model.autocomplete_search_fields()
except AttributeError:
search_fields = AUTOCOMPLETE_SEARCH_FIELDS[model._meta.app_label][model._meta.module_name]
except KeyError:
search_fields = ()
for word in term.split():
search = [models.Q(**{smart_str(item): smart_str(word)}) for item in search_fields]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
return qs
def search(self, request):
query = request.GET.get("q", None)
id = request.GET.get("id", None)
app_label = request.GET.get("app_label", None)
model_name = request.GET.get("model_name", None)
db_field_name = request.GET.get("db_field_name", None)
search_fields = self.related_search_fields[db_field_name]
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith("^"):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith("="):
return "%s__iexact" % field_name[1:]
elif field_name.startswith("@"):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
try:
if id:
qs = model.objects.filter(id=query)
else:
qs = model._default_manager.all()
for bit in query.split():
or_queries = [
models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)})
for field_name in search_fields
]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
except:
qs = ()
data = "".join([u"%s|%s\n" % (self.to_string_function(db_field_name)(f), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def search(request):
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
if app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
if not hasattr(model, 'can_search') \
or not model.can_search(request.user):
return HttpResponseForbidden()
if hasattr(model, 'get_search_fields'):
search_fields = model.get_search_fields()
qs = model._default_manager.all()
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
data = ''.join([u'%s|%s\n' % (f.__unicode__(), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def search(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get("q", None)
app_label = request.GET.get("app_label", None)
model_name = request.GET.get("model_name", None)
search_fields = request.GET.get("search_fields", None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith("^"):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith("="):
return "%s__iexact" % field_name[1:]
elif field_name.startswith("@"):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
qs = model._default_manager.all()
for bit in query.split():
or_queries = [
models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(",")
]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
data = "".join([u"%s|%s\n" % (to_string_function(f), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def get_query_set(self):
qs = self.root_query_set
lookup_params = self.params.copy() # a dictionary of the query string
for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
if i in lookup_params:
del lookup_params[i]
for key, value in lookup_params.items():
if not isinstance(key, str):
# 'key' will be used as a keyword argument later, so Python
# requires it to be a string.
del lookup_params[key]
lookup_params[smart_str(key)] = value
# if key ends with __in, split parameter into separate values
if key.endswith('__in'):
lookup_params[key] = value.split(',')
# Apply lookup parameters from the query string.
try:
qs = qs.filter(**lookup_params)
# Naked except! Because we don't have any other way of validating "params".
# They might be invalid if the keyword arguments are incorrect, or if the
# values are not in the correct type, so we might get FieldError, ValueError,
# ValicationError, or ? from a custom field that raises yet something else
# when handed impossible data.
except:
raise IncorrectLookupParameters
# Use select_related() if one of the list_display options is a field
# with a relationship.
if self.list_select_related:
qs = qs.select_related()
else:
for field_name in self.list_display:
try:
f = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(f.rel, models.ManyToOneRel):
qs = qs.select_related()
break
# Set ordering.
if self.order_field:
qs = qs.order_by('%s%s' % ((self.order_type == 'desc' and '-' or ''), self.order_field))
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
if self.search_fields and self.query:
for bit in self.query.split():
or_queries = [models.Q(**{construct_search(str(field_name)): bit}) for field_name in self.search_fields]
other_qs = QuerySet(self.model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
for field_name in self.search_fields:
if '__' in field_name:
qs = qs.distinct()
break
return qs
def foreignkey_autocomplete(self, request):
def _restrict_queryset(queryset, search_fields):
for bit in search_fields.split(','):
if bit[0] == '#':
key, val = bit[1:].split('=')
queryset = queryset.filter(**{key: val})
return queryset
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = []
for field_name in search_fields.split(','):
if field_name[0] == "#":
continue
or_queries.append(
models.Q(
**{
construct_search(smart_str(field_name)):
smart_str(bit)
}))
other_qs = QuerySet(model)
other_qs.dup_select_related(queryset)
other_qs = other_qs.filter(reduce(operator.or_,
or_queries))
queryset = queryset & other_qs
queryset = _restrict_queryset(queryset, search_fields)
data = ''.join([
u'%s|%s\n' % (to_string_function(f), f.pk)
for f in queryset
])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except:
pass
else:
data = to_string_function(obj)
return HttpResponse(data)
return HttpResponseNotFound()
def get_query_set(self):
qs = self.manager.get_query_set()
lookup_params = self.params.copy() # a dictionary of the query string
for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR,
IS_POPUP_VAR):
if i in lookup_params:
del lookup_params[i]
for key, value in lookup_params.items():
if not isinstance(key, str):
# 'key' will be used as a keyword argument later, so Python
# requires it to be a string.
del lookup_params[key]
lookup_params[smart_str(key)] = value
# Apply lookup parameters from the query string.
qs = qs.filter(**lookup_params)
# Use select_related() if one of the list_display options is a field
# with a relationship.
if self.lookup_opts.admin.list_select_related:
qs = qs.select_related()
else:
for field_name in self.lookup_opts.admin.list_display:
try:
f = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(f.rel, models.ManyToOneRel):
qs = qs.select_related()
break
# Set ordering.
if self.order_field:
qs = qs.order_by(
'%s%s' %
((self.order_type == 'desc' and '-' or ''), self.order_field))
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
if self.lookup_opts.admin.search_fields and self.query:
for bit in self.query.split():
or_queries = [
models.Q(**{construct_search(field_name): bit})
for field_name in self.lookup_opts.admin.search_fields
]
other_qs = QuerySet(self.model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
if self.opts.one_to_one_field:
qs = qs.complex_filter(
self.opts.one_to_one_field.rel.limit_choices_to)
return qs
def get_query_set(self):
qs = self.root_query_set
lookup_params = self.params.copy() # a dictionary of the query string
for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
if i in lookup_params:
del lookup_params[i]
for key, value in lookup_params.items():
if not isinstance(key, str):
# 'key' will be used as a keyword argument later, so Python
# requires it to be a string.
del lookup_params[key]
lookup_params[smart_str(key)] = value
# if key ends with __in, split parameter into separate values
if key.endswith('__in'):
lookup_params[key] = value.split(',')
# Apply lookup parameters from the query string.
try:
qs = qs.filter(**lookup_params) #IGNORE:W0142
# Naked except! Because we don't have any other way of validating "params".
# They might be invalid if the keyword arguments are incorrect, or if the
# values are not in the correct type, so we might get FieldError, ValueError,
# ValicationError, or ? from a custom field that raises yet something else
# when handed impossible data.
except:
raise IncorrectLookupParameters
# Use select_related() if one of the list_display options is a field
# with a relationship.
if self.list_select_related:
qs = qs.select_related()
else:
for field_name in self.list_display:
try:
f = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(f.rel, models.ManyToOneRel):
qs = qs.select_related()
break
# Set ordering.
if self.order_field:
qs = qs.order_by('%s%s' % ((self.order_type == 'desc' and '-' or ''), self.order_field))
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
# Salva: ñapa para las Macs + Ips. Si pudieramos crear una vista en mysql
# no seria necesario todo esto
if self.model == Macip:
if self.search_fields and self.query: # tenemos busqueda. A saco
qs=Mac.objects.all() #IGNORE:E1101
qs = qs.filter(Q(ip__ip__contains=str(self.query))|Q(mac__icontains=str(self.query))|Q(switch__iexact=str(self.query)))\
.extra(select={'ip': '`rtg_ip`.`ip`',
'ultima_modificacion_ip': '`rtg_ip`.`ultima_modificacion`',
'dns': '`rtg_ip`.`dns`'})
# aplicamos los filtros y el ordering
qs = qs.filter(**lookup_params) #IGNORE:W0142
if self.order_field:
qs = qs.order_by('%s%s' % ((self.order_type == 'desc' and '-' or ''), self.order_field))
return qs
if self.search_fields and self.query:
for bit in self.query.split():
or_queries = [models.Q(**{construct_search(field_name): bit}) for field_name in self.search_fields] #IGNORE:W0142
other_qs = QuerySet(self.model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
for field_name in self.search_fields:
if '__' in field_name:
qs = qs.distinct()
break
return qs
def get_query_set(self):
qs = self.root_query_set
lookup_params = self.params.copy() # a dictionary of the query string
for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR,
IS_POPUP_VAR):
if i in lookup_params:
del lookup_params[i]
for key, value in lookup_params.items():
if not isinstance(key, str):
# 'key' will be used as a keyword argument later, so Python
# requires it to be a string.
del lookup_params[key]
lookup_params[smart_str(key)] = value
# if key ends with __in, split parameter into separate values
if key.endswith('__in'):
lookup_params[key] = value.split(',')
# Apply lookup parameters from the query string.
try:
qs = qs.filter(**lookup_params)
# Naked except! Because we don't have any other way of validating "params".
# They might be invalid if the keyword arguments are incorrect, or if the
# values are not in the correct type, so we might get FieldError, ValueError,
# ValicationError, or ? from a custom field that raises yet something else
# when handed impossible data.
except:
raise IncorrectLookupParameters
# Use select_related() if one of the list_display options is a field
# with a relationship.
if isinstance(self.list_select_related, (tuple, list)):
qs = qs.select_related(*self.list_select_related)
elif self.list_select_related:
qs = qs.select_related()
else:
fields = []
for field_name in self.list_display:
try:
f = self.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
pass
else:
if isinstance(f.rel, models.ManyToOneRel):
fields.append(f.name)
if fields:
qs = qs.select_related(*fields)
# Set ordering.
if self.order_field:
qs = qs.order_by(
'%s%s' %
((self.order_type == 'desc' and '-' or ''), self.order_field))
# Apply keyword searches.
def construct_search(field_name):
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
if self.search_fields and self.query:
for bit in self.query.split():
or_queries = [
models.Q(**{construct_search(field_name): bit})
for field_name in self.search_fields
]
other_qs = QuerySet(self.model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
for field_name in self.search_fields:
if '__' in field_name:
qs = qs.distinct()
break
if self.opts.one_to_one_field:
qs = qs.complex_filter(
self.opts.one_to_one_field.rel.limit_choices_to)
return qs
def search(self, request):
""" Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin """
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
field_name = request.GET.get('field_name', None)
related_fields = [field[:-3] for field in request.GET
if field[-3:] == "_pk" and request.GET[field]]
# remove all garbage and injections
from django.template.defaultfilters import slugify
search_fields = [f for f in search_fields.split(',') if f==slugify(f)]
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
qs = self.get_autocomplete_queryset(request, field_name)
if qs is None:
qs = model._default_manager.all()
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
# filter out by related ids
qs = qs.filter(**dict([(str(field), request.GET[field+"_pk"]) for field in related_fields]))
# sort rows directly containing query be the first
from django.utils.datastructures import SortedDict
# we do not was to dig into __ relations here. Only first model fields go for smart sorting.
smartsorted_fields = []
for field_name in search_fields:
# add qualifying table
try:
model._meta.get_field_by_name(field_name)
except:
continue
smartsorted_fields.append(field_name)
for field_name in smartsorted_fields:
full_field_name = model._meta.db_table+"."+field_name
qs = qs.extra(select=SortedDict([
('_%s_match' % field_name,
"CASE WHEN lower("+full_field_name+")=lower(%s) THEN 1 ELSE 0 END"),
('_%s_contains' % field_name,
# can not put percents here because of http://code.djangoproject.com/ticket/6400
"CASE WHEN "+full_field_name+" LIKE %s THEN 1 ELSE 0 END"),
]), select_params = [query, '%'+query+'%'])
ordering = [ ['-_%s_match' % field_name, '-_%s_contains' % field_name]
for field_name in smartsorted_fields]
# flatten list of sorting options
ordering = sum(ordering, [])
qs = qs.order_by(*ordering)
qs = qs[:25]
# sometimes we want to present suggestions in a special way
def ajax_str(obj):
if hasattr(obj, 'ajax_str') and callable(obj.ajax_str):
return obj.ajax_str()
else:
return unicode(obj)
data = ''.join([u'%s|%s\n' % (ajax_str(f), f.pk) for f in qs])
return HttpResponse(data, mimetype='text/plain')
return HttpResponseNotFound()
