def search(self, keywords, search_type='or'):
if type(keywords) in [unicode, str]:
keywords = keywords.strip().split()
Q_list = [Q(title__icontains=keyword) for keyword in keywords]
Q_filters = reduce(lambda x, y: x or y, Q_list)
if len(keywords) > 0:
qs = Thread.objects.filter(Q_filters)
else:
qs = EmptyQuerySet()
return qs
def _fetch_all_for_group(self, **kwargs):
group = kwargs['group']
albums = Album.remote.fetch(group, all=True)
overall_result = EmptyQuerySet(model=Photo)
last_result = EmptyQuerySet(model=Photo)
overall_count = kwargs.get('count')
for album in albums:
if overall_count is not None and not kwargs.get('all'):
overall_count -= len(last_result)
kwargs['count'] = min(self.__class__.fetch_photo_limit,
overall_count)
if kwargs['count'] <= 0:
break
else:
kwargs['all'] = True
kwargs['album'] = album
last_result = self._fetch_group_album(**kwargs)
overall_result = last_result | overall_result
return overall_result
def related_news(self):
"""
News related to a location are the union of the news related to all the acts
tagged with this location
"""
news = EmptyQuerySet()
tagged_acts = Act.objects.filter(id__in=set(
[ta['act_id'] for ta in self.tagged_acts.values('act_id')]))
for a in tagged_acts:
news |= a.downcast().related_news
return news
def get_queryset(self):
if not self.parent_resource:
# pathological case
return EmptyQuerySet()
queryset = super(ChildResourceMixin, self).get_queryset()
queryset = queryset.filter(parent_id=self.parent_resource.id)
if self.include_inverse_mappings:
queryset = queryset.filter(Q(from_concept=self.concept) | Q(to_concept=self.concept))
else:
queryset = queryset.filter(from_concept=self.concept)
if not self.include_retired:
queryset = queryset.filter(~Q(retired=True))
return queryset
def render(self, context):
try:
object = template.resolve_variable(self.object, context)
except template.VariableDoesNotExist:
return ''
# extract all news
# if obect is a Person, extract news related to all current and past charges
if isinstance(object, Person):
news = EmptyQuerySet()
for c in object.all_institution_charges:
news |= c.related_news
elif isinstance(object, basestring):
if object == 'politicians_all':
news = EmptyQuerySet()
for c in InstitutionCharge.objects.all():
news |= c.related_news
if object == 'politicians_council':
news = EmptyQuerySet()
for c in municipality.council.charges:
news |= c.related_news
if object == 'politicians_gov':
news = EmptyQuerySet()
for c in municipality.gov.charges:
news |= c.related_news
else:
news = object.related_news
# filter only news of a given type (INST or COMM) (if given)
if self.news_type:
news = news.filter(news_type=self.news_type)
# sort news by news_date, descending order
context[self.context_var] = sorted(news,
key=lambda n: n.news_date,
reverse=True)[0:15]
return ''
def index_queryset(self):
# get the correct language and exclude pages that have a redirect
base_qs = super(_PageIndex, self).index_queryset()
result_qs = EmptyQuerySet()
for site_obj in Site.objects.all():
qs = base_qs.published(site=site_obj.id).filter(
Q(title_set__language=language_code)
& (Q(title_set__redirect__exact='')
| Q(title_set__redirect__isnull=True)))
if 'publisher' in settings.INSTALLED_APPS:
qs = qs.filter(publisher_is_draft=True)
qs = qs.distinct()
result_qs |= qs
return result_qs
def related_news(self):
"""
News related to a category are the union of the news related to all the acts
tagged with ther category and all the tags contained in the category
"""
news = EmptyQuerySet()
# fetch all acts tagget with the category
tagged_acts = Act.objects.filter(
id__in=set([ta['content_object_id'] for ta in self.tagged_acts.values('content_object_id')])
)
for a in tagged_acts:
news |= a.downcast().related_news
return news
def _simplify(self, qss=None):
'''
Returns QuerySetSequence, QuerySet or EmptyQuerySet depending on the
contents of items, i.e. at least two non empty QuerySets, exactly one
non empty QuerySet and all empty QuerySets respectively.
Does not modify original QuerySetSequence.
'''
not_empty_qss = filter(None, qss if qss else self.iables)
if not len(not_empty_qss):
return EmptyQuerySet()
if len(not_empty_qss) == 1:
return not_empty_qss[0]
return QuerySetSequence(*not_empty_qss)
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user', AnonymousUser)
kwargs['queryset'] = EmptyQuerySet()
if self.user is not AnonymousUser:
if self.user.is_authenticated():
kwargs['queryset'] = InputFile.objects.filter(user__exact = self.user)
else:
'''
TODO: add AnonymousUser logic here
ATM tests suppose that AnonymousUsers don't have any
input files.
'''
super(InputFileChoiceField, self).__init__(*args, **kwargs)
def search_haystack(request, species_wid, query):
#search
if species_wid is None:
species_wid = Species.objects.all()[0].wid
results = SearchQuerySet().filter(species_wid=species_wid).filter(
content=query)
#calculate facets
facets = results.facet('model_type')
tmp = facets.facet_counts()['fields']['model_type']
modelNameFacet = []
objectTypes = getObjectTypes()
models = []
for tmp2 in tmp:
modelName = objectTypes[objectTypes.index(tmp2[0])]
modelNameFacet.append({
'name': modelName,
'verbose_name': getModel(modelName)._meta.verbose_name,
'count': tmp2[1],
})
models.append(getModel(modelName))
modelNameFacet.sort(lambda x, y: cmp(x['verbose_name'], y['verbose_name']))
#narrow search by facets
model_type = request.GET.get('model_type', '')
if model_type:
results = results.models(getModel(model_type))
#order results
results = results.order_by('wid')
#convert results to query set
queryset = EmptyQuerySet()
for object in results:
tmp = object.model.objects.none()
tmp._result_cache.append(object.object)
queryset = chain(queryset, tmp)
#form response
return render_queryset_to_response(species_wid=species_wid,
request=request,
models=models,
queryset=queryset,
templateFile='public/search.html',
data={
'query': query,
'engine': 'haystack',
'model_type': model_type,
'modelNameFacet': modelNameFacet,
})
def document_objects_for_keyword_in_range(first_index, keyword):
#unescapes and splits the query into keywords
keywords = list(set((urllib.unquote_plus(keyword)).split(" ")))
query_set = EmptyQuerySet()
# Retrieves the set of documents corresponding to each keyword
for key in keywords:
word = get_or_none(Word, text=key)
if word is not None:
query_set = query_set | word.document_set.all()
# Orders the set, removes duplicates, and returns a list of the resultant documents
document_objects = list(
query_set.order_by("-pagerank").distinct()
[first_index * RESULTS_PER_PAGE:(first_index + 1) * RESULTS_PER_PAGE])
return document_objects
def search(request, keywords=None):
if not keywords:
keywords = request.GET.get('q', "")
if keywords != "":
qs = News.objects.get_published().filter(
Q(title__contains=keywords) | Q(content__contains=keywords))
else:
qs = EmptyQuerySet()
return ListView.as_view(request,
qs,
template_object_name='item',
template_name='news/search.html',
paginate_by=1,
extra_context={"keywords": keywords})
def __init__(self, *args, **kwargs):
'''
Build algorithm's arguments form dynamically based on given arguments.
This form is shown in browser when user wants to do a new run for
certain algorithm.
user: User who is currently active in this session. Only this
user's files will be shown as possible input files.
arguments: 'args' field from instance of Algorithm model.
post: request.POST to populate form fields so that is_valid()
can be called. Don't use this if you expect user to
populate the fields.
'''
self.user = kwargs.pop('user', AnonymousUser)
post = kwargs.pop('post', None)
arguments = kwargs.pop('arguments', None)
super(forms.Form, self).__init__(*args, **kwargs)
# We need to keep these in mind to check that all of them will be owned
# by self.user when form is validated.
self.input_files = []
for arg in arguments.all():
key, value, name = arg.key, arg.value, arg.name
kwargs = {'label': name, 'validators': field_validators[value]}
if value == 'boolean': kwargs['required'] = False
if value == 'input_file':
kwargs['user'] = self.user
field = ftypes[value](**kwargs)
#print "%s %s" % (self.user, len(field.queryset))
if field is not EmptyQuerySet():
self.input_files.append(key)
self.fields[key] = field
else:
self.fields[key] = ftypes[value](**kwargs)
'''
If there is request, we change form's data to correspond request's
key values.
'''
if post is not None:
for key in post.keys():
self.data[key] = post[key]
self.is_bound = True
def fetch_likes(self, **kwargs):
kwargs['gid'] = self.owner.pk
if not kwargs.get('count'):
kwargs['count'] = self.__class__.fetch_like_users_limit
kwargs['fields'] = self.__class__.remote.get_request_fields(
'user', prefix=True)
response = self.__class__.remote.api_call(method='get_likes', **kwargs)
users = response.get('users')
if users:
users_ids = User.remote.get_or_create_from_resources_list(
users).values_list('pk', flat=True)
else:
users_ids = EmptyQuerySet(model=User)
return users_ids, response
def getRows(database, table, q):
LOG(q)
dbModule = getattr(models, database, None)
if dbModule:
tableObj = getattr(dbModule, table.capitalize())
tableDigestObj = getattr(dbModule, table.capitalize() + 'Digest')
table = 'transition' if table == 'lineprof' else table
dsID = 'id_%s_ds' % table
exQ = Q(
**{
dsID + '__in':
tableDigestObj.objects.filter(
line_count__gt=settings.LIMIT).values_list(dsID, flat=True)
})
return tableObj.objects.select_related().exclude(exQ).filter(
makeQ(q, (table, )))
else:
return EmptyQuerySet()
def exportData(request, species_wid=None):
getDict = request.GET.copy()
if getDict.get('format', ''):
getDict.__setitem__('species', getDict.get('species', species_wid))
form = ExportDataForm(getDict or None)
if not form.is_valid():
return render_queryset_to_response(
species_wid=species_wid,
request=request,
templateFile='public/exportDataForm.html',
data={'form': form})
else:
species = Species.objects.get(wid=form.cleaned_data['species'])
queryset = EmptyQuerySet()
models = []
if form.cleaned_data['all_model_types'] == 'True':
model_types = getObjectTypes()
else:
model_types = form.cleaned_data['model_type']
for model_type in model_types:
model = getModel(model_type)
if issubclass(model, SpeciesComponent):
queryset = chain(
queryset,
model.objects.filter(
species__id=species.id).select_related(depth=2).all())
else:
queryset = chain(
queryset,
model.objects.select_related(depth=2).filter(
id=species.id))
models.append(getModel(model_type))
return render_queryset_to_response(
species_wid=species_wid,
request=request,
queryset=queryset,
templateFile='public/exportDataResult.html',
models=models)
def get_queryset_descendants(nodes, include_self=False, add_to_result=None):
"""
RUS: Запрос к базе данных потомков. Если нет узлов,
то возвращается пустой запрос.
:param nodes: список узлов дерева, по которым необходимо отыскать потомков
:param include_self: признак включения в результ исходного спичка узлов
:param add_to_result: список ключей узлов которые необходимо дополнительно включить в результат
:return: список узлов (QuerySet), отсортированный в порядке обхода дерева
"""
if not nodes:
# HACK: Emulate MPTTModel.objects.none(), because MPTTModel is abstract
return EmptyQuerySet(MPTTModel)
filters = []
model_class = nodes[0].__class__
if include_self:
for n in nodes:
if n.get_descendant_count():
lft, rght = n.lft - 1, n.rght + 1
filters.append(Q(tree_id=n.tree_id, lft__gt=lft, rght__lt=rght))
else:
filters.append(Q(pk=n.pk))
else:
for n in nodes:
if n.get_descendant_count():
lft, rght = n.lft, n.rght
filters.append(Q(tree_id=n.tree_id, lft__gt=lft, rght__lt=rght))
if add_to_result:
if len(add_to_result) > 1:
filters.append(Q(id__in=add_to_result))
else:
filters.append(Q(pk=add_to_result[0]))
if filters:
return model_class.objects.filter(reduce(operator.or_, filters))
else:
# HACK: Emulate model_class.objects.none()
return model_class.objects.filter(id__isnull=True)
def includeConceptsAndMappings(self, request, data, container_version):
offset = request.QUERY_PARAMS.get(OFFSET_PARAM, DEFAULT_OFFSET)
try:
offset = int(offset)
except ValueError:
offset = DEFAULT_OFFSET
limit = settings.REST_FRAMEWORK.get('MAX_PAGINATE_BY', self.paginate_by)
include_retired = False
include_concepts = request.QUERY_PARAMS.get(INCLUDE_CONCEPTS_PARAM, False)
include_mappings = request.QUERY_PARAMS.get(INCLUDE_MAPPINGS_PARAM, False)
updated_since = None
if include_concepts or include_mappings:
paginate_by = self.get_paginate_by(EmptyQuerySet())
if paginate_by:
limit = min(limit, paginate_by)
include_retired = request.QUERY_PARAMS.get(INCLUDE_RETIRED_PARAM, False)
updated_since = parse_updated_since_param(request)
if include_concepts:
queryset = container_version.get_concepts()
queryset = queryset.filter(is_active=True)
if not include_retired:
queryset = queryset.filter(~Q(retired=True))
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
queryset = queryset[offset:offset+limit]
serializer = ConceptVersionDetailSerializer(queryset, many=True)
data['concepts'] = serializer.data
if include_mappings:
queryset = container_version.get_mappings()
queryset = queryset.filter(is_active=True)
if not include_retired:
queryset = queryset.filter(~Q(retired=True))
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
queryset = queryset[offset:offset+limit]
serializer = MappingVersionDetailSerializer(queryset, many=True)
data['mappings'] = serializer.data
def tidbits_by_book(request, book):
book = book.replace('-', ' ')
startverse = Verse.objects.filter(book__iexact=book).order_by('id')[:1]
if startverse.count() == 0:
return HttpResponse(book + " is not valid!")
endverse = Verse.objects.filter(book__iexact=book).order_by('-id')[:1]
cfs = CrossRef.objects.filter(startverse__gte=startverse,
endverse__lte=endverse)
from django.db.models.query import EmptyQuerySet
tidbits = EmptyQuerySet()
for cf in cfs:
tidbits |= cf.tidbit_set.all()
tidbits = tidbits.distinct()
c = {
'filter_criteria': book,
'filter_count': tidbits.count(),
'tidbits': paginate_tidbits(request, tidbits),
'total_count': Tidbit.objects.all().count()
}
return render_to_response("tidbits_home.html",
c,
context_instance=RequestContext(request))
def search(query, models=None):
assert models and len(models) == 1, \
"This search backend only supports searching single models."
model = models[0]
(conv_query, fields) = convert_new(query, QueryConverter)
# TODO: fields.
if not conv_query:
return EmptyQuerySet(model)
index = get_indexer(model)
if len(index.text) > 1:
columns = ["coalesce(%s, '')" % qn(s) for s in index.text]
else:
columns = index.text
# TODO: support different languages
tsvector = "to_tsvector('english', %s)" % " || ".join(columns)
return index.get_query_set().extra(
select={'_relevance': "ts_rank(%s, to_tsquery(%%s), 32)"
% tsvector},
select_params=[conv_query],
where=["to_tsquery(%%s) @@ %s" % tsvector],
params=[conv_query],
# FIXME: relevance can't be used outside extra()
order_by=["-_relevance"])
def cache_objects(self, objects):
"""Cache query_key => objects, then update the flush lists."""
query_key = self.query_key()
query_flush = flush_key(self.query_string)
try:
constraints, extra_flush_keys = self.get_constraints()
except StopCaching:
# Put a persistent lock on the query key to prevent it from going
# through the cache again
cache.set(query_key, None, timeout=0)
else:
if len(objects):
cache.add(query_key, objects, timeout=self.timeout)
else:
empty_queryset = EmptyQuerySet(model=self.queryset.model,
query=self.queryset.query, using=self.queryset.db)
cache.set(query_key, empty_queryset, timeout=self.timeout)
model_flush_keys = set([flush_key(k) for k in extra_flush_keys])
if len(constraints):
model_flush_keys.update([flush_key(k[5:]) for k in constraints.keys()])
invalidator.cache_objects(objects, query_key, query_flush, model_flush_keys)
if len(constraints):
invalidator.add_to_flush_list(constraints, watch_key=query_flush)
def _fetch_group_album(self, **kwargs):
kwargs_copy = dict(kwargs)
album = kwargs_copy.pop('album')
if not isinstance(album, Album):
raise Exception(
'album parameter should be odnoklassniki_photos.models.Album object'
)
group = kwargs_copy.pop('group')
kwargs_copy['fields'] = Photo.remote.get_request_fields('group_photo',
prefix=True)
kwargs_copy['aid'] = album.pk
kwargs_copy['gid'] = group.pk
count = kwargs_copy.get('count')
if count:
if not kwargs_copy.get('all'):
result = EmptyQuerySet(model=Photo)
while count > 0:
kwargs_copy['count'] = min(
self.__class__.fetch_photo_limit, count)
count -= kwargs_copy['count']
result = super(PhotoRemoteManager,
self).fetch(**kwargs_copy) | result
return result
else:
# set count to the highest available value to speed pagination
kwargs_copy['count'] = self.__class__.fetch_photo_limit
return super(PhotoRemoteManager, self).fetch(**kwargs_copy)
else:
# return all if count is not set
kwargs_copy['all'] = True
return super(PhotoRemoteManager, self).fetch(**kwargs_copy)
def fetch_group_specific(self, ids, *args, **kwargs):
group = kwargs.pop('group', None)
if not isinstance(group, Group):
raise Exception(
'This function needs group parameter (object of odnoklassniki_groups.models.Group) to get albums from'
)
if not isinstance(ids, (list, tuple)):
raise Exception('ids should be tuple or list of ints')
kwargs['method'] = 'get_one'
kwargs['gid'] = group.pk
kwargs['fields'] = self.get_request_fields('group_album', prefix=True)
result = EmptyQuerySet(model=Album)
if kwargs.get('count'):
ids = ids[:kwargs['count']]
for id in ids:
kwargs['aid'] = id
result = super(AlbumRemoteManager, self).fetch(*args, **
kwargs) | result
return result
def test_emptyqs(self):
# Can't be instantiated
with self.assertRaises(TypeError):
EmptyQuerySet()
self.assertTrue(isinstance(Article.objects.none(), EmptyQuerySet))
def get_empty_query_set(self):
return EmptyQuerySet(self.model)
def get_empty_query_set(self):
return EmptyQuerySet(self.model, using=self._db)
def voters_email(request, election, poll=None, voter_uuid=None):
user = request.admin
TEMPLATES = [
('vote', _('Time to Vote')),
('info', _('Additional Info')),
]
default_template = 'vote'
if not election.any_poll_feature_can_send_voter_mail:
raise PermissionDenied('34')
if not election.any_poll_feature_can_send_voter_booth_invitation:
TEMPLATES.pop(0)
default_template = 'info'
if election.voting_extended_until and not election.voting_ended_at:
TEMPLATES.append(('extension', _('Voting end date extended')))
template = request.REQUEST.get('template', default_template)
if not template in [t[0] for t in TEMPLATES]:
raise Exception("bad template")
polls = [poll]
if not poll:
polls = election.polls_by_link_id
voter = None
if voter_uuid:
try:
if poll:
voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
else:
voter = get_object_or_404(Voter,
uuid=voter_uuid,
election=election)
except Voter.DoesNotExist:
raise PermissionDenied('35')
if not voter:
url = election_reverse(election, 'index')
return HttpResponseRedirect(url)
election_url = election.get_absolute_url()
default_subject = render_to_string('email/%s_subject.txt' % template,
{'custom_subject': "<SUBJECT>"})
default_body = render_to_string(
'email/%s_body.txt' % template, {
'election': election,
'election_url': election_url,
'custom_subject': default_subject,
'custom_message': '<BODY>',
'voter': {
'vote_hash': '<SMART_TRACKER>',
'name': '<VOTER_NAME>',
'voter_name': '<VOTER_NAME>',
'voter_surname': '<VOTER_SURNAME>',
'voter_login_id': '<VOTER_LOGIN_ID>',
'voter_password': '******',
'audit_passwords': '1',
'get_audit_passwords': ['pass1', 'pass2', '...'],
'get_quick_login_url': '<VOTER_LOGIN_URL>',
'poll': poll,
'election': election
}
})
q_param = request.GET.get('q', None)
filtered_voters = election.voters.filter()
if poll:
filtered_voters = poll.voters.filter()
if not q_param:
filtered_voters = EmptyQuerySet()
else:
voters_filters = get_filters(q_param, VOTER_TABLE_HEADERS,
VOTER_SEARCH_FIELDS, VOTER_BOOL_KEYS_MAP,
VOTER_EXTRA_HEADERS)
filtered_voters = filtered_voters.filter(voters_filters)
if not filtered_voters.count():
message = _("No voters were found.")
messages.error(request, message)
url = election_reverse(election, 'polls_list')
return HttpResponseRedirect(url)
if request.method == "GET":
email_form = EmailVotersForm()
email_form.fields['subject'].initial = dict(TEMPLATES)[template]
if voter:
email_form.fields['send_to'].widget = \
email_form.fields['send_to'].hidden_widget()
else:
email_form = EmailVotersForm(request.POST)
if email_form.is_valid():
# the client knows to submit only once with a specific voter_id
voter_constraints_include = None
voter_constraints_exclude = None
update_booth_invitation_date = False
if template == 'vote':
update_booth_invitation_date = True
if voter:
voter_constraints_include = {'uuid': voter.uuid}
# exclude those who have not voted
if email_form.cleaned_data['send_to'] == 'voted':
voter_constraints_exclude = {'vote_hash': None}
# include only those who have not voted
if email_form.cleaned_data['send_to'] == 'not-voted':
voter_constraints_include = {'vote_hash': None}
for _poll in polls:
if not _poll.feature_can_send_voter_mail:
continue
if template == 'vote' and not \
_poll.feature_can_send_voter_booth_invitation:
continue
subject_template = 'email/%s_subject.txt' % template
body_template = 'email/%s_body.txt' % template
extra_vars = {
'custom_subject': email_form.cleaned_data['subject'],
'custom_message': email_form.cleaned_data['body'],
'election_url': election_url,
}
task_kwargs = {
'subject_template': subject_template,
'body_template': body_template,
'extra_vars': extra_vars,
'voter_constraints_include': voter_constraints_include,
'voter_constraints_exclude': voter_constraints_exclude,
'update_date': True,
'update_booth_invitation_date':
update_booth_invitation_date,
'q_param': q_param,
}
log_obj = election
if poll:
log_obj = poll
if voter:
log_obj.logger.info(
"Notifying single voter %s, [template: %s, filter: %s]",
voter.voter_login_id, template, q_param)
else:
log_obj.logger.info(
"Notifying voters, [template: %s, filter: %r]",
template, q_param)
tasks.voters_email.delay(_poll.pk, **task_kwargs)
filters = get_voters_filters_with_constraints(
q_param, voter_constraints_include, voter_constraints_exclude)
send_to = filtered_voters.filter(filters)
if q_param and not send_to.filter(filters).count():
msg = "No voters matched your filters. No emails were sent."
messages.error(request, _(msg))
else:
messages.info(request, _("Email sending started"))
url = election_reverse(election, 'polls_list')
if poll:
url = poll_reverse(poll, 'voters')
if q_param:
url += '?q=%s' % urllib.quote_plus(q_param)
return HttpResponseRedirect(url)
context = {
'email_form': email_form,
'election': election,
'poll': poll,
'voter_o': voter,
'default_subject': default_subject,
'default_body': default_body,
'template': template,
'filtered_voters': filtered_voters,
'templates': TEMPLATES
}
set_menu('voters', context)
if not poll:
set_menu('polls', context)
return render_template(request, "voters_email", context)
def get_queryset(self):
return EmptyQuerySet()
def test_emptyqs(self):
msg = "EmptyQuerySet can't be instantiated"
with self.assertRaisesMessage(TypeError, msg):
EmptyQuerySet()
self.assertIsInstance(Article.objects.none(), EmptyQuerySet)
self.assertNotIsInstance('', EmptyQuerySet)
def get_initial_queryset(self):
if self.model:
return self.model.objects.all().exclude(processing_status='temp')
else:
return EmptyQuerySet()
