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 test_user_saved_professional_delete(
user: User,
client_with_token: Client,
user_saved_professionals: QuerySet,
):
"""Should be able to delete a user saved professionals."""
obj = user_saved_professionals.filter(user=user).first()
response = client_with_token.delete(
reverse("user-saved-professionals-detail", args=[obj.pk]))
assert response.status_code == 204
assert user_saved_professionals.filter(pk=obj.pk).count() == 0
def test_user_professional_closed_periods_delete(
user: User,
client_with_token: Client,
professional_closed_periods: QuerySet,
):
"""Should be able to delete a user professional closed period."""
obj = professional_closed_periods.filter(professional__user=user).first()
response = client_with_token.delete(
reverse("user-professional-closed-periods-detail", args=[obj.pk]))
assert response.status_code == 204
assert professional_closed_periods.filter(pk=obj.pk).count() == 0
def test_sent_unread_message_delete(
user: User,
client_with_token: Client,
messages: QuerySet,
):
"""Should be able to delete a unread sent message."""
obj = messages.filter(sender=user).first()
response = client_with_token.delete(
reverse("messages-sent-detail", args=[obj.pk]))
assert response.status_code == 204
assert messages.filter(pk=obj.pk).count() == 0
def test_user_service_schedule_delete(
user: User,
client_with_token: Client,
service_schedules: QuerySet,
):
"""Should be able to delete a user service schedule."""
obj = service_schedules.filter(service__professional__user=user).first()
response = client_with_token.delete(
reverse("user-service-schedule-detail", args=[obj.pk]))
assert response.status_code == 204
assert service_schedules.filter(pk=obj.pk).count() == 0
def test_user_languages_delete(
user: User,
client_with_token: Client,
user_languages: QuerySet,
):
"""Should be able to update a user language."""
lang = user_languages.filter(user=user).first()
response = client_with_token.delete(
reverse("user-languages-detail", args=[lang.pk]))
assert response.status_code == 204
assert user_languages.filter(user=user).count() == 0
def queryset(self, request: Any, queryset: QuerySet) -> Optional[QuerySet]:
today = datetime.date.today()
year, week, _ = today.isocalendar()
if self.value() == "thisWeek":
return queryset.filter(store_date__week=week,
store_date__year=year)
if self.value() == "nextWeek":
return queryset.filter(store_date__week=week + 1,
store_date__year=year)
def apply_filters(self, bands: QuerySet, filters: QueryDict) -> QuerySet:
city_id = filters.get('city')
style_id = filters.get('style')
if city_id:
bands = bands.filter(city_id=city_id).all()
if style_id:
bands = bands.filter(styles__in=[style_id]).all()
return bands
def test_user_settings_delete(
user: User,
client_with_token: Client,
user_settings: QuerySet,
):
"""Should be able to delete a user settings."""
obj = user_settings.filter(user=user).first()
response = client_with_token.delete(
reverse("user-settings-detail", args=[obj.pk]))
assert response.status_code == 204
assert user_settings.filter(user=user).count() == 0
def test_user_location_delete(
user: User,
client_with_token: Client,
user_locations: QuerySet,
):
"""Should be able to delete a user language."""
obj = user_locations.filter(user=user).first()
response = client_with_token.delete(
reverse("user-locations-detail", args=[obj.pk]))
assert response.status_code == 204
assert user_locations.filter(user=user, pk=obj.pk).count() == 0
def test_user_review_comment_delete(
user: User,
client_with_token: Client,
review_comments: QuerySet,
):
"""Should be able to delete a user review."""
obj = review_comments.filter(user=user).first()
response = client_with_token.delete(
reverse("user-review-comments-detail", args=[obj.pk]))
assert response.status_code == 204
assert review_comments.filter(pk=obj.pk).count() == 0
def test_user_service_photos_delete(
user: User,
client_with_token: Client,
services: QuerySet,
):
"""Should be able to delete a user service photo."""
obj = services.filter(professional__user=user).first().photos.first()
response = client_with_token.delete(
reverse("user-service-photos-detail", args=[obj.pk]))
assert response.status_code == 204
assert not services.filter(professional__user=user).first().photos.count()
def test_validate_parent(admin: User, messages: QuerySet):
"""Should validate the message parent message."""
messages = messages.filter(sender=admin)
message = messages[0]
message.parent = messages[1]
with pytest.raises(ValidationError):
validate_message_parent(message)
message.is_read = True
with pytest.raises(ValidationError):
validate_message_parent(message)
message.parent = messages.filter(recipient=admin).first()
validate_message_parent(message)
def test_user_order_reminders_delete(
user: User,
client_with_token: Client,
order_reminders: QuerySet,
):
"""Should be able to delete a user professional tag."""
obj: OrderReminder = order_reminders.filter(recipient=user).first()
response = client_with_token.delete(
reverse("user-order-reminders-detail", args=[obj.pk]))
assert response.status_code == 204
assert not order_reminders.filter(pk=obj.pk).count()
def search(request, **kwargs):
rg = request.REQUEST.get
group = kwargs.get("group", False)
q = rg("q", None)
if not q:
return HttpResponseRedirect("%s/publications/" % settings.URLBASE)
search_fields = ['title', 'abstract', 'authorship__author__last_name',
'publication_name', 'book_title']
q = rg("q", "")
if not q.split() == []:
for bit in q.split():
or_queries = [Q(**{'%s__search' % field_name: bit}) for field_name
in search_fields]
qs = QuerySet(Publication)
qs = qs.filter(reduce(operator.or_, or_queries)).distinct()
else:
qs = Publication.objects.all()[:0]
if group:
g = Group.objects.get(acronym=group)
qs = qs.filter(groupship__group=g)
css = g.defaultcss
logo = g.get_logo_url()
del kwargs['group']
else:
css = settings.DEFAULT_CSS
logo = settings.DEFAULT_LOGO
g = False
kwargs["queryset"] = qs
kwargs["allow_empty"] = True
#query = Q(title__search=q) | \
# Q(abstract__search=q) | \
# Q(authorship__author__last_name__search=q) | \
# Q(publication_name__search=q)
# #Q(editorship__editor__last_name__search=q)
#if rg("year"):
# query &= Q(year__exact=rg("year"))
#if rg("journal"):
# query &= Q(journal__icontains=rg("journal", ""))
#if rg("author"):
# query &= Q(authorship__author__last_name__exact=rg("author"))
d = request.GET.copy()
if "page" in d:
del d["page"]
if "submit" in d:
del d["submit"]
kwargs["extra_context"] = {"query": urlencode(d), "query_readable": d["q"],
"group": g, "css": css, "logo": logo}
return object_list(request, **kwargs)
def apply_filters(self, musicians: QuerySet,
filters: QueryDict) -> Optional[QuerySet]:
'''Extract all filters'''
city_id = filters.get('city')
instrument_id = filters.get('instrument')
'''Apply filters'''
if city_id:
musicians = musicians.filter(city_id=city_id).all()
if instrument_id:
instrument = Instrument.objects.filter(id=instrument_id).first()
musicians = musicians.filter(instruments__in=[instrument]).all()
return musicians
def search(terms):
query = terms.replace("+"," ")
search_results = []
if query:
for clazz, search_fields, filter_terms in class_search_fields:
or_query=Q()
other_qs = QuerySet(clazz) # your class here
for bit in query.split():
or_queries = [Q(**{'%s__icontains' % field_name: bit}) for field_name in search_fields]
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
search_results.append((clazz, other_qs.filter(**filter_terms)))
return search_results
def filter_queryset(self, request, queryset: QuerySet, view):
try:
if 'user__id' in request.query_params.keys():
queryset = queryset.filter(
author__user__id=request.query_params['user__id'])
if 'user__email' in request.query_params.keys():
queryset = queryset.filter(
author__user__email=request.query_params['user__email'])
if 'user__username' in request.query_params.keys():
queryset = queryset.filter(author__user__username=request.
query_params['user__username'])
if 'author__id' in request.query_params.keys():
queryset = queryset.filter(
author__id=request.query_params['author__id'])
if 'author__ORCID' in request.query_params.keys():
queryset = queryset.filter(
author__ORCID=request.query_params['author__ORCID'])
if 'article__id' in request.query_params.keys():
queryset = queryset.filter(
article__id=request.query_params['article__id'])
if 'article__title' in request.query_params.keys():
queryset = queryset.filter(
article__title=request.query_params['article__title'])
if 'is_email_author' in request.query_params.keys():
queryset = queryset.filter(
is_email_author=request.query_params['is_email_author'])
except Exception as e:
queryset = queryset.none()
return queryset
def test_user_service_prices_delete(
user: User,
client_with_token: Client,
services: QuerySet,
):
"""Should be able to delete a user professional tag."""
# pylint: disable=unused-argument
obj = services.filter(professional__user=user).first().price
response = client_with_token.delete(
reverse("user-service-prices-detail", args=[obj.pk]))
assert response.status_code == 204
with pytest.raises(ObjectDoesNotExist):
_ = services.filter(professional__user=user).first().price
def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet:
"""
Adjust the queryset based on the selection
:param request: The incoming request
:param queryset: The original queryset
:return: The modified queryset
"""
val = self.value()
if val == 'slow':
return queryset.filter(response_ts__gt=F('request_ts') + timedelta(seconds=1))
elif val == 'no':
return queryset.filter(response='')
else:
return queryset
def test_professionals_list(
client_with_token: Client,
professionals: QuerySet,
user_languages: QuerySet,
):
"""Should return a professionals list."""
obj = professionals.filter().first()
response = client_with_token.get(reverse("professionals-list"))
data = response.json()
assert response.status_code == 200
assert data["count"] == 4
entry = data["results"][0]
assert entry["name"] == obj.name
lang = user_languages.filter(user__pk=entry["user"]["id"]).first()
assert entry["user"]["languages"][0]["language"] == lang.language
def collect_and_remove(objs, using):
collector = Collector(using=using)
with transaction.atomic():
now = timezone.now()
collector.collect(objs)
for qs in collector.fast_deletes:
if issubclass(qs.model, SoftDeletableModel):
# only touch related objects which aren't already softdeleted
# to prevent clobbering the removed date on already removed objects
qs.filter(removed__isnull=True).update(removed=now)
for model, instances in collector.data.items():
if issubclass(model, SoftDeletableModel):
pks = [obj.pk for obj in instances]
qs = QuerySet(model=model, using=collector.using)
qs.filter(pk__in=pks).filter(removed__isnull=True).update(removed=now)
def leaf_filter(self, query):
'''
Should not be called directly, use filter()
Executes a query over leaf instances of MapObj
allows for some complex / cross model queries
ex:
q1 = Q(name__icontains='commons')
q2 = Q(abbreviation__icontains='map')
MapObj.objects.filter(q1|q2)
returns:
[<Group: Ferrell Commons>, <Building: Libra Commons>, <Building: Math & Physics>, ...]
'''
# grab all the models that extend MapObj
if not MapQuerySet.campus_models:
MapQuerySet.campus_models = []
for ct in ContentType.objects.filter(app_label="campus"):
model = models.get_model("campus", ct.model)
if issubclass(model, campus.models.MapObj):
MapQuerySet.campus_models.append(model)
# return queryset containing MapObj's
mob_query = Q(pk="~~~ no results ~~~")
for m in self.campus_models:
if m == campus.models.MapObj: continue
try:
qs = QuerySet(m)
results = qs.filter(query)
for o in results:
mob_query = mob_query | Q(id=o.mapobj_ptr_id)
except FieldError:
continue
return mob_query
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 filter(self, *args, **kwargs):
'''
allows to query over all MapObj's, incliding child specfic fields.
The queryset returned has only MapObj's in it, yet when each one is
pulled, __getitem__ converts back to original object, creating a
pseudo heterogenous queryset
ex:
can now do
MapObj.objects.filter(abbreviation="MAP")
MapObj.objects.filter(permit_type="Greek Row")
yet these attributes are not apart of MapObj
'''
# process the query
if len(args):
query = args[0]
else:
query = Q(**kwargs)
new_query = Q(pk="~~~ no results ~~~")
if query.connector != "OR":
new_query = query
else:
for c in query.children:
# shoudl probably have some recurrsion here
# will fail with complex / nested queries
new_query = new_query | self.leaf_filter(Q(c))
# return a QuerySet of MapObj's
return QuerySet.filter(self, new_query)
def search_filter(self, queryset:QuerySet, name, value):
if value == "":
return queryset.none()
# qval = Q(wylie__istartswith=value) | Q(sa2ru1__istartswith=value) | Q(sa2en1__istartswith=value) | Q(sa2ru2__istartswith=value) | Q(sa2en2__istartswith=value) | Q(sa2ru3__istartswith=value) | Q(sa2en3__istartswith=value) | Q(tibetan__istartswith=value) | Q(sanscrit__istartswith=value)
qval = Q(wylie__iexact=value) | Q(sa2ru1__iexact=value) | Q(sa2en1__iexact=value) | Q(sa2ru2__iexact=value) | Q(sa2en2__iexact=value) | Q(sa2ru3__iexact=value) | Q(sa2en3__iexact=value) | Q(tibetan__iexact=value) | Q(sanscrit__iexact=value)
return queryset.filter(qval)
def apply_filters(cls, args: dict, qs: QuerySet) -> QuerySet:
pk = args.get('pk', None)
if pk:
qs = qs.filter(pk=pk)
return qs
def search_filter(self, queryset:QuerySet, name, value):
if value == "":
return queryset.none()
# qval = Q(meaning__icontains=value)
# qval = Q(meaning__istartswith=value)
qval = Q(meaning__iexact=value)
return queryset.filter(qval)
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 filter(self, *args, **kwargs):
'''
allows to query over all MapObj's, incliding child specfic fields.
The queryset returned has only MapObj's in it, yet when each one is
pulled, __getitem__ converts back to original object, creating a
pseudo heterogenous queryset
ex:
can now do
MapObj.objects.filter(abbreviation="MAP")
MapObj.objects.filter(permit_type="Greek Row")
yet these attributes are not apart of MapObj
'''
# process the query
if len(args):
query = args[0]
else:
query = Q(**kwargs)
new_query = Q(pk="~~~ no results ~~~")
if query.connector != "OR":
new_query = query
else:
for c in query.children:
# shoudl probably have some recurrsion here
# will fail with complex / nested queries
new_query = new_query | self.leaf_filter(Q(c))
# return a QuerySet of MapObj's
return QuerySet.filter(self, new_query)
def paginate_request(filters: Optional[dict], list_to_paginate: QuerySet, page_number: str = '1'):
if filters is not None:
list_to_paginate = list_to_paginate.filter(**filters).distinct()
paginator = Paginator(list_to_paginate, 6)
page = paginator.get_page(page_number)
return page, paginator
def leaf_filter(self, query):
'''
Should not be called directly, use filter()
Executes a query over leaf instances of MapObj
allows for some complex / cross model queries
ex:
q1 = Q(name__icontains='commons')
q2 = Q(abbreviation__icontains='map')
MapObj.objects.filter(q1|q2)
returns:
[<Group: Ferrell Commons>, <Building: Libra Commons>, <Building: Math & Physics>, ...]
'''
# grab all the models that extend MapObj
if not MapQuerySet.campus_models:
MapQuerySet.campus_models = []
for ct in ContentType.objects.filter(app_label="campus"):
model = models.get_model("campus", ct.model)
if issubclass(model, campus.models.MapObj):
MapQuerySet.campus_models.append(model)
# return queryset containing MapObj's
mob_query = Q(pk="~~~ no results ~~~")
for m in self.campus_models:
if m == campus.models.MapObj: continue
try:
qs = QuerySet(m)
results = qs.filter(query)
for o in results:
mob_query = mob_query | Q(id=o.mapobj_ptr_id)
except FieldError:
continue
return mob_query
def people_detail(request, people_permalink, meter_permalink=None):
people = get_object_or_404(People, permalink=people_permalink)
meter_list = Meter.objects.all().order_by('order')
meter_statement_count = [(meter, meter.statement_set.filter(status=STATUS_PUBLISHED, quoted_by=people).count()) for meter in meter_list]
statement_list = statement_query_base(request.user.is_anonymous(), request.user.is_staff, request.user)
statement_list = statement_list.filter(Q(quoted_by=people)|Q(relate_peoples=people)).order_by('-uptodate')
query = statement_list.query
query.group_by = ['id']
statement_list = QuerySet(query=query, model=Statement)
request_meter = None
if meter_permalink:
request_meter = get_object_or_404(Meter, permalink=meter_permalink)
statement_list = statement_list.filter(meter=request_meter)
statement_list = pagination_build_query(request, statement_list, 5)
people_list = people_query_base(is_anonymous=True)
people_list = people_list.exclude(id=people.id)
people_list = people_list[0:2]
return render(request, 'domain/people_detail.html', {
'people': people,
'meter_statement_count': meter_statement_count,
'statement_list': statement_list,
'people_list': people_list,
'request_meter': request_meter
})
def find_by_city(
*,
city_id: int,
queryset: QuerySet,
) -> QuerySet:
"""Find postal codes by the city."""
return queryset.filter(Q(city__pk=city_id) | Q(city__isnull=True))
def get_filtered_queryset(self, queryset: QuerySet) -> QuerySet:
try:
return queryset.filter(**self.used_parameters)
except (ValueError, ValidationError) as e:
# Fields may raise a ValueError or ValidationError when converting
# the parameters to the correct type.
raise IncorrectLookupParameters(e)
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 get_rarity_ratio_rows(self, dates: List[date], decks: QuerySet,
exclude_lands: bool = False) -> List[List[float]]:
"""
Gets the rows of rarity ratios for each of the given dates
:param dates: The dates to create the rarity ratios for
:param decks: The queryset of decks
:param exclude_lands: Whether to exclude lands from the results
:return: The rarity ratio rows
"""
rows = []
for created_date in dates:
date_decks = decks.filter(date_created=created_date)
row = [0] * len(self.rarities)
deck_count = 0
for deck in date_decks:
if sum(x.count for x in deck.cards.all()) < 60:
continue
rarity_ratios = self.get_deck_rarity_ratios(deck, exclude_lands)
for idx, rarity in enumerate(self.rarities):
row[idx] += rarity_ratios[rarity]
deck_count += 1
if deck_count > 0:
row = [x / deck_count for x in row]
rows.append(row)
return rows
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:
try:
search_fields = AUTOCOMPLETE_SEARCH_FIELDS[
model._meta.app_label][model._meta.model_name]
except KeyError:
search_fields = ()
if search_fields:
for word in term.split():
search = [
models.Q(**{smart_text(item): smart_text(word)})
for item in search_fields
]
search_qs = QuerySet(model)
search_qs.query.select_related = qs.query.select_related
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
else:
qs = model.objects.none()
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:
if six.PY3:
to_string_function = lambda x: x.__str__()
else:
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 = apps.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.query.select_related = queryset.query.select_related
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
additional_filter = self.get_related_filter(model, request)
if additional_filter:
queryset = queryset.filter(additional_filter)
if self.autocomplete_limit:
queryset = queryset[:self.autocomplete_limit]
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 Exception: # FIXME: use stricter exception checking
pass
else:
data = to_string_function(obj)
return HttpResponse(data, content_type='text/plain')
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)
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:
try:
search_fields = AUTOCOMPLETE_SEARCH_FIELDS[model._meta.app_label][model._meta.module_name]
except KeyError:
search_fields = ()
if search_fields:
for word in term.split():
search = [models.Q(**{smart_text(item): smart_text(word)}) for item in search_fields]
search_qs = QuerySet(model)
search_qs.query.select_related = qs.query.select_related
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
else:
qs = model.objects.none()
return qs
def test_validate_message_recipient(admin: User, messages: QuerySet):
"""Should mark the message read."""
message = messages.filter(sender=admin).first()
validate_message_recipient(message)
message.recipient = admin
with pytest.raises(ValidationError):
validate_message_recipient(message)
def test_user_professional_certificate_create(
user: User,
client_with_token: Client,
professionals: QuerySet,
):
"""Should be able to create a user professional certificates object."""
obj = professionals.filter(user=user).first()
response = client_with_token.post(
reverse("user-professional-certificates-list"),
{
"name":
"test name",
"organization":
"test organization",
"professional":
obj.pk,
"photo":
("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKBAMAA"
"AB/HNKOAAAAGFBMVEXMzMyWlpajo6O3t7fFxcWcnJyxsbG+vr50Rsl6AAAAC"
"XBIWXMAAA7EAAAOxAGVKw4bAAAAJklEQVQImWNgwADKDAwsAQyuDAzMAgyMb"
"OYMAgyuLApAUhnMRgIANvcCBwsFJwYAAAAASUVORK5CYII=")
},
)
certificate = obj.certificates.first()
photo_path = f"certificates/{slugify(obj)}"
assert response.status_code == 201
assert certificate.name == "test name"
assert photo_path in certificate.photo.name
assert certificate.photo_thumbnail is not None
certificate.photo.delete()
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):
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 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.query.select_related = queryset.query.select_related
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
if self.autocomplete_limit:
queryset = queryset[: self.autocomplete_limit]
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):
"""
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 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)
# 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 handle(self, **options):
limit = options.get('limit',None)
loop_sleep = options.get('loop_sleep', 0.001)
info = options.get('info', False)
if info:
qs = QuerySet(model=Page)
nonmigrated = qs.filter(layout_migrated=False).count()
total = qs.count()
l = len(str(total))
print str(total-nonmigrated).rjust(l), 'pages allready migrated'
print str(nonmigrated).rjust(l), 'pages NOT YET migrated'
print str(total).rjust(l), "pages TOTAL"
return
migrate(limit, loop_sleep)
def admin_keyword_search(model, fields, keywords):
"""
"""
if not keywords:
return []
keywords = keywords.split(" ")
qs = QuerySet(model)
for keyword in keywords:
or_queries = [ Q(**{'%s__icontains' % field: keyword}) for field in fields ]
other_qs = QuerySet(model)
if qs.select_related:
other_qs = other_qs.select_related()
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
return qs
def get_json(request, token):
"""Return matching results as JSON"""
result = []
searchtext = request.GET['q']
if len(searchtext) >= 1:
pickled = _simple_autocomplete_queryset_cache.get(token, None)
if pickled is not None:
app_label, model_name, query = pickle.loads(pickled)
model = get_model(app_label, model_name)
queryset = QuerySet(model=model, query=query)
fieldname = get_search_fieldname(model)
di = {'%s__istartswith' % fieldname: searchtext}
items = queryset.filter(**di).order_by(fieldname)[:10]
for item in items:
result.append((item.id, getattr(item, fieldname)))
else:
result = 'CACHE_MISS'
return HttpResponse(simplejson.dumps(result))
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 get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
try:
term = model.autocomplete_term_adjust(term)
except AttributeError:
pass
search_fields = get_autocomplete_search_fields(self.model)
if search_fields:
for word in term.split():
search = [models.Q(**{smart_text(item): smart_text(word)}) for item in search_fields]
search_qs = QuerySet(model)
search_qs.query.select_related = qs.query.select_related
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
else:
qs = model.objects.none()
return qs
def get_json(request, token):
"""Return matching results as JSON"""
result = []
searchtext = request.GET['q']
if len(searchtext) >= 3:
pickled = _simple_autocomplete_queryset_cache.get(token, None)
if pickled is not None:
app_label, model_name, query = pickle.loads(pickled)
model = apps.get_model(app_label, model_name)
queryset = QuerySet(model=model, query=query)
fieldname = get_search_fieldname(model)
di = {'%s__istartswith' % fieldname: searchtext}
app_label_model = '%s.%s' % (app_label, model_name)
max_items = get_setting(app_label_model, 'max_items', 10)
items = queryset.filter(**di).order_by(fieldname)[:max_items]
# Check for duplicate strings
counts = {}
for item in items:
key = unicode(item)
counts.setdefault(key, 0)
counts[key] += 1
# Assemble result set
for item in items:
key = value = unicode(item)
value = getattr(item, fieldname)
if counts[key] > 1:
func = get_setting(
app_label_model,
'duplicate_format_function',
lambda obj, model, content_type: content_type.name
)
content_type = ContentType.objects.get_for_model(model)
value = '%s (%s)' % (value, func(item, model, content_type))
result.append((item.id, value))
else:
result = 'CACHE_MISS'
return HttpResponse(json.dumps(result))
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()
