class FuzzySearchIndexMixin(indexes.SearchIndex):
text_fuzzy = indexes.EdgeNgramField()
def prepare(self, obj):
prepared_data = super(FuzzySearchIndexMixin, self).prepare(obj)
content = prepared_data[self.get_content_field()]
prepared_data['text_fuzzy'] = content
return prepared_data
class ProductIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
category = indexes.CharField(model_attr='category', null=True)
location = indexes.EdgeNgramField(model_attr='location', null=True)
def get_model(self):
return Product
class ProductIndex(indexes.SearchIndex):
text = indexes.EdgeNgramField(document=True, use_template=True)
name = CharField(model_attr='name')
description = CharField(model_attr='description')
#get_queryset is deprecated
def index_queryset(self):
return Product.objects.all()
class ResourceIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
published = indexes.DateField(model_attr='published')
abstract = indexes.CharField(model_attr='abstract')
review = indexes.CharField(model_attr='review')
publisher = indexes.CharField(model_attr='publisher')
journal = indexes.CharField(model_attr='journal')
volume = indexes.IntegerField(model_attr='volume', null=True)
number = indexes.IntegerField(model_attr='number', null=True)
pages = indexes.CharField(model_attr='pages')
series = indexes.CharField(model_attr='series')
edition = indexes.CharField(model_attr='edition')
url = indexes.CharField(model_attr='url')
resource_type = indexes.CharField(model_attr='resource_type')
categories = indexes.MultiValueField(indexed=True, stored=True)
authors = indexes.MultiValueField(indexed=True, stored=True)
editors = indexes.MultiValueField(indexed=True, stored=True)
keywords = indexes.MultiValueField(indexed=True, stored=True)
title = indexes.CharField(model_attr='title')
subtitle = indexes.CharField(model_attr='subtitle')
title_auto = indexes.EdgeNgramField(model_attr='title')
subtitle_auto = indexes.EdgeNgramField(model_attr='subtitle')
#A search with the 'author:'-tag will look through this field:
author = indexes.CharField(indexed=True, stored=True)
def get_model(self):
return Resource
def index_queryset(self, using=None):
return self.get_model().objects.all()
def prepare_categories(self, obj):
return [c for c in obj.categories.all()]
def prepare_authors(self, obj):
return [a for a in obj.authors.all()]
def prepare_editors(self, obj):
return [e for e in obj.editors.all()]
def prepare_keywords(self, obj):
return [k for k in obj.keywords.all()]
def prepare_author(self, obj):
return (' '.join(
[a.name for a in obj.authors.all() | obj.editors.all()]))
class CarModelIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
price = indexes.IntegerField(model_attr='price')
milage = indexes.IntegerField(model_attr='milage')
content_auto = indexes.EdgeNgramField(model_attr='name')
def get_model(self):
return CarModel
class ProductIndex(indexes.SearchIndex):
"""
Abstract base class used to index all products for this shop
"""
text = indexes.CharField(document=True, use_template=True)
autocomplete = indexes.EdgeNgramField(use_template=True)
product_name = indexes.CharField(stored=True,
indexed=False,
model_attr='product_name')
product_url = indexes.CharField(stored=True,
indexed=False,
model_attr='get_absolute_url')
categories = indexes.MultiValueField(stored=True, indexed=False)
def get_model(self):
"""
Hook to refer to the used Product model. Override this to create indices of
specialized product models.
"""
return ProductModel
def prepare(self, product):
if hasattr(product, 'translations'):
product.set_current_language(self.language)
with translation.override(self.language):
data = super(ProductIndex, self).prepare(product)
return data
def prepare_categories(self, product):
category_fields = getattr(product, 'category_fields', [])
category_ids = set(page.pk for field in category_fields
for page in getattr(product, field).all())
return category_ids
def render_html(self, prefix, product, postfix):
"""
Render a HTML snippet to be stored inside the index database, so that rendering of the
product's list views can be performed without database queries.
"""
app_label = product._meta.app_label.lower()
params = [
(app_label, prefix, product.product_model, postfix),
(app_label, prefix, 'product', postfix),
('shop', prefix, 'product', postfix),
]
template = select_template(
['{0}/products/{1}-{2}-{3}.html'.format(*p) for p in params])
context = {'product': product}
content = strip_spaces_between_tags(template.render(context).strip())
return mark_safe(content)
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
if using in dict(settings.LANGUAGES):
self.language = using
else:
self.language = settings.LANGUAGE_CODE
return self.get_model().objects.indexable()
class NoosferoCommunityIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True,
use_template=True, stored=False)
title = indexes.EdgeNgramField(model_attr='name')
description = indexes.EdgeNgramField(model_attr='description', null=True)
url = indexes.EdgeNgramField(model_attr='url', indexed=False)
icon_name = indexes.EdgeNgramField()
type = indexes.EdgeNgramField()
modified = indexes.DateTimeField(model_attr='modified', null=True)
created_at = indexes.DateTimeField(model_attr='created_at', null=True)
category = indexes.MultiValueField()
thumb_url = indexes.EdgeNgramField(model_attr='thumb_url', null=True)
def prepare_category(self, obj):
return obj.categories.values_list('name', flat=True)
def prepare_icon_name(self, obj):
return u'file'
def get_ful_name(self):
self.objs.name
def get_model(self):
return NoosferoCommunity
def prepare_type(self, obj):
return u'community'
class CourseIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
def get_model(self):
return Course
def index_queryset(self, using=None):
""" Used for indexing """
return self.get_model().objects.all()
class PostIndex(indexes.SearchIndex, indexes.Indexable):
# 创建文章索引类
text = indexes.EdgeNgramField(document=True, use_template=True)
def get_model(self):
return Post
def index_queryset(self, using=None):
return self.get_model().objects.all()
class DataIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
text_auto = indexes.EdgeNgramField(use_template=True)
def index_queryset(self, using=None):
return self.get_model().objects.published()
def load_all_queryset(self):
return self.index_queryset()
class NetworkSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
name = indexes.EdgeNgramField(model_attr='name')
def get_model(self):
return Network
def index_queryset(self, using=None):
return Network.objects.all()
class PodcastIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
description = indexes.CharField(model_attr='description')
title = indexes.EdgeNgramField(model_attr='title')
tags = indexes.EdgeNgramField(model_attr='tags')
language = indexes.CharField(model_attr='language')
content_area = indexes.CharField(model_attr='content_area')
content_type = indexes.CharField(model_attr='content_type')
def get_model(self):
return Podcast
def index_queryset(self, using=None):
return self.get_model().objects.filter(
created__lte=datetime.datetime.now())
def prepare_tags(self, object):
return [tag.name for tag in object.tags.all()]
class MessageIndex(indexes.BasicSearchIndex, indexes.Indexable):
content_auto = indexes.EdgeNgramField(model_attr='content')
rendered = indexes.CharField(
use_template=True,
indexed=False,
template_name='search/indexes/vestlus/message_rendered.txt')
def get_model(self):
return Message
class PostIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
content_auto = indexes.EdgeNgramField(model_attr='content')
def get_model(self):
return Post
def index_queryset(self, using=None):
return self.get_model().objects.all()
class EventoIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
text_auto = indexes.EdgeNgramField(model_attr='title')
title = indexes.CharField(model_attr='title')
name = indexes.CharField(model_attr='name')
image_file = indexes.CharField(model_attr="image_file")
def get_model(self):
return Evento
class EstablecimientoIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
nombre = indexes.EdgeNgramField(model_attr='nombre')
#nombre_auto = indexes.EdgeNgramField(model_attr='nombre')
email = indexes.EdgeNgramField(model_attr='email')
web_page = indexes.EdgeNgramField(model_attr='web_page')
address= indexes.EdgeNgramField(model_attr='address')
sub_categorias = indexes.EdgeNgramField(model_attr='sub_categorias')
# content_auto = indexes.EdgeNgramField(model_attr='nombre')
def get_model(self):
return Establecimiento
def index_queryset(self, using=None):
# using select_related here should avoid an extra query for getting
# the manufacturer when indexing
return self.get_model().objects.all().select_related('sub_categorias')
class PostIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
published = indexes.BooleanField(model_attr='published')
def get_model(self):
return Post
def index_queryset(self, using=None):
return self.get_model().objects.filter(published=True)
class ModuleIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
name_auto = indexes.EdgeNgramField(model_attr='autocomplete_name')
def get_model(self):
return Module
def index_queryset(self):
return Module.objects.filter(custom=False)
class WordIndex(indexes.SearchIndex, indexes.Indexable):
masculinitive1 = indexes.CharField(document=True, use_template=True)
feminitive1 = indexes.CharField(document=True, use_template=True)
#content for autocomplete
content_auto = indexes.EdgeNgramField(model_attr='masculinitive1')
def get_model(self):
return Word
class ProfileIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
full_name = indexes.CharField(model_attr='full_name', null=True)
full_name_auto = indexes.EdgeNgramField(model_attr='full_name', null=True)
academy_name = indexes.CharField(model_attr='academy_name', null=True)
academy_name_auto = indexes.EdgeNgramField(model_attr='academy_name',
null=True)
company_name = indexes.CharField(model_attr='company_name', null=True)
company_name_auto = indexes.EdgeNgramField(model_attr='company_name',
null=True)
def get_model(self):
return Profile
def index_queryset(self, using=None):
return self.get_model().objects.all()
class VehicleIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
reg_number = indexes.CharField(model_attr='reg_number')
make = indexes.CharField(model_attr='make')
model = indexes.CharField(model_attr='model')
vin = indexes.CharField(model_attr='vin')
owner = indexes.CharField(model_attr='owner')
def get_model(self):
return Vehicle
class PersonIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=False)
name = AnalyzerCharField(model_attr="name", analyzer=IDTokenizer())
name_auto = indexes.EdgeNgramField(model_attr="name")
def get_model(self):
return Person
def index_queryset(self, using=None):
return self.get_model().objects.all()
class PageIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
date = indexes.DateTimeField(model_attr='modified_on')
def get_model(self):
return Page
def index_queryset(self, using=None):
return self.get_model().objects.filter(
modified_on__lte=datetime.datetime.now())
class InterestIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(model_attr='name', document=True)
content_auto = indexes.EdgeNgramField(model_attr='name')
url = indexes.CharField()
def get_model(self):
return Interest
def prepare_url(self, obj):
return obj.get_absolute_url()
class CampusIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
content_auto = indexes.EdgeNgramField(model_attr='name')
def get_model(self):
return Campus
def index_queryset(self, using=None):
# Used when the entire index for model is updated
return self.get_model().objects.all()
class UVIndex(indexes.SearchIndex, indexes.Indexable):
"""
Indexer class for UVs
"""
text = BigCharFieldIndex(document=True, use_template=True)
auto = indexes.EdgeNgramField(use_template=True)
def get_model(self):
return UV
class MainSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) url = indexes.CharField(model_attr='url', null=True) title = indexes.EdgeNgramField(model_attr='title', null=True) metadata = indexes.EdgeNgramField(model_attr='metadata', null=True) meta_keywords = indexes.CharField(model_attr='meta_keywords', null=True) context = indexes.EdgeNgramField(model_attr='context', null=True) suggestions = indexes.FacetCharField() def get_model(self): return MainData def index_queryset(self, using=None): return MainData.objects.filter(created__lte=datetime.datetime.now()) def prepare(self, obj): prepared_data = super(MainSearchIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data
class CourseIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
title_auto = indexes.EdgeNgramField(model_attr='title')
def get_model(self):
return Course
def index_queryset(self, using=None):
return self.get_model().objects.all()
class MeetingIndex(indexes.SearchIndex, indexes.Indexable):
'''
make a search_indexes for Django haystack to index the search items.
'''
text = indexes.EdgeNgramField(
document=True, use_template=True,
template_name='/Users/ceciliaxiang/TransparentGov/transgov/src/templates/search/indexes/Meeting_text.txt')
committee = indexes.CharField(model_attr='committee', faceted=True)
date = indexes.CharField(model_attr='date', faceted=True)
title = indexes.EdgeNgramField(model_attr='title')
location = indexes.CharField(model_attr='location', faceted=True)
time = indexes.CharField(model_attr='time', faceted=True)
attendees = indexes.CharField(model_attr='attendees', faceted=True)
items = indexes.CharField(model_attr='items', faceted=True)
url = indexes.CharField(model_attr='url', faceted=True)
def get_model(self):
return Meeting
class ProductIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
pub_date = indexes.DateTimeField(model_attr='timestamp')
content_auto = indexes.EdgeNgramField(model_attr='name')
def get_model(self):
return Products
def index_queryset(self, using=None):
return self.get_model().objects.all()
