class ArticleIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
auteur = indexes.CharField(model_attr='auteur')
categorie = indexes.CharField(model_attr='categorie')
contenu = indexes.CharField(model_attr='contenu')
tags = indexes.MultiValueField(model_attr='tags__nom')
auteurs_commentaires = indexes.MultiValueField(
model_attr='commentaires__auteur__full_name')
def get_model(self):
return Article
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
class MarketingFailedContactIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(
document=True, use_template=True, template_name='search/failed_contact_emails.txt')
id = indexes.CharField(model_attr='id')
email = indexes.EdgeNgramField(model_attr='email')
email_domain = indexes.EdgeNgramField()
name = indexes.CharField(model_attr='name')
company_name = indexes.CharField()
created_on = indexes.CharField(model_attr='created_on')
created_on_arrow = indexes.CharField(model_attr='created_on_arrow')
created_by = indexes.CharField()
created_by_id = indexes.CharField()
contact_lists = indexes.MultiValueField()
contact_lists_id = indexes.MultiValueField()
contact_lists_name = indexes.MultiValueField()
contact_lists_count = indexes.IntegerField()
def get_model(self):
return FailedContact
def prepare_email_domain(self, obj):
return obj.email.split('@')[-1]
def prepare_contact_lists(self, obj):
return [[contact_list.id, contact_list.name if contact_list.name else ''] for contact_list in obj.contact_list.all()]
def prepare_contact_lists_id(self, obj):
return [contact_list.id for contact_list in obj.contact_list.all().order_by('id')]
def prepare_contact_lists_name(self, obj):
return [contact_list.name for contact_list in obj.contact_list.all().order_by('id')]
def prepare_company_name(self, obj):
return obj.company_name if obj.company_name else ''
def prepare_created_by(self, obj):
return obj.created_by.email if obj.created_by else ''
def prepare_created_by_id(self, obj):
return obj.created_by.id if obj.created_by else ''
def prepare_contact_lists_count(self, obj):
return obj.contact_list.count()
def index_queryset(self, using=None):
return self.get_model().objects.all()
class UserIndex(indexes.ModelSearchIndex, indexes.Indexable):
content_type = indexes.CharField(default='User')
user_roles = indexes.MultiValueField(indexed=True, stored=True)
interests = indexes.MultiValueField(indexed=True, stored=True)
country = indexes.CharField(indexed=True, stored=True)
has_relation = indexes.BooleanField(indexed=True,
stored=True,
default=False)
is_published = indexes.BooleanField(indexed=True, stored=True)
class Meta:
model = get_user_model()
fields_to_skip = [
'_total_follower', '_total_following', '_total_love',
'_total_testify', 'password'
]
excludes = ['password']
def index_queryset(self, using=None):
"Used when the entire index for model is updated."
return self.get_model().objects.filter()
def prepare_user_roles(self, object):
return [inst.permalink for inst in object.user_roles.all()]
def prepare_interests(self, object):
return [inst.permalink for inst in object.interests.all()]
def prepare_country(self, object):
if object.country:
return object.country.permalink
else:
return ''
def prepare_has_relation(self, object):
for Model in BaseRelation.__subclasses__():
if Model.objects.filter(Q(dst_id=object.id)
| Q(src_id=object.id)).count():
return True
return False
def prepare_is_published(self, object):
# is_published = indexes.BooleanField(indexed=True, stored=True)
return bool(object.is_active)
class ProgramIndex(BaseIndex, indexes.Indexable, OrganizationsMixin):
model = Program
uuid = indexes.CharField(model_attr='uuid')
title = indexes.CharField(model_attr='title', boost=TITLE_FIELD_BOOST)
title_autocomplete = indexes.NgramField(model_attr='title', boost=TITLE_FIELD_BOOST)
subtitle = indexes.CharField(model_attr='subtitle')
type = indexes.CharField(model_attr='type__name', faceted=True)
marketing_url = indexes.CharField(null=True)
organizations = indexes.MultiValueField(faceted=True)
authoring_organizations = indexes.MultiValueField(faceted=True)
authoring_organizations_autocomplete = indexes.NgramField(boost=ORG_FIELD_BOOST)
authoring_organization_uuids = indexes.MultiValueField()
subject_uuids = indexes.MultiValueField()
staff_uuids = indexes.MultiValueField()
authoring_organization_bodies = indexes.MultiValueField()
credit_backing_organizations = indexes.MultiValueField(faceted=True)
card_image_url = indexes.CharField(model_attr='card_image_url', null=True)
status = indexes.CharField(model_attr='status', faceted=True)
partner = indexes.CharField(model_attr='partner__short_code', null=True, faceted=True)
start = indexes.DateTimeField(model_attr='start', null=True, faceted=True)
seat_types = indexes.MultiValueField(model_attr='seat_types', null=True, faceted=True)
published = indexes.BooleanField(null=False, faceted=True)
min_hours_effort_per_week = indexes.IntegerField(model_attr='min_hours_effort_per_week', null=True)
max_hours_effort_per_week = indexes.IntegerField(model_attr='max_hours_effort_per_week', null=True)
weeks_to_complete_min = indexes.IntegerField(model_attr='weeks_to_complete_min', null=True)
weeks_to_complete_max = indexes.IntegerField(model_attr='weeks_to_complete_max', null=True)
language = indexes.MultiValueField(faceted=True)
hidden = indexes.BooleanField(model_attr='hidden', faceted=True)
def prepare_aggregation_key(self, obj):
return 'program:{}'.format(obj.uuid)
def prepare_published(self, obj):
return obj.status == ProgramStatus.Active
def prepare_organizations(self, obj):
return self.prepare_authoring_organizations(obj) + self.prepare_credit_backing_organizations(obj)
def prepare_subject_uuids(self, obj):
return [str(subject.uuid) for course in obj.courses.all() for subject in course.subjects.all()]
def prepare_staff_uuids(self, obj):
return [str(staff.uuid) for course_run in obj.course_runs for staff in course_run.staff.all()]
def prepare_credit_backing_organizations(self, obj):
return self._prepare_organizations(obj.credit_backing_organizations.all())
def prepare_marketing_url(self, obj):
return obj.marketing_url
def prepare_language(self, obj):
return [self._prepare_language(language) for language in obj.languages]
class AdIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True, template_name='search/indexes/ad/ad_text.txt')
#model fields
title = indexes.CharField(model_attr='title')
short_description = indexes.CharField(model_attr='short_description')
slug = indexes.CharField(model_attr='slug')
price = indexes.FloatField(model_attr='price')
pub_date = indexes.DateTimeField(model_attr='pub_date')
tags = indexes.CharField()
image1 = indexes.CharField()
#localities = indexes.CharField(faceted=True)
#provinces = indexes.CharField(faceted=True)
#administrative_area_level_2 = indexes.CharField(faceted=True)
categories = indexes.MultiValueField(faceted=True)
groups = indexes.MultiValueField(faceted=True)
location = indexes.LocationField()
def prepare_location(self, obj):
# If you're just storing the floats...
return "%s,%s" % (obj.locations.first().lat, obj.locations.first().lng)
def prepare_image1(self, obj):
return str(obj.images.first().image)
def prepare(self, object):
self.prepared_data = super(AdIndex, self).prepare(object)
self.prepared_data['tags'] = [tag.name for tag in object.tags.all()]
self.prepared_data['categories'] = [category.slug for category in object.categories.all()]
self.prepared_data['groups'] = [group.slug for group in object.groups.all()]
#self.prepared_data['categories_slug'] = [category.slug for category in object.categories.all()]
#self.prepared_data['localities'] = [location.locality for location in object.locations.all()]
#self.prepared_data['provinces'] = [location.administrative_area_level_1 for location in object.locations.all()]
#self.prepared_data['administrative_area_level_2'] = [location.administrative_area_level_2 for location in object.locations.all()]
return self.prepared_data
class Meta:
model = Ad
def get_model(self):
return Ad
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(pub_date__lte=datetime.datetime.now()).filter(status=1)
class DocumentIndex(indexes.Indexable, indexes.SearchIndex):
"""Search index used by Haystack"""
doc_type = indexes.CharField(model_attr='doc_type')
version = indexes.CharField(model_attr='version', null=True)
label_string = indexes.CharField(model_attr='label_string')
text = indexes.CharField(model_attr='text')
is_root = indexes.BooleanField(model_attr='root')
is_subpart = indexes.BooleanField()
title = indexes.MultiValueField()
regulation = indexes.CharField(model_attr='label_string')
text = indexes.CharField(document=True, use_template=True)
def prepare_regulation(self, obj):
return obj.label_string.split('-')[0]
def prepare_is_subpart(self, obj):
return ('Subpart' in obj.label_string or 'Subjgrp' in obj.label_string)
def prepare_title(self, obj):
"""For compatibility reasons, we make this a singleton list"""
if obj.title:
return [obj.title]
else:
return []
def get_model(self):
return models.Document
class PostIndex(indexes.SearchIndex, indexes.Indexable):
"""Indexes Post data"""
text = indexes.CharField(document=True, use_template=True)
txt = indexes.CharField(model_attr='text')
author = indexes.CharField(model_attr='author')
pubdate = indexes.DateTimeField(model_attr='pubdate',
stored=True,
indexed=False)
topic_title = indexes.CharField(stored=True, indexed=False)
topic_author = indexes.CharField(stored=True, indexed=False)
topic_forum = indexes.CharField(stored=True, indexed=False)
# Groups authorized to read this topic.
# If a group "public" is defined, the forum is public (and anyone can read it).
permissions = indexes.MultiValueField()
def get_model(self):
return Post
def index_queryset(self, using=None):
return self.get_model().objects.filter(is_visible=True, position__gt=1)
def prepare_topic_title(self, obj):
return obj.topic.title
def prepare_topic_author(self, obj):
return obj.topic.author
def prepare_topic_forum(self, obj):
return obj.topic.forum
def prepare_permissions(self, obj):
return [group.name
for group in obj.topic.forum.group.all()] or "public"
class CourseIndex(BaseCourseIndex, indexes.Indexable):
model = Course
course_runs = indexes.MultiValueField()
expected_learning_items = indexes.MultiValueField()
prerequisites = indexes.MultiValueField(faceted=True)
def prepare_course_runs(self, obj):
return [course_run.key for course_run in obj.course_runs.all()]
def prepare_expected_learning_items(self, obj):
return [item.value for item in obj.expected_learning_items.all()]
def prepare_prerequisites(self, obj):
return [prerequisite.name for prerequisite in obj.prerequisites.all()]
class HelpFileIndex(TendenciBaseSearchIndex, indexes.Indexable):
question = indexes.CharField(model_attr='question')
answer = indexes.CharField(model_attr='answer')
syndicate = indexes.BooleanField(model_attr='syndicate', null=True)
topic = indexes.MultiValueField()
# RSS field
can_syndicate = indexes.BooleanField(null=True)
order = indexes.DateTimeField()
@classmethod
def get_model(self):
return HelpFile
def prepare_answer(self, obj):
return strip_html(obj.answer)
def prepare_topic(self, obj):
return [topic.pk for topic in obj.topics.all()]
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.create_dt <= datetime.now()
def prepare_order(self, obj):
return obj.create_dt
class ThreadIndex(get_base_index()):
haystack_use_for_indexing = ENABLE_HAYSTACK_SEARCH
title = indexes.CharField()
tags = indexes.MultiValueField()
def get_language(self, obj):
return obj.language_code
def get_model(self):
return get_model('askbot', 'Thread')
def get_index_kwargs(self, language):
kwargs = {'deleted': False}
if self.i18n_enabled:
kwargs['language_code__startswith'] = language
return kwargs
def prepare_tags(self, obj):
return [tag.name for tag in obj.tags.all()]
def should_update(self, instance, **kwargs):
# Update only if thread is not deleted
return not instance.deleted
class CustomUserIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
position = indexes.CharField()
bio = indexes.CharField()
skills = indexes.MultiValueField()
# image = indexes.ImageField()
skill_area1_title = indexes.CharField()
skill_area1 = indexes.CharField()
skill_area2_title = indexes.CharField()
skill_area2 = indexes.CharField()
skill_area3_title = indexes.CharField()
skill_area3 = indexes.CharField()
skill_area4_title = indexes.CharField()
skill_area4 = indexes.CharField()
skill_area5_title = indexes.CharField()
skill_area5 = indexes.CharField()
software_hardware = indexes.CharField()
availability = indexes.CharField()
rate = indexes.CharField()
expert = indexes.BooleanField()
gives_tutorials = indexes.BooleanField()
tutorial_area = indexes.CharField()
def get_model(self):
return CustomUser
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.all()
def prepare_tags(self, obj):
return [skill.name for skill in obj.skills.all()]
class PatronIndex(indexes.Indexable, indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=False)
location = indexes.LocationField(model_attr='default_address__position',
null=True)
username = indexes.CharField(model_attr='username')
avatar = indexes.CharField(null=True)
sites = indexes.MultiValueField(faceted=True)
date_joined_date = indexes.DateField(model_attr='date_joined__date')
url = indexes.CharField(model_attr='get_absolute_url')
def get_updated_field(self):
return "date_joined_date"
def prepare_sites(self, obj):
return tuple(obj.sites.values_list('id', flat=True))
def prepare_avatar(self, obj):
# FIXME: should we really check for obj.avatar here?
return obj.thumbnail.url if obj.avatar and obj.thumbnail else None
def get_model(self):
return Patron
def index_queryset(self, using=None):
return self.get_model().on_site.select_related(
'default_address__position')
class ModelWithManyToManyFieldAndAttributeLookupSearchIndex(
indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
related_models = indexes.MultiValueField(model_attr="related_models__name")
def get_model(self):
return ManyToManyLeftSideModel
class DocumentIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr="title", boost=2)
# https://github.com/toastdriven/django-haystack/issues/569 - Necessary for sorting
title_sortable = indexes.CharField(indexed=False)
oid = indexes.IntegerField(model_attr='id')
type = indexes.CharField(faceted=True)
bbox_left = indexes.FloatField(model_attr="bbox_x0", null=True)
bbox_right = indexes.FloatField(model_attr="bbox_x1", null=True)
bbox_top = indexes.FloatField(model_attr="bbox_y0", null=True)
bbox_bottom = indexes.FloatField(model_attr="bbox_y1", null=True)
abstract = indexes.CharField(model_attr='abstract', boost=1.5)
owner = indexes.CharField(model_attr="owner", faceted=True, null=True)
modified = indexes.DateTimeField(model_attr="date")
detail_url = indexes.CharField(model_attr="get_absolute_url")
popular_count = indexes.IntegerField(model_attr="popular_count", default=0)
keywords = indexes.MultiValueField(model_attr="keyword_list", indexed=False, null=True, faceted=True)
thumbnail_url = indexes.CharField(model_attr="thumbnail_url", null=True)
def get_model(self):
return Project
def prepare_type(self, obj):
return "document"
def prepare_title_sortable(self, obj):
return obj.title.lower().lstrip()
class AreaIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
uLocStr = indexes.CharField()
locationId = indexes.IntegerField(model_attr='id')
locationType = indexes.CharField()
parent = indexes.IntegerField(model_attr='environment__id')
name = indexes.CharField(model_attr='name', boost=2.0, faceted=True)
tags = indexes.MultiValueField(boost=2.0, faceted=True)
description = indexes.CharField()
timestamp = indexes.DateTimeField(model_attr='timestamp')
def get_model(self):
return Area
def prepare_uLocStr(self, obj):
return "area" + str(obj.id)
def prepare_locationType(self, obj):
return "area"
def prepare_tags(self, obj):
return obj.tags.getList()
def prepare_description(self, obj):
desc = u''
for feat in obj.features.all():
if feat.category == "default":
desc += feat.data.to_serializable()
return desc
def index_queryset(self):
## Used when the entire index for model is updated.
return self.get_model().objects.filter(
timestamp__lte=datetime.datetime.now())
class VoteIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
uid = indexes.CharField(model_attr='uid')
category = indexes.CharField(default=None, model_attr='category')
content = indexes.CharField(model_attr='content')
conflict = indexes.BooleanField(default=None, model_attr='conflict')
ad = indexes.IntegerField(model_attr='sitting__ad')
date = indexes.DateField(model_attr='sitting__date')
vote_seq = indexes.CharField(model_attr='vote_seq')
result = indexes.CharField(model_attr='result')
results = indexes.CharField(model_attr='results')
tags = indexes.MultiValueField()
tags_num = indexes.IntegerField()
def get_model(self):
return Vote
def prepare_tags(self, obj):
return [
(x.title, x.votes, )
for x in
Standpoint.objects.filter(vote=obj)\
.annotate(votes=Count('user_standpoint__id'))\
.order_by('-votes')
]
def prepare_tags_num(self, obj):
return Standpoint.objects.filter(vote=obj)\
.count()
class PageIndex(indexes.SearchIndex, indexes.Indexable):
title = indexes.CharField(model_attr='title')
date = indexes.DateTimeField(model_attr='publish_date')
description = indexes.CharField(model_attr='description')
keywords = indexes.MultiValueField()
get_absolute_url = indexes.CharField(model_attr='get_absolute_url')
text = indexes.CharField(document=True)
def full_prepare(self, *args, **kwargs):
widgy_pre_index.send(sender=self)
return super(PageIndex, self).full_prepare(*args, **kwargs)
def get_model(self):
return WidgyPage
def index_queryset(self, using=None):
return self.get_model().objects.published()
def prepare_text(self, obj):
context = {'_current_page': obj.page_ptr, 'page': obj.page_ptr}
html = render_root(context, obj, 'root_node')
content = html_to_plaintext(html)
keywords = ' '.join(self.prepare_keywords(obj))
return ' '.join([obj.title, keywords, obj.description, content])
def prepare_keywords(self, obj):
return [unicode(k) for k in obj.keywords.all()]
class QuestionIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title', boost=1.125)
title_auto = indexes.EdgeNgramField(model_attr='title')
model_content = indexes.CharField(model_attr='content')
answer = indexes.CharField(null=True)
answered = indexes.BooleanField(model_attr='answered')
user_email = indexes.CharField(model_attr='user')
pub_date = indexes.DateTimeField(model_attr='pub_date')
tags = indexes.MultiValueField(model_attr='tag_list',
faceted=True,
boost=1.5)
get_absolute_url = indexes.CharField(null=True)
def get_model(self):
return Question
def prepare_get_absolute_url(self, obj):
return "%s" % obj.get_absolute_url()
def prepare_user_email(self, obj):
return "%s" % obj.user_email
def prepare_answer(self, obj):
try:
return textify("%s" %
obj.answer_set.all().filter(accepted=True)[0])
except IndexError:
return None
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(pub_date__lte=timezone.now())
class BookIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=False)
genres = indexes.MultiValueField(null=True)
def get_model(self):
return Book
def index_queryset(self, using=None):
return self.get_model().objects.prefetch_related(
'authors', 'comments', 'identifiers', 'languages')
def prepare_genres(self, obj):
return ','.join(obj.genres) or None
def prepare(self, obj):
self.prepared_data = super(BookIndex, self).prepare(obj)
text = [obj.title, obj.isbn, obj.uuid]
if obj.series:
text.extend([obj.series])
authors = [author.name for author in obj.authors.all()]
authors.extend(map(unidecode, authors))
text.extend(set(authors))
text.extend(obj.tags.all())
text.extend(obj.publishers.all())
text.extend(['lang:%s' % l.lang_code for l in obj.languages.all()])
text.extend(['publisher:%s' % p.name for p in obj.publishers.all()])
self.prepared_data['text'] = u' '.join(map(unicode, text))
return self.prepared_data
class DocumentIndex(CelerySearchIndex, indexes.Indexable):
text = indexes.CharField(use_template=True, document=True)
datetime = indexes.DateTimeField(model_attr="data__datetime")
parent_ids = indexes.MultiValueField()
suggestions = indexes.FacetCharField()
def get_model(self):
return Document
def index_queryset(self, using=None):
return self.get_model().objects.all().exclude(parent=None)
def prepare_parent_ids(self, obj):
return _parent_ids(obj)
def prepare(self, obj):
data = super().prepare(obj)
file_obj = obj.data.file
extracted_data = self.get_backend().extract_file_contents(file_obj)
t = loader.select_template(
('search/indexes/documents/document_text.txt', ))
data['text'] = t.render(
Context({
'object': obj,
'extracted': extracted_data
}))
# data['suggestions'] = data['text'][:30000]
return data
class PersonIndex(BaseIndex, indexes.Indexable):
model = Person
uuid = indexes.CharField(model_attr='uuid')
salutation = indexes.CharField(model_attr='salutation', null=True)
full_name = indexes.CharField(model_attr='full_name')
partner = indexes.CharField(null=True)
bio = indexes.CharField(model_attr='bio', null=True)
bio_language = indexes.CharField(model_attr='bio_language', null=True)
get_profile_image_url = indexes.CharField(
model_attr='get_profile_image_url', null=True)
position = indexes.MultiValueField()
def prepare_aggregation_key(self, obj):
return 'person:{}'.format(obj.uuid)
def prepare_position(self, obj):
try:
position = Position.objects.get(person=obj)
except Position.DoesNotExist:
return []
return [position.title, position.organization_override]
def prepare_bio_language(self, obj):
if obj.bio_language:
return obj.bio_language.name
return
class FeatureIndex(indexes.SearchIndex, indexes.Indexable):
"""Feature search index definition."""
# This is a workaround for the Haystack limitation that all document=True fields
# on all indices in the whole application must be of the same type. Therefore, we
# use a CharField and have a separate MultiValueField.
text = indexes.CharField(document=True)
genes = indexes.MultiValueField()
source = indexes.CharField(model_attr='source')
name_auto = indexes.EdgeNgramField(boost=10.0)
aliases_auto = indexes.EdgeNgramField()
def get_model(self):
"""Model to index."""
return Feature
def prepare_text(self, obj):
"""Prepare the value for the 'text' field during indexing."""
return '\n'.join(self.prepare_genes(obj))
def prepare_genes(self, obj):
"""Prepare the value for the 'genes' field during indexing."""
return [obj.name, obj.feature_id] + obj.aliases
def prepare_name_auto(self, obj):
"""Prepare the value for the 'name_auto' field during indexing."""
return ' '.join([obj.name, obj.feature_id])
def prepare_aliases_auto(self, obj):
"""Prepare the value for the 'aliases_auto' field during indexing."""
return ' '.join(obj.aliases)
class TextIndex(indexes.SearchIndex, indexes.Indexable):
"""
Index annotatable texts.
"""
text = indexes.CharField(document=True, use_template=False)
title = indexes.EdgeNgramField(model_attr='title', indexed=False)
created = indexes.DateField(model_attr='created',
faceted=True,
indexed=False,
null=True)
added = indexes.DateField(model_attr='added', faceted=True, indexed=False)
addedBy = indexes.CharField(model_attr='addedBy')
uri = indexes.CharField(model_attr='id')
relation_count = indexes.CharField(model_attr='relation_count')
collections = indexes.MultiValueField(indexed=False,
faceted=True,
null=True)
def get_model(self):
""" Get model to be used for indexing """
return Text
def index_queryset(self, using=None):
""" Used when entire index for model is updated """
return self.get_model().objects.all()
def prepare_text(self, instance):
return instance.title
def prepare_added(self, instance):
return instance.added.date()
def prepare_collections(self, instance):
return [c.id for c in instance.partOf.all()]
class UserIndex(BaseSearchIndex, indexes.Indexable):
"""A Haystack search index for users."""
model = User
local_site_attr = 'local_site'
username = indexes.CharField(model_attr='username')
email = indexes.CharField(model_attr='email')
full_name = indexes.CharField(model_attr='get_full_name')
url = indexes.CharField(model_attr='get_absolute_url')
show_profile = indexes.BooleanField(model_attr='is_profile_visible')
groups = indexes.MultiValueField(indexed=False)
def index_queryset(self, using=None):
"""Query the list of users for the index.
All active users will be returned.
"""
return self.get_model().objects.filter(is_active=True)
def prepare_groups(self, user):
"""Prepare a user's list of groups for the index.
Only publicly-accessible groups will be stored in the index.
"""
return [
group.name
for group in user.review_groups.filter(invite_only=False)
]
class HelpFileIndex(TendenciBaseSearchIndex):
question = indexes.CharField(model_attr='question')
answer = indexes.CharField(model_attr='answer')
syndicate = indexes.BooleanField(model_attr='syndicate')
topic = indexes.MultiValueField()
# RSS field
can_syndicate = indexes.BooleanField()
order = indexes.DateTimeField()
def prepare_answer(self, obj):
answer = obj.answer
answer = strip_tags(answer)
answer = strip_entities(answer)
return answer
def prepare_topic(self, obj):
return [topic.pk for topic in obj.topics.all()]
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.create_dt <= datetime.now()
def prepare_order(self, obj):
return obj.create_dt
class AllTypesWhooshMockSearchIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField(model_attr='author', indexed=False)
pub_date = indexes.DateField(model_attr='pub_date')
sites = indexes.MultiValueField()
seen_count = indexes.IntegerField(indexed=False)
is_active = indexes.BooleanField(default=True)
class ExperimentIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
experiment_id_stored = indexes.IntegerField(model_attr='id')
experiment_title = indexes.CharField(model_attr='title')
experiment_description = indexes.CharField(model_attr='description')
experiment_created_time = indexes.DateTimeField(model_attr='created_time')
experiment_start_time = indexes.DateTimeField(model_attr='start_time', default=None)
experiment_end_time = indexes.DateTimeField(model_attr='end_time', default=None)
experiment_update_time = indexes.DateTimeField(model_attr='update_time', default=None)
experiment_institution_name = indexes.CharField(model_attr='institution_name', default=None)
experiment_creator=indexes.CharField(model_attr='created_by__username')
experiment_author = indexes.MultiValueField()
def prepare_text(self, obj):
return '{} {}'.format(obj.title.encode('utf-8'), obj.description.encode('utf-8'))
def prepare_experimentauthor(self, obj):
return [author.author for author in obj.experimentauthor_set.all()]
def get_model(self):
return Experiment
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(created_time__lte=datetime.datetime.now())
class ChapterIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
# A Chapter belongs to a Part (big-tuto) **or** a Tutorial (mini-tuto)
part = indexes.CharField(model_attr='part', null=True)
tutorial = indexes.CharField(model_attr='tutorial', null=True)
# Groups authorized to read this topic.
# If a group "public" is defined, the forum is public (and anyone can read it).
permissions = indexes.MultiValueField()
def get_model(self):
return Chapter
def index_queryset(self, using=None):
"""Only chapters online."""
published_content = GetPublished().get_published_content()
return self.get_model().objects.filter(
Q(tutorial__sha_public__isnull=False)
| Q(part__tutorial__sha_public__isnull=False),
id__in=published_content["chapters"])
def prepare_permissions(self, obj):
return "public"
class MultiValueValidSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
author = indexes.MultiValueField(stored=False)
title = indexes.CharField(indexed=False)
def get_model(self):
return MockModel
class ExtractIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
chapter = indexes.CharField(model_attr='chapter')
txt = indexes.CharField(model_attr='text')
# Groups authorized to read this topic.
# If a group "public" is defined, the forum is public (and anyone can read it).
permissions = indexes.MultiValueField()
def get_model(self):
return Extract
def index_queryset(self, using=None):
"""Only extracts online."""
published_content = GetPublished().get_published_content()
return self.get_model().objects.filter(
Q(chapter__tutorial__sha_public__isnull=False)
| Q(chapter__part__tutorial__sha_public__isnull=False),
id__in=published_content["extracts"])
def prepare_permissions(self, obj):
return "public"
