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()