from django_dms.apps.small_dms.models import Document
from wiki.models import Article
from threadedcomments.models import ThreadedComment
import datetime
class TopicIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True, model_attr='body')
author = indexes.CharField(model_attr='creator')
# crasher reindex.. created = indexes.DateTimeField()
title = indexes.CharField(model_attr='title', indexed=True)
def get_query_set(self):
"Used when the entire index for model is updated."
return Topic.objects.filter(tribe__private=False)
def should_update(self):
# opdater if editet er blvet changed indenfor 5 secs.
return True
#site.register(Topic)
#site.register(Tribe)
site.register(Document)
site.register(Article)
site.register(Profile)
site.register(ThreadedComment)
return Question
# ``get_queryset`` is deprecated in Haystack v2, and ``index_queryset``
# ought to be used instead. But we must use the former to support
# Haystack < 1.2.4. Support for such older version is likely to be dropped
# in the near future.
def get_queryset(self):
return Question.objects.published()
# try/except in order to register search indexes with site for Haystack 1.X
# without throwing exceptions with Haystack 2.0.
try:
from haystack.sites import site
site.register(Topic, TopicIndex)
site.register(Question, QuestionIndex)
except ImportError:
pass
########NEW FILE########
__FILENAME__ = settings
# -*- coding: utf-8 -*-
from django.conf import settings
from django.utils.translation import ugettext_lazy as _
# Status settings.
# It's unlikely that you should need to change these. But if
# you do, here you go.
class ProgramIndex(indexes.SearchIndex):
type = 'cfda'
program_number = indexes.CharField(model_attr='program_number')
program_title = indexes.CharField(document=True,
model_attr='program_title')
# def prepare_text(self, object):
# text = getattr(object, 'objectives')
#limit to just program title. Objectives produces a lot of noise
# text = getattr(object, 'program_title')
# return text
def prepare_program_title(self, object):
return str(
object.program_title.replace('_', ' ').encode('ascii', 'ignore'))
def get_queryset(self):
"Used when the entire index for model is updated."
return Program.objects.filter(
types_of_assistance__financial=True).distinct()
#return Program.objects.all()
site.register(Program, ProgramIndex)
import datetime
from haystack import indexes
from haystack.sites import site
from make.blog.models import BlogPost
class BlogPostIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr = 'title')
body = indexes.CharField(model_attr = 'body')
author = indexes.CharField(model_attr = 'author')
pub_date = indexes.DateTimeField(model_attr = 'pub_date')
tags = indexes.CharField(model_attr = 'tags')
site.register(BlogPost, BlogPostIndex)
from haystack import indexes
from haystack.sites import site
from tax_expenditures.models import Group, Expenditure
class GroupIndex(indexes.SearchIndex):
type = 'tax-expenditure-group'
group_name = indexes.CharField(model_attr='name')
group_description = indexes.CharField(model_attr='description')
group_id = indexes.IntegerField(model_attr='id')
text = indexes.CharField(document=True, model_attr='description')
def get_queryset(self):
return Group.objects.filter(parent__isnull=False)
def prepare_text(self, obj):
exp = Expenditure.objects.filter(group=obj)
text = []
for e in exp:
text.append(e.description + ' ' + e.name)
return (obj.name + ' ' + obj.description + ' '.join(text)).encode('ascii', 'ignore')
site.register(Group, GroupIndex)
return None
def prepare_publication(self, object):
return object.blog.section.publication.name
def prepare_publication_exact(self, object):
return object.blog.section.publication.name
def get_updated_field(self):
return 'last_updated'
def get_queryset(self):
return Entry.objects.filter(pub_date__lte=datetime.datetime.now())
site.register(Entry, EntryIndex)
class BlogIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# title = indexes.CharField(model_attr='title')
# description = indexes.CharField(model_attr='description')
section = indexes.CharField(model_attr='section')
section_exact = indexes.CharField(model_attr='section', indexed=False)
publication = indexes.CharField()
publication_exact = indexes.CharField(indexed=False)
rendered = indexes.CharField(
use_template=True,
indexed=False,
)
def index_queryset(self, using=None):
return self.get_model().objects.all()
def prepare_easiness(self, obj):
return obj.prof.easiness
def prepare_helpfulness(self, obj):
return obj.prof.helpfulness
def prepare_clarity(self, obj):
return obj.prof.clarity
def prepare_comments(self, obj):
return obj.prof.comments
site.register(Prof, ProfIndex)
class CourseIndex(indexes.SearchIndex):
text = indexes.NgramField(document=True, use_template=True)
code = indexes.NgramField(model_attr='code')
name = indexes.NgramField(model_attr='name')
easiness = models.DecimalField()
helpfulness = models.DecimalField()
clarity = models.DecimalField()
comments = models.CharField()
def get_model(self):
return Course
def prepare_easiness(self, obj):
# self.prepared_data['place_web_sites'] = [mpl.web_site for mpl in object.mapplacelink_set.all()]
# return self.prepared_data
def prepare_publication(self, object):
return object.section.publication.name
def prepare_publication_exact(self, object):
return object.section.publication.name
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Map.objects.all()
site.register (Map, MapIndex)
class PlaceIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# name = indexes.CharField(model_attr='name')
# address = indexes.CharField(model_attr='address')
rendered = indexes.CharField(use_template=True, indexed=False,)
# def prepare(self, object):
# self.prepared_data = super(PlaceIndex, self).prepare(object)
# return self.prepared_data
def get_updated_field(self):
return 'last_updated'
from haystack.sites import site
from cfda.models import Program
class ProgramIndex(indexes.SearchIndex):
type = 'cfda'
program_number = indexes.CharField(model_attr='program_number')
program_title = indexes.CharField(document=True, model_attr='program_title')
# def prepare_text(self, object):
# text = getattr(object, 'objectives')
#limit to just program title. Objectives produces a lot of noise
# text = getattr(object, 'program_title')
# return text
def prepare_program_title(self, object):
return str(object.program_title.replace('_', ' ').encode('ascii', 'ignore'))
def get_queryset(self):
"Used when the entire index for model is updated."
return Program.objects.filter(types_of_assistance__financial=True ).distinct()
#return Program.objects.all()
site.register(Program, ProgramIndex)
return None
except:
return None
def prepare_sectors(self, object):
return map(lambda x: x.id, object.sectors.all())
def prepare_subsectors(self, object):
return map(lambda x: x.id, object.subsectors.all())
def get_queryset(self):
"Used when the entire index for model is updated."
return FPDSRecord.objects.all()
site.register(FPDSRecord, FPDSRecordIndex)
# # unused model attributes follow
#
# version = indexes.CharField(model_attr='version', null=True)
# agency_id = indexes.CharField(model_attr='agency_id', null=True)
# piid = indexes.CharField(model_attr='piid', null=True)
# mod_number = indexes.CharField(model_attr='mod_number', null=True)
# transaction_number = indexes.CharField(model_attr='transaction_number', null=True)
# street_address = indexes.CharField(model_attr='street_address', null=True)
# street_address2 = indexes.CharField(model_attr='street_address2', null=True)
# street_address3 = indexes.CharField(model_attr='street_address3', null=True)
# idvagency_id = indexes.CharField(model_attr='idvagency_id', null=True)
# idvpiid = indexes.CharField(model_attr='idvpiid', null=True)
# idvmodification_number = indexes.CharField(model_attr='idvmodification_number', null=True)
# signed_date = indexes.DateField(model_attr='signed_date', null=True)
class TransitSystemIndex(indexes.SearchIndex):
type = "transitsystem"
text = indexes.CharField(document=True, model_attr='name', null=True)
def prepare_text(self, object):
name = getattr(object, 'name')
city = getattr(object, 'city')
abbrev = getattr(object, 'common_name')
state = getattr(object, 'state')
if state:
state_name = state.name
state_code = state.abbreviation
else:
state_name = ''
state_code =''
uza = getattr(object, 'urbanized_area')
if uza: uza_name = uza.name
else: uza_name = ''
text = "%s %s %s %s %s %s" % (name, city, abbrev, state_name, state_code, uza_name)
return text
def get_queryset(self):
return TransitSystem.objects.all()
site.register(TransitSystem, TransitSystemIndex)
publications.append(section.publication.name)
return publications
def prepare_publication_exact(self, object):
publications = []
for section in object.section.all():
publications.append(section.publication.name)
return publications
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Channel.objects.all()
site.register (Channel, ChannelIndex)
class EpisodeIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
channel = indexes.CharField(model_attr='channel')
channel_exact = indexes.CharField(model_attr='channel', indexed=False)
# name = indexes.CharField(model_attr='name')
pub_date = indexes.DateTimeField(model_attr='pub_date')
# description = indexes.CharField(model_attr='description')
# keywords = indexes.CharField(model_attr='keywords')
producers = indexes.MultiValueField()
producers_exact = indexes.MultiValueField(indexed=False)
writers = indexes.MultiValueField()
writers_exact = indexes.MultiValueField(indexed=False)
reporters = indexes.MultiValueField()
reporters_exact = indexes.MultiValueField(indexed=False)
if object.recipient_state:
return object.recipient_state.id
else:
return -1
def prepare_principal_place_county(self, object):
if object.principal_place_county:
return object.principal_place_county.id
else:
return -1
def prepare_principal_place_state(self, object):
if object.principal_place_state:
return object.principal_place_state.id
else:
return -1
def prepare_sectors(self, object):
return map(lambda x: x.id, object.sectors.all())
def get_queryset(self):
"Used when the entire index for model is updated."
return Record.objects.all()
site.register(Record, RecordIndex)
from haystack import indexes
from haystack.sites import site
from make.projects.models import Project
class ProjectIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr = 'title')
description = indexes.CharField(model_attr = 'description')
owner = indexes.CharField(model_attr = 'owner')
site.register(Project, ProjectIndex)
import datetime
from haystack import indexes
from haystack.sites import site
from cfda.models import ProgramDescription
class ProgramDescriptionIndex(indexes.SearchIndex):
type = 'cfda'
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='program_title')
def prepare_cfda_program(self, object):
return str(object.program_number)
def get_queryset(self):
"Used when the entire index for model is updated."
# limit cfda indexing to programs that are included in a sector
return ProgramDescription.objects.filter(sectors__isnull=False)
site.register(ProgramDescription, ProgramDescriptionIndex)
from haystack import indexes
from haystack.sites import site
from models import Keyword, Metadata
class MetadataIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
image_LNID = indexes.CharField(model_attr='image_LNID')
copyright = indexes.BooleanField(model_attr='copyright', null=True)
subject = indexes.CharField(model_attr='subject')
site.register(Metadata, MetadataIndex)
except:
return None
def prepare_publication(self, object):
return object.blog.section.publication.name
def prepare_publication_exact(self, object):
return object.blog.section.publication.name
def get_updated_field(self):
return 'last_updated'
def get_queryset(self):
return Entry.objects.filter(pub_date__lte=datetime.datetime.now())
site.register (Entry, EntryIndex)
class BlogIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# title = indexes.CharField(model_attr='title')
# description = indexes.CharField(model_attr='description')
section = indexes.CharField(model_attr='section')
section_exact = indexes.CharField(model_attr='section', indexed=False)
publication = indexes.CharField()
publication_exact = indexes.CharField(indexed=False)
rendered = indexes.CharField(use_template=True, indexed=False,)
# def prepare(self, object):
# self.prepared_data = super(BlogIndex, self).prepare(object)
# return self.prepared_data
use_template=True,
indexed=False,
)
# def prepare(self, object):
# self.prepared_data = super(CalendarIndex, self).prepare(object)
# return self.prepared_data
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Calendar.objects.all()
site.register(Calendar, CalendarIndex)
class EventIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# name = indexes.CharField(model_attr='name')
# summary = indexes.CharField(model_attr='summary')
# description = indexes.CharField(model_attr='description')
start = indexes.DateTimeField(model_attr='start')
end = indexes.DateTimeField(model_attr='start', null=True)
# location = indexes.CharField(model_attr='location')
rendered = indexes.CharField(
use_template=True,
indexed=False,
)
from haystack.indexes import * from haystack.sites import site from paws.main import models class AnimalIndex(SearchIndex): text = CharField(document=True, use_template=True) species = CharField(model_attr='species') name = CharField(model_attr='name') class EnrichmentIndex(SearchIndex): text = CharField(document=True, use_template=True) subcategory = CharField(model_attr='subcategory') name = CharField(model_attr='name') class StaffIndex(SearchIndex): text = CharField(document=True, use_template=True) user = CharField(model_attr='user') site.register(models.Animal, AnimalIndex) site.register(models.Enrichment, EnrichmentIndex) site.register(models.Staff, StaffIndex)
from haystack import indexes
from haystack.sites import site
from word.models import Word
import datetime
class WordIndex(indexes.SearchIndex):
text = indexes.CharField(document=True,use_template=True)
secwepemc = indexes.CharField(model_attr='secwepemc')
english = indexes.CharField(model_attr='english')
def get_queryset(self):
"""Used when the entire index for model is updated."""
return Word.objects.all()
site.register(Word, WordIndex)
return (datetime.datetime.now() - instance.date_updated).seconds > 5
class BreweryIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
def should_update(self, instance):
"""
When certain actions happen, a brewery may be saved several times in a row.
In order to prevent indexing every single time, check the date_updated.
If it's less than five seconds ago, don't index the brewery again.
"""
return (datetime.datetime.now() - instance.date_updated).seconds > 5
class EntryIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
class UserIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
def should_update(self, instance):
""" Don't index users when they're just logging in. """
return (datetime.datetime.now() - instance.last_login).seconds > 10
class TagIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
site.register(Beer, BeerIndex)
site.register(Brewery, BreweryIndex)
# site.register(Entry, EntryIndex)
site.register(User, UserIndex)
site.register(Tag, TagIndex)
proxy = True
verbose_name = _("FAQ")
verbose_name_plural = _("FAQs")
def display(self):
return self.question
def description(self):
return self.question
def resulttype(self):
return _("[{0}] ".format("FAQ"))
def get_updated_field(self):
return self.date_modified
def get_absolute_url(self):
return "/faq/#{0}".format(self.slug)
class FaqIndex(SearchIndex):
text = CharField(document=True, use_template=True)
question = CharField(model_attr="question")
answer = CharField(model_attr="answer")
def get_queryset(self):
return SearchableFAQ.objects.filter(status=enums.STATUS_ACTIVE)
site.register(SearchableFAQ, FaqIndex)
def prepare_tags_exact(self, obj):
return [tag.title for tag in obj.tags.all()]
def prepare_publication(self, object):
return object.publication.name
def prepare_publication_exact(self, object):
return object.publication.name
def get_updated_field(self):
return 'last_updated'
def get_queryset(self):
return AudioClip.objects.filter(pub_date__lte=datetime.datetime.now())
site.register (AudioClip, AudioClipIndex)
class SlideshowIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# title = indexes.CharField(model_attr='title')
pub_date = indexes.DateTimeField(model_attr='pub_date')
# description = indexes.CharField(model_attr='description')
# static_byline = indexes.CharField(model_attr='static_byline')
contributors = indexes.MultiValueField()
contributors_exact = indexes.MultiValueField(indexed=False)
tags = indexes.MultiValueField()
tags_exact = indexes.MultiValueField(indexed=False)
publication = indexes.CharField()
publication_exact = indexes.CharField(indexed=False)
rendered = indexes.CharField(use_template=True, indexed=False,)
import datetime
from haystack import indexes
from haystack.sites import site
from morsels.models import Morsel, Page
class PageIndex(indexes.SearchIndex):
type = 'site'
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
url = indexes.CharField(model_attr='url')
def get_queryset(self):
"Used when the entire index for model is updated."
return Page.objects.all()
def should_update(self, instance=None):
"Disable update on save - re-index lag is causing problems with timeouts"
return False
site.register(Page, PageIndex)
text = indexes.CharField(document=True, use_template=True)
# name = indexes.CharField(model_attr='name')
rendered = indexes.CharField(use_template=True, indexed=False,)
# def prepare(self, object):
# self.prepared_data = super(CalendarIndex, self).prepare(object)
# return self.prepared_data
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Calendar.objects.all()
site.register (Calendar, CalendarIndex)
class EventIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# name = indexes.CharField(model_attr='name')
# summary = indexes.CharField(model_attr='summary')
# description = indexes.CharField(model_attr='description')
start = indexes.DateTimeField(model_attr='start')
end = indexes.DateTimeField(model_attr='start', null=True)
# location = indexes.CharField(model_attr='location')
rendered = indexes.CharField(use_template=True, indexed=False,)
# def prepare(self, object):
# self.prepared_data = super(EventIndex, self).prepare(object)
# return self.prepared_data
return publications
def prepare_publication_exact(self, object):
publications = []
for section in object.section.all():
publications.append(section.publication.name)
return publications
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Channel.objects.all()
site.register(Channel, ChannelIndex)
class EpisodeIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
channel = indexes.CharField(model_attr='channel')
channel_exact = indexes.CharField(model_attr='channel', indexed=False)
# name = indexes.CharField(model_attr='name')
pub_date = indexes.DateTimeField(model_attr='pub_date')
# description = indexes.CharField(model_attr='description')
# keywords = indexes.CharField(model_attr='keywords')
producers = indexes.MultiValueField()
producers_exact = indexes.MultiValueField(indexed=False)
writers = indexes.MultiValueField()
writers_exact = indexes.MultiValueField(indexed=False)
reporters = indexes.MultiValueField()
from authoring.models import AuthoredMaterial
from haystack.fields import IntegerField, CharField, MultiValueField
from haystack.sites import site
from materials.search_indexes import MaterialSearchIndex, AuthorsField, VocabularyMultiValueField
class AuthoredMaterialSearchIndex(MaterialSearchIndex):
creator = IntegerField(model_attr="author__id")
abstract = CharField(model_attr="abstract", weight=2.0)
url = CharField(model_attr="url", stored=True, indexed=False)
authors = AuthorsField(model_attr="authors", weight=1.0)
keywords = MultiValueField(model_attr="keyword_slugs")
keywords_names = MultiValueField(model_attr="keyword_names", weight=3.0)
general_subjects = VocabularyMultiValueField(model_attr="general_subjects")
grade_levels = VocabularyMultiValueField(model_attr="all_grade_levels")
grade_sublevels = VocabularyMultiValueField(model_attr="all_grade_sublevels")
grades = VocabularyMultiValueField(model_attr="all_grades")
media_formats = VocabularyMultiValueField(model_attr="media_formats")
languages = VocabularyMultiValueField(model_attr="languages")
course_material_types = VocabularyMultiValueField(model_attr="material_types")
collection = IntegerField(model_attr="collection__id", null=True)
collection_name = CharField(model_attr="collection__name", weight=2.0, null=True)
site.register(AuthoredMaterial, AuthoredMaterialSearchIndex)
from haystack import indexes
from haystack.sites import site
from faq.models import Topic, Question
class FAQIndexBase(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
url = indexes.CharField(model_attr='get_absolute_url', indexed=False)
class TopicIndex(FAQIndexBase):
title = indexes.CharField(model_attr='title', indexed=True)
def get_query_set(self):
return Topic.published.all()
class QuestionIndex(FAQIndexBase):
title = indexes.CharField(model_attr='question', indexed=True)
def get_query_set(self):
return Question.published.all()
site.register(Topic, TopicIndex)
site.register(Question, QuestionIndex)
import datetime
from haystack import indexes
from haystack.sites import site
from make.wiki.models import Page
class PageIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr="title")
content = indexes.CharField(model_attr="content")
site.register(Page, PageIndex)
# return self.prepared_data
def prepare_publication(self, object):
return object.section.publication.name
def prepare_publication_exact(self, object):
return object.section.publication.name
def get_updated_field(self):
return 'last_updated'
# def get_queryset(self):
# return Map.objects.all()
site.register(Map, MapIndex)
class PlaceIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
# name = indexes.CharField(model_attr='name')
# address = indexes.CharField(model_attr='address')
rendered = indexes.CharField(
use_template=True,
indexed=False,
)
# def prepare(self, object):
# self.prepared_data = super(PlaceIndex, self).prepare(object)
# return self.prepared_data
import datetime
from haystack import indexes
from haystack.sites import site
from make.forum.models import ForumPost, Thread, Poll
class ForumPostIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
thread = indexes.CharField(model_attr = 'thread')
body = indexes.CharField(model_attr = 'body')
poster = indexes.CharField(model_attr = 'poster')
class PollIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
topic = indexes.CharField(model_attr = 'topic')
poster = indexes.CharField(model_attr = 'poster')
description = indexes.CharField(model_attr = 'description')
class ThreadIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, use_template=True)
topic = indexes.CharField(model_attr = 'topic')
poster = indexes.CharField(model_attr = 'poster')
description = indexes.CharField(model_attr = 'description')
site.register(ForumPost, ForumPostIndex)
site.register(Thread, ThreadIndex)
site.register(Poll, PollIndex)
