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)
