def register(self, t, extends=None): """ register a type and the models it extends """ self[t.name()] = t if extends: try: for e in extends: self._extenders.setdefault(e, []).append(t) except TypeError: # not iterable self._extenders.setdefault(extends, []).append(t) if t.add_to_index: try: site.register(t.model, t.index()) except exceptions.AlreadyRegistered: pass
def test_solr_schema(self): site.register(MockModel, MockModelSearchIndex) command = Command() self.assertEqual( command.build_context().dicts[0], { 'DJANGO_ID': 'my_django_id', 'content_field_name': 'text', 'fields': [{ 'indexed': 'true', 'type': 'text', 'stored': 'true', 'field_name': 'text', 'multi_valued': 'false' }, { 'indexed': 'true', 'type': 'date', 'stored': 'true', 'field_name': 'pub_date', 'multi_valued': 'false' }, { 'indexed': 'true', 'type': 'text', 'stored': 'true', 'field_name': 'name', 'multi_valued': 'false' }], 'DJANGO_CT': 'my_django_ct', 'default_operator': 'AND', 'ID': 'my_id' }) schema_xml = command.build_template() self.assertTrue('<uniqueKey>my_id</uniqueKey>' in schema_xml) self.assertTrue( '<field name="my_id" type="string" indexed="true" stored="true" multiValued="false" required="true"/>' in schema_xml) self.assertTrue( '<field name="my_django_ct" type="string" indexed="true" stored="true" multiValued="false" />' in schema_xml) self.assertTrue( '<field name="my_django_id" type="string" indexed="true" stored="true" multiValued="false" />' in schema_xml)
def test_solr_schema(self): site.register(MockModel, MockModelSearchIndex) command = Command() self.assertEqual(command.build_context().dicts[0], { 'DJANGO_ID': 'my_django_id', 'content_field_name': 'text', 'fields': [ { 'indexed': 'true', 'type': 'text', 'stored': 'true', 'field_name': 'text', 'multi_valued': 'false' }, { 'indexed': 'true', 'type': 'date', 'stored': 'true', 'field_name': 'pub_date', 'multi_valued': 'false' }, { 'indexed': 'true', 'type': 'text', 'stored': 'true', 'field_name': 'name', 'multi_valued': 'false' } ], 'DJANGO_CT': 'my_django_ct', 'default_operator': 'AND', 'ID': 'my_id' }) schema_xml = command.build_template() self.assertTrue('<uniqueKey>my_id</uniqueKey>' in schema_xml) self.assertTrue('<field name="my_id" type="string" indexed="true" stored="true" multiValued="false" required="true"/>' in schema_xml) self.assertTrue('<field name="my_django_ct" type="string" indexed="true" stored="true" multiValued="false" />' in schema_xml) self.assertTrue('<field name="my_django_id" type="string" indexed="true" stored="true" multiValued="false" />' in schema_xml)
# See: https://groups.google.com/forum/?fromgroups#!topic/django-haystack/hRJKcPNPXqw def prepare(self, object): self.prepared_data = truncate_fields( super(SimulationBatchIndex, self).prepare(object)) return self.prepared_data class Meta: pass class InvestigatorIndex(SearchIndex): text = CharField(document=True, use_template=True) first_name = CharField(model_attr='user__first_name') last_name = CharField(model_attr='user__last_name') affiliation = CharField(model_attr='affiliation') def prepare(self, object): self.prepared_data = truncate_fields( super(InvestigatorIndex, self).prepare(object)) return self.prepared_data class Meta: pass #register indices site.register(models.Organism, OrganismIndex) site.register(models.SimulationBatch, SimulationBatchIndex) #site.register(models.Simulation, SimulationIndex) site.register(models.Investigator, InvestigatorIndex)
text_list.extend(map(toIntIfNumeric, params)) exp_text = self.get_experiment_text(obj, exp) ds_text = self.get_dataset_text(obj, ds) # Always convert to strings as this is a text index df_text = ' '.join(map(cleanText, text_list)) self.prepared_data['text'] = ' '.join([exp_text, ds_text, df_text]) # add all soft parameters listed as searchable as in field search for par in DatafileParameter.objects.filter( parameterset__dataset_file__pk=obj.pk, name__is_searchable=True): fn = prepareFieldName(par.name) self.prepared_data[fn] = _getParamValue(par) self.prepared_data.update(self.get_experiment_params(exp)) self.prepared_data.update(self.get_dataset_params(ds)) for par in DatasetParameter.objects.filter( parameterset__dataset__pk=ds.id, name__is_searchable=True): fn = prepareFieldName(par.name) self.prepared_data[fn] = _getParamValue(par) return self.prepared_data site.register(Dataset_File, DatasetFileIndex)
from haystack.indexes import * from haystack import site from funda.models import Question, Answer class QuestionIndex(SearchIndex): text= CharField(document=True, use_template=True) def index_queryset(self): return Question.objects.all() site.register(Question,QuestionIndex)
import datetime from haystack.indexes import * from haystack import site from package.models import Package class PackageIndex(SearchIndex): text = CharField(document=True, use_template=True) #name, description total_members = IntegerField(null = False) def get_queryset(self): """Used when the entire index for model is updated.""" return Package.objects.all() #def get_updated_field(self): # return 'updated' def prepare_total_members(self, obj): return obj.userpackage_set.count() site.register(Package, PackageIndex)
from haystack import site from haystack import indexes from parliament.search.utils import SearchIndex from parliament.hansards.models import Statement class StatementIndex(SearchIndex): text = indexes.CharField(document=True, model_attr='text_plain') searchtext = indexes.CharField(stored=False, use_template=True) date = indexes.DateTimeField(model_attr='time') politician = indexes.CharField(use_template=True) politician_id = indexes.CharField(model_attr='member__politician__identifier', null=True) who_hocid = indexes.IntegerField(model_attr='who_hocid', null=True) party = indexes.CharField(model_attr='member__party__short_name', null=True) province = indexes.CharField(model_attr='member__riding__province', null=True) topic = indexes.CharField(model_attr='topic') url = indexes.CharField(model_attr='get_absolute_url', indexed=False) committee = indexes.CharField(model_attr='committee_name') committee_slug = indexes.CharField(model_attr='committee_slug') def get_queryset(self): return Statement.objects.all().prefetch_related( 'member__politician', 'member__party', 'member__riding', 'document', 'document__committeemeeting__committee' ).order_by('-date') site.register(Statement, StatementIndex)
from haystack import indexes from haystack import site from music.models import Tune class TuneIndex(indexes.SearchIndex): """The index used for searching Tune records.""" text = indexes.CharField(document=True, use_template=True) title = indexes.CharField(model_attr='title') composer = indexes.CharField(model_attr='composer') category = indexes.CharField(model_attr='category') description = indexes.CharField(model_attr='description') site.register(Tune, TuneIndex)
'document': field['document'], 'faceted': field['faceted'], 'model_attr': field['name'], } if field['type'] == 'date': index_field = indexes.DateField(null=True, **kwargs) elif field['type'] == 'int': index_field = indexes.IntegerField(null=True, **kwargs) elif field['type'] in ('float', 'latitude', 'longitude'): index_field = indexes.FloatField(null=True, **kwargs) elif field['type'] == 'boolean': index_field = indexes.BooleanField(**kwargs) elif field['type'] == 'null_boolean': index_field = indexes.BooleanField(null=True, **kwargs) elif field['type'] in ('char', 'text'): index_field = indexes.CharField(**kwargs) else: raise Exception("Unrecognized search index field type '%s'." % field['type']) index_fields[field['name']] = index_field # Override metaclass to let us specify fields non-declaratively. class DocumentMetaclass(indexes.DeclarativeMetaclass): def __new__(cls, name, bases, attrs): return super(DocumentMetaclass, cls).__new__(cls, name, bases, index_fields) class DocumentIndex(indexes.SearchIndex): __metaclass__ = DocumentMetaclass site.register(Document, DocumentIndex)
def name(self): return "%s %s" % (self.first_name, self.last_name) class Occupation(models.Model): name = models.CharField(max_length=200) region = models.ForeignKey('Region', null=True) def __unicode__(self): return self.name class Region(models.Model): name = models.CharField(max_length=200) mayor = models.OneToOneField(Person, null=True) def __unicode__(self): return self.name # -- haystack ----------------------------------------------------------------- if not six.PY3: # Haystack isn't compatible with Python 3 from haystack import site from haystack.indexes import CharField, SearchIndex class PersonIndex(SearchIndex): first_name = CharField(document=True) site.register(Person, PersonIndex)
from haystack.indexes import * from haystack import site from models import Event class EventIndex(SearchIndex): text = CharField(document=True, use_template=True) author = CharField(model_attr='user') pub_date = DateTimeField(model_attr='pub_date') ## def get_queryset(self): ## """Used when the entire index for model is updated.""" ## return Note.objects.filter(pub_date__lte=datetime.datetime.now()) site.register(Event, EventIndex)
# -*- coding: utf-8 -*- import datetime from haystack.indexes import * from haystack import site from cms_search.search_helpers.indexes import MultiLanguageIndex from cmskit.articles.models import Article class ArticleIndex(MultiLanguageIndex): title = CharField(model_attr='title') url = CharField(stored=True) text = CharField(document=True, use_template=True, template_name='search/articles/article_index.txt') def index_queryset(self): """Used when the entire index for model is updated.""" return Article.objects.published().select_related() def prepare_url(self, obj): return '%s%s/%s' % (obj.index.page.get_absolute_url(), obj.slug, obj.pk) site.register(Article, ArticleIndex)
from haystack import site from oscar.apps.search.abstract_indexes import AbstractProductIndex from oscar.core.loading import import_module product_models = import_module('product.models', ['Item']) class ProductIndex(AbstractProductIndex): pass site.register(product_models.Item, ProductIndex)
author = MultiValueField(stored=False, null=True) classifier = MultiValueField(stored=False, null=True, model_attr='latest__classifiers') summary = CharField(stored=False, null=True, model_attr='latest__summary') description = CharField(stored=False, null=True, model_attr='latest__description') def prepare_author(self, obj): output = [] for user in list(obj.owners.all()) + list(obj.maintainers.all()): output.append(user.get_full_name()) if user.email: output.append(user.email) if obj.latest: info = obj.latest.package_info for field in ( 'author', 'author_email', 'maintainer', 'maintainer_email', ): if info.get(field): output.append(info.get(field)) return output site.register(Package, PackageSearchIndex)
import datetime from haystack import indexes from haystack import site from blog.models import BlogEntry class BlogEntryIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr='author') pub_date = indexes.DateField(model_attr='pub_date') def get_queryset(self): return BlogEntry.objects.filter(pub_date= datetime.datetime.now(), status=BlogEntry.LIVE_STATUS) site.register(BlogEntry, BlogEntryIndex)
from haystack import site from haystack import indexes from parliament.core.models import Politician from parliament.search.utils import SearchIndex class PolIndex(SearchIndex): text = indexes.CharField(document=True, use_template=True) sci = indexes.CharField(use_template=True, stored=False) pol_name = indexes.CharField(model_attr='name', indexed=False) url = indexes.CharField(model_attr='get_absolute_url', indexed=False) #dob = indexes.DateTimeField(model_attr='dob') def get_queryset(self): return Politician.objects.elected() site.register(Politician, PolIndex)
from haystack.indexes import * from haystack import site import app.models as models #class FeaturedChefIndex(indexes.SearchIndex, Indexes.Indexable): class LessonIndex(SearchIndex): text = CharField(document=True, use_template=True) teacher = CharField(model_attr="teacher") flavor_text = CharField(model_attr="flavor_text") title = CharField(model_attr="title") description = CharField(model_attr="description") def index_queryset(self): """used when the entire index for the model is updated""" return models.Lesson.objects.filter(status=2) site.register(models.Lesson, LessonIndex)
class PageIndex(SearchIndex): """Search index for pages content.""" text = CharField(document=True, use_template=True) title = CharField(model_attr='title') url = CharField(model_attr='get_absolute_url') publication_date = DateTimeField(model_attr='publication_date') def get_queryset(self): """Used when the entire index for model is updated.""" return Page.objects.published() class RealTimePageIndex(RealTimeSearchIndex): """Search index for pages content.""" text = CharField(document=True, use_template=True) title = CharField(model_attr='title') url = CharField(model_attr='get_absolute_url') publication_date = DateTimeField(model_attr='publication_date') def get_queryset(self): """Used when the entire index for model is updated.""" return Page.objects.published() if settings.PAGE_REAL_TIME_SEARCH: site.register(Page, RealTimePageIndex) else: site.register(Page, PageIndex)
def prepare_author(self, obj): return obj.project.users.all()[0] def prepare_text(self, obj): """ Prepare the text of the html file. This only works on machines that have the html files for the projects checked out. """ #Import this here to hopefully fix tests for now. from pyquery import PyQuery full_path = obj.project.rtd_build_path() file_path = os.path.join(full_path, obj.path.lstrip('/')) try: with codecs.open(file_path, encoding='utf-8', mode='r') as f: content = f.read() except IOError as e: log.info('Unable to index file: %s, error :%s' % (file_path, e)) return log.debug('Indexing %s' % obj.slug) try: to_index = strip_tags(PyQuery(content)("div.document").html()).replace(u'¶', '') except ValueError: #Pyquery returns ValueError if div.document doesn't exist. return return to_index site.register(File, FileIndex) site.register(ImportedFile, ImportedFileIndex) site.register(Project, ProjectIndex)
from haystack.indexes import * from haystack import site from models import Speaker, Session class SpeakerIndex(SearchIndex): """docstring for SpeakerIndex""" text = CharField(document=True, use_template=True) full_name = CharField(model_attr='full_name') bio = CharField(model_attr='bio') company = CharField(model_attr='company') class SessionIndex(SearchIndex): """docstring for SessionIndex""" text = CharField(document=True, use_template=True) title = CharField(model_attr='title') abstract = CharField(model_attr='abstract') site.register(Speaker, SpeakerIndex) site.register(Session, SessionIndex)
from what_apps.commerce.models import TradeElement from haystack.indexes import RealTimeSearchIndex, CharField, DateTimeField, EdgeNgramField, IntegerField from haystack import site class TradeElementIndex(RealTimeSearchIndex): text = CharField(document=True, use_template=True, template_name="search/indexes/generic_name_index.html") quick = CharField(null=True) short = CharField() autocomplete_index = EdgeNgramField( use_template=True, template_name="search/indexes/generic_name_index.html") def prepare_short(self, obj): return obj.name def get_queryset(self): return TradeElement.objects.all() site.register(TradeElement, TradeElementIndex)
.order_by('-featured') @classmethod def get_popular_videos(cls, sort='-week_views'): return VideoIndex.public().order_by(sort) @classmethod def get_latest_videos(cls): return VideoIndex.public().order_by('-created') class VideoSearchResult(SearchResult): title_for_url = Video.__dict__['title_for_url'] get_absolute_url = Video.__dict__['_get_absolute_url'] def __unicode__(self): title = self.title if len(title) > 60: title = title[:60] + '...' return title try: site.register(Video, VideoIndex) except AlreadyRegistered: # i hate python imports with all my will. # i hope they die. pass
# # Copyright 2010-2013 Código Sur Sociedad Civil. # All rights reserved. # # This file is part of Cyclope. # # Cyclope is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Cyclope is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from haystack.indexes import * from haystack import site import cyclope.apps.staticpages.models class StaticPageIndex(RealTimeSearchIndex): text = CharField(document=True, use_template=True) #template: summary, text site.register(cyclope.apps.staticpages.models.StaticPage, StaticPageIndex)
import datetime from haystack.indexes import * from haystack import site from evilsheep.catalog.models import Product class ProductIndex(SearchIndex): text = CharField(document=True, use_template=True) title = CharField(model_attr='name') site.register(Product, ProductIndex)
index_class = RealTimeSearchIndex else: index_class = SearchIndex class CHAMPIndex(index_class): text = CharField(document=True, use_template=True) author = CharField(model_attr='creator') pub_date = DateTimeField(model_attr='date') rating = IntegerField(model_attr='rating', default=1) metrics = MultiValueField() def index_queryset(self): return Activity.objects.filter(visible=True, confirmed=True) def prepare_author(self, obj): return obj.creator.visible_name() def prepare_metrics(self, obj): return [m.metricname for m in obj.get_metrics()] def get_updated_field(self): return 'modified_date' # not currently used; see apps/search/view.py, create_queryset() # def load_all_queryset(self): # return GroupTopic.objects.visible() site.register(Activity, CHAMPIndex)
class StoryIndex(RealTimeSearchIndex): text = CharField(document=True, use_template=True) project_id = IntegerField(model_attr='project_id') iteration_id = IntegerField(model_attr='iteration_id') local_id = IntegerField(model_attr='local_id') user_id = IntegerField(model_attr='assignee_id', null=True) numeric_points = IntegerField(model_attr='points_value') created = DateField(model_attr='created') status = IntegerField(model_attr='status') rank = IntegerField(model_attr='rank') tags = CharField(model_attr='tags') category = CharField(model_attr='category', null=True) def prepare(self, object): try: self.prepared_data = super(StoryIndex, self).prepare(object) except Exception as e: logger.error("Story Index super failed to run! %s" % e) traceback.print_exc() fields = ('user_id', 'category', 'status', 'numeric_points', 'tags') for field in fields: if not field in self.prepared_data: self.prepared_data[field] = "" return self.prepared_data site.register(Story, StoryIndex)
from haystack import indexes from haystack import site from tendenci.core.perms.indexes import TendenciBaseSearchIndex from addons.case_studies.models import CaseStudy, Image class CaseStudyIndex(TendenciBaseSearchIndex): text = indexes.CharField(document=True, use_template=True) client = indexes.CharField(model_attr='client') service = indexes.CharField(model_attr='services') technology = indexes.CharField(model_attr='technologies') site.register(CaseStudy, CaseStudyIndex) site.register(Image)
class ProfileIndex(TendenciBaseSearchIndex): user = indexes.CharField(model_attr='user', faceted=True) user_object = indexes.CharField(model_attr='user', faceted=True) display_name = indexes.CharField(model_attr='display_name') company = indexes.CharField(model_attr='company') address = indexes.CharField(model_attr='address') city = indexes.CharField(model_attr='city') state = indexes.CharField(model_attr='state') zipcode = indexes.CharField(model_attr='zipcode') country = indexes.CharField(model_attr='country') last_name = indexes.CharField(faceted=True) hide_in_search = indexes.BooleanField(model_attr='hide_in_search') def prepare_last_name(self, obj): return obj.user.last_name def prepare_user_object(self, obj): return obj.user.username def prepare_user(self, obj): return "%s, %s (%s)" % (obj.user.last_name, obj.user.first_name, obj.user.username) def index_queryset(self): return Profile.objects.all().order_by('user') site.register(Profile, ProfileIndex)
#!/usr/bin/env python # -*- coding: utf-8 -*- from datetime import datetime from haystack.indexes import SearchIndex, CharField, DateTimeField from haystack import site from .models import Channel class ChannelIndex(SearchIndex): text = CharField(document=True, use_template=True) date_available = DateTimeField(model_attr='date_available') def get_updated_field(self): return 'date_available' def index_queryset(self): return Channel.objects.filter( date_available__lte=datetime.datetime.now(), published=True) site.register(Channel, ChannelIndex)
from django.conf.urls.defaults import * from haystack import indexes from haystack import site from site_registration.models import Foo, Bar class FooIndex(indexes.SearchIndex): text = indexes.CharField(document=True, model_attr='body') site.register(Foo, FooIndex) site.register(Bar) urlpatterns = patterns('', (r'^search/', include('haystack.urls')), )
from haystack import indexes from haystack import site from vcms.simpleblogs.models import BlogPost class NewsBlogsIndex(indexes.SearchIndex): text = indexes.CharField(document=True, use_template=True, model_attr='content') name = indexes.CharField(model_attr='title') description = indexes.CharField(model_attr='description') keywords = indexes.CharField(model_attr='preview') pub_date = indexes.DateTimeField(model_attr='date_published') site.register(BlogPost, NewsBlogsIndex)
def __unicode__(self): return self.first_name class Occupation(models.Model): name = models.CharField(max_length=200) region = models.ForeignKey('Region', null=True) def __unicode__(self): return self.name class Region(models.Model): name = models.CharField(max_length=200) def __unicode__(self): return self.name # -- haystack ----------------------------------------------------------------- from haystack import site from haystack.indexes import CharField, SearchIndex class PersonIndex(SearchIndex): first_name = CharField(document=True) site.register(Person, PersonIndex)
from haystack.indexes import SearchIndex, CharField from haystack import site from serie.models import Serie class SerieIndex(SearchIndex): text = CharField(document=True, use_template=True) name = CharField(model_attr='name', boost=1.125) name_es = CharField(model_attr='name_es') name_en = CharField(model_attr='name_en') site.register(Serie, SerieIndex)
from haystack.indexes import * from haystack import site from models import Page class PageIndex(RealTimeSearchIndex): text = CharField(document=True, use_template=True) # TODO: We'll likely need to tweak this boost value. name = CharField(model_attr='name', boost=2) site.register(Page, PageIndex)
def prepare_data_inizio(self, obj): if obj.data_inizio_effettiva: return obj.data_inizio_effettiva else: return datetime.datetime.strptime('19700101', '%Y%m%d') def prepare_perc_pagamento(self, obj): return obj.percentuale_pagamenti def prepare(self, obj): self.prepared_data = super(ProgettoIndex, self).prepare(obj) self.prepared_data['cup_s'] = obj.cup or '' return self.prepared_data def index_queryset(self): related = [ 'territorio_set', 'programma_asse_obiettivo__classificazione_superiore__classificazione_superiore', 'programma_linea_azione__classificazione_superiore__classificazione_superiore', 'classificazione_azione', 'classificazione_oggetto', 'tema', 'fonte_set' ] return self.model.fullobjects.select_related( *related).prefetch_related(*related) site.register(Progetto, ProgettoIndex)
from django.utils.html import strip_tags, strip_entities from haystack import indexes from haystack import site from forms_builder.forms.models import Form from perms.indexes import TendenciBaseSearchIndex class FormsIndex(TendenciBaseSearchIndex): title = indexes.CharField(model_attr='title') intro = indexes.CharField(model_attr='intro') response = indexes.CharField(model_attr='response') def prepare_intro(self, obj): intro = obj.intro intro = strip_tags(intro) intro = strip_entities(intro) return intro def prepare_response(self, obj): response = obj.response response = strip_tags(response) response = strip_entities(response) return response site.register(Form, FormsIndex)
from haystack import indexes from haystack import site from django.utils.html import strip_tags, strip_entities from tendenci.core.perms.indexes import TendenciBaseSearchIndex from tendenci.core.perms.object_perms import ObjectPermission from tendenci.apps.discounts.models import Discount class DiscountIndex(TendenciBaseSearchIndex): discount_code = indexes.CharField(model_attr='discount_code') start_dt = indexes.DateTimeField(model_attr='start_dt') end_dt = indexes.DateTimeField(model_attr='end_dt') never_expires = indexes.BooleanField(model_attr='never_expires') value = indexes.DecimalField(model_attr='value') cap = indexes.IntegerField(model_attr='cap') num_of_uses = indexes.IntegerField() def prepare_num_of_uses(self, obj): return obj.num_of_uses() site.register(Discount, DiscountIndex)
from haystack.indexes import * from haystack import site from md_messages.models import Message class MessageIndex(SearchIndex): text = CharField(document=True, use_template=True) site.register(Message, MessageIndex)
from haystack import site from commis.clients.models import Client from commis.search.indexes import CommisSearchIndex class ClientIndex(CommisSearchIndex): pass site.register(Client, ClientIndex)
from albums.models import AlbumConvertableItem, Album, Video, Image from tagging.models import Tag class AlbumItemIndex(SearchIndex): text = CharField(document=True, use_template=True) title = CharField(model_attr='title') created = DateTimeField(model_attr='created') class AlbumIndex(AlbumItemIndex): owners = MultiValueField() created = DateTimeField(model_attr='created') def prepare_owners(self, object): return [u.username for u in object.owners.all()] site.register(Album, AlbumIndex) class AlbumConvertableItemIndex(AlbumItemIndex): tags = MultiValueField(model_attr='tags') submitter = CharField(model_attr='submitter') def prepare_tags(self, object): return [tag.name for tag in Tag.objects.get_for_object(object)] class ImageIndex(AlbumConvertableItemIndex): def get_queryset(self): return Image.objects.filter(preview_ready=True) site.register(Image, ImageIndex)
from haystack import indexes from haystack import site from squigcards.models import Card class CardIndex(indexes.RealTimeSearchIndex): text = indexes.CharField(document=True, use_template=True) site.register(Card, CardIndex)
def prepare_url(self, obj): return obj.get_absolute_url() def prepare_category_title(self, obj): result = [] if obj.category: for category in obj.category.title_set.all(): result.append(category.title) result.append(category.slug) return result def prepare(self, obj): self.prepared_data = super(EntryTitleIndex, self).prepare(obj) plugins = CMSPlugin.objects.filter(placeholder__in=obj.entry.placeholders.all()) text = '' for plugin in plugins: instance, _ = plugin.get_plugin_instance() if hasattr(instance, 'search_fields'): text += '\n'.join(strip_tags(getattr(instance, field, '').replace('>', '> ')) for field in instance.search_fields) if getattr(instance, 'search_fulltext', False): text += strip_tags(instance.render_plugin().replace('>', '> ')) self.prepared_data['text'] = text return self.prepared_data def get_queryset(self): """Used when the entire index for model is updated.""" return EntryTitle.objects.filter(entry__is_published=True, entry__pub_date__lte=datetime.today()) site.register(EntryTitle, EntryTitleIndex)
import datetime from haystack.indexes import * from haystack import site from main.models import Student #import pdb;pdb.set_trace() class StudentIndex(SearchIndex): text = CharField(document=True, use_template=True) last_name = CharField(model_attr='last_name') first_name = CharField(model_attr='first_name') middle_name = CharField(model_attr='middle_name') title = CharField(model_attr='title') publish_date = IntegerField(model_attr='publish_date') subtitle = CharField(model_attr='subtitle') isbn = CharField(model_attr='isbn') department = CharField(model_attr='department__name') university = CharField(model_attr='department__university__name') country = CharField(model_attr='department__university__country__name') # adviser def index_queryset(self): """Used when the entire index for model is updated.""" return Student.objects #.filter(publish_date__lte=datetime.datetime.now()) site.register(Student, StudentIndex)
from haystack import indexes, site from .models import Library class LibraryIndex(indexes.SearchIndex): name = indexes.CharField(model_attr='name', document=True) def index_queryset(self): return Library.objects.all() site.register(Library, LibraryIndex)
def register_indexes(): site.register(models.Product, ProductPredictiveSearchIndex)
from haystack import site from bare_bones_app.models import Cat # For the most basic usage, you can simply register a model with the `site`. # It will get a `haystack.indexes.BasicSearchIndex` assigned to it, whose # only requirement will be that you create a # `search/indexes/bare_bones_app/cat_text.txt` data template for indexing. site.register(Cat)
from haystack import site from haystack import indexes from vu.supporters.models import Supporter class SupporterIndex(indexes.SearchIndex): text = indexes.CharField(document=True, use_template=True) trigram = indexes.CharField(use_template=True) site.register(Supporter, SupporterIndex)
text = indexes.CharField(document=True, use_template=True) class PersonIndex(BaseIndex): name_auto = indexes.EdgeNgramField(model_attr='name') class PlaceIndex(BaseIndex): name_auto = indexes.EdgeNgramField(model_attr='name') class OrganisationIndex(BaseIndex): name_auto = indexes.EdgeNgramField(model_attr='name') class PositionTitleIndex(BaseIndex): name_auto = indexes.EdgeNgramField(model_attr='name') class HansardEntryIndex(BaseIndex): pass try: site.register( core_models.Person, PersonIndex ) site.register( core_models.Place, PlaceIndex ) site.register( core_models.Organisation, OrganisationIndex ) site.register( core_models.PositionTitle, PositionTitleIndex ) site.register( hansard_models.Entry, HansardEntryIndex ) except AlreadyRegistered: # Ignore this error pass
class Meta: pass def should_update(self, instance, **kwargs): update = not instance.labeled(Object.ARCHIVE) if not update: self.remove_object(instance, **kwargs) return update class ServiceIndex(RealTimeSearchIndex): name = EdgeNgramField(model_attr='name', boost=1.25) summary = EdgeNgramField(model_attr='summary', null=True) text = EdgeNgramField(document=True, use_template=True, template_name='catalog/haystack/service_text.txt') html = CharField(use_template=True, template_name='catalog/haystack/service_result.html') class Meta: pass def should_update(self, instance, **kwargs): update = not instance.labeled(Object.ARCHIVE) if not update: self.remove_object(instance, **kwargs) return update haystack.register(Product, ProductIndex) haystack.register(Service, ServiceIndex)
""" Search index for VirtualMachines """ text = CharField(document=True, use_template=True) # We can pull data strait out of the model via `model_attr` # (Commmenting out 'cause I'm not sure it's needed) # hostname = CharField(model_attr='hostname') # Autocomplete search field on the `hostname` model field content_auto = EdgeNgramField(model_attr="hostname") def get_queryset(self): return VirtualMachine.objects.all() site.register(VirtualMachine, VirtualMachineIndex) class ClusterIndex(SearchIndex): """ Search index for Clusters """ text = CharField(document=True, use_template=True) # Autocomplete search field on `hostname` model field content_auto = EdgeNgramField(model_attr="hostname") def get_queryset(self): return Cluster.objects.all() site.register(Cluster, ClusterIndex)
import datetime from haystack.indexes import * from haystack import site from cms.news.models import Story class StoryIndex(SearchIndex): text = CharField(document=True, use_template=True) author = CharField(model_attr='user') pub_date = DateTimeField(model_attr='pub_date') headline = CharField(model_attr='headline') def get_queryset(self): """Used when the entire index for model is updated.""" return Story.live.filter(pub_date__lte=datetime.datetime.now()) site.register(Story, StoryIndex)
# published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from django.contrib.auth.models import User try: import search from search.core import startswith search.register(User, ('username', 'first_name', 'last_name'), indexer=startswith) except ImportError: from haystack import indexes from haystack import site class UserIndex(indexes.SearchIndex): text = indexes.CharField(document=True, use_template=True) def index_queryset(self): return User.objects.all() site.register(User, UserIndex)
return 'modified' class ScheduledEventIndex(KanisaBaseSearchIndex): def index_queryset(self): return ScheduledEvent.objects.filter(date__gte=date.today()) class SermonIndex(KanisaBaseSearchIndex): def should_update(self, instance, **kwargs): return not instance.in_the_future() def index_queryset(self): return Sermon.preached_objects.all() class BlogPostIndex(KanisaBaseSearchIndex): def index_queryset(self): return BlogPost.published_objects.all() def get_updated_field(self): return 'updated_date' site.register(BlogPost, BlogPostIndex) site.register(Page, KanisaBaseSearchIndex) site.register(RegularEvent, KanisaBaseSearchIndex) site.register(ScheduledEvent, ScheduledEventIndex) site.register(Sermon, SermonIndex) site.register(SermonSeries, KanisaBaseSearchIndex)
from haystack import indexes from haystack import site from tendenci.apps.redirects.models import Redirect class RedirectIndex(indexes.RealTimeSearchIndex): text = indexes.CharField(document=True, use_template=True) from_url = indexes.CharField(model_attr='from_url') to_url = indexes.CharField(model_attr='to_url') http_status = indexes.IntegerField(model_attr='http_status') status = indexes.BooleanField(model_attr='status') uses_regex = indexes.BooleanField(model_attr='uses_regex') create_dt = indexes.DateTimeField(model_attr='create_dt') update_dt = indexes.DateTimeField(model_attr='update_dt') # PK: needed for exclude list_tags primary_key = indexes.CharField(model_attr='pk') order = indexes.DateTimeField() def get_updated_field(self): return 'update_dt' def prepare_order(self, obj): return obj.create_dt site.register(Redirect, RedirectIndex)
from haystack import indexes from haystack import site from flutemusic.models import * class PieceIndex(indexes.SearchIndex): text = indexes.CharField(document = True) title = indexes.CharField(model_attr='title') composer = indexes.CharField(model_attr='composer') program_notes = indexes.CharField(model_attr='program_notes') def get_queryset(self): return Piece.objects.all() site.register(Composer, Instrumentation, Category, Bibliography, PieceIndex, Piece)
order = indexes.DateTimeField() def prepare_body(self, obj): body = obj.body body = strip_tags(body) body = strip_entities(body) return body def prepare_category(self, obj): category = Category.objects.get_for_object(obj, 'category') if category: return category.name return '' def prepare_sub_category(self, obj): category = Category.objects.get_for_object(obj, 'sub_category') if category: return category.name return '' def prepare_can_syndicate(self, obj): return obj.allow_anonymous_view and obj.syndicate \ and obj.status == 1 and obj.status_detail == 'active' \ and obj.release_dt <= datetime.now() def prepare_order(self, obj): return obj.release_dt site.register(News, NewsIndex)
from haystack.indexes import * from haystack import site from news.models import News class NewsIndex(SearchIndex): text = CharField(document=True, use_template=True) site.register(News, NewsIndex)