class MetadataBaseIndex(CustomQuerySetIndex, indexes.Indexable): """ Subclassable class for creating III "metadata" indexes -- Locations, Itypes, etc. (E.g. admin parameters.) Most of them are just key/value pairs (code/label), so they follow a predictable pattern. In each subclass just be sure to set your model and type_name and any fields and/or prepare methods that need to be customized. The prepare_label method will always need to be overridden. See LocationIndex, etc., below for examples. """ model = None type_name = '' text = indexes.CharField(document=True, use_template=False) code = indexes.FacetCharField(model_attr='code') label = indexes.FacetCharField() type = indexes.FacetCharField() _version_ = indexes.IntegerField() def get_model(self): return self.model def prepare_label(self, obj): return None def prepare_type(self, obj): return self.type_name def prepare(self, obj): self.prepared_data = super(MetadataBaseIndex, self).prepare(obj) include = ('code', 'label', 'type') self.prepared_data["text"] = cat_fields(self.prepared_data, include=include) return self.prepared_data
class ExplicitFacetSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) author = indexes.CharField(faceted=True) title = indexes.CharField() title_facet = indexes.FacetCharField(facet_for="title") bare_facet = indexes.FacetCharField() def get_model(self): return MockModel
class CandidateIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) first_name = indexes.CharField(indexed=True) party = indexes.FacetCharField(indexed=True) college = indexes.FacetCharField(indexed=True) state = indexes.FacetCharField(indexed=True) issues = indexes.FacetMultiValueField(indexed=True) race = indexes.FacetCharField(indexed=True) race_type = indexes.FacetCharField(indexed=True) women = indexes.BooleanField(indexed=True) active = indexes.BooleanField(indexed=True) random = indexes.CharField() def get_model(self): return Candidate def prepare_first_name(self, obj): return obj.first_name def prepare_issues(self, obj): return [(issue.issue.parent_name) for issue in obj.issues.all()] or None def prepare_party(self, obj): return obj.party def prepare_state(self, obj): return obj.state def prepare_race(self, obj): if obj.race: return obj.race.title def prepare_active(self, obj): return obj.active def prepare_women(self, obj): if obj.man: return False return True def prepare_race_type(self, obj): if obj.race: return obj.race.race_type def prepare_random(self, obj): return random.randint(0, 99999999) def prepare_college(self, obj): if obj.college: return obj.college.name return None def index_queryset(self, using=None): """Used when the entire index for model is updated.""" return self.get_model().objects.all()
def __init__(self, queryset=None, using=None): super(MarcIndex, self).__init__(queryset=queryset, using=using) for mf in range(10, 1000): fname = 'mf_{:03d}'.format(mf) setattr(self, fname, indexes.FacetCharField(stored=False)) for sf in [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' ]: sfname = 'sf_{:03d}{}'.format(mf, sf) setattr(self, sfname, indexes.FacetCharField(stored=False))
class InitiativeIndex(AbstractIndex, indexes.ModelSearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) # facets years = indexes.FacetMultiValueField() recipients = indexes.FacetMultiValueField() agency = indexes.FacetCharField() aid_types = indexes.FacetMultiValueField() channels = indexes.FacetMultiValueField() finance_type = indexes.FacetCharField() sectors = indexes.FacetMultiValueField() def prepare_years(self, obj): return obj.years_range() def prepare_recipients(self, obj): return self._prepare_codelist(obj.recipients(), roots=False) def prepare_agency(self, obj): agency = obj.agency() return agency.code if agency else None def prepare_aid_types(self, obj): return self._prepare_codelist(obj.aid_types()) def prepare_channels(self, obj): return self._prepare_codelist(obj.channels()) def prepare_finance_type(self, obj): finance_type = obj.finance_type() return finance_type.code if finance_type else None def prepare_sectors(self, obj): return self._prepare_codelist(obj.sectors()) class Meta: model = Initiative # fields = ['years', 'recipients', 'agency', 'aid_types', # 'channels', 'finance_type', 'sectors', # 'code', 'start_year', 'end_year', 'has_focus'] excludes = [ 'code', 'title', 'total_project_costs', 'loan_amount_approved', 'grant_amount_approved', 'photo_set', 'document_set', 'updated_at', 'created_at' ] for f in Initiative._meta.fields: if f.attname.endswith('_temp') or f.attname[-3:] in ('_it', '_en'): excludes.append(f.attname)
class EventIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) # faceting fields date = indexes.FacetDateField(model_attr='date') institution = indexes.FacetCharField(model_attr='institution') title = indexes.CharField(indexed=False, stored=True, model_attr='title', default='') address = indexes.CharField(indexed=False, stored=True, model_attr='address') url = indexes.CharField(indexed=False, stored=True) n_acts = indexes.IntegerField() def get_model(self): return Event def prepare_url(self, obj): return obj.get_absolute_url() def prepare_n_acts(self, obj): return obj.eventact_set.count()
class AnswerBaseIndex(indexes.SearchIndex, indexes.Indexable): text = fields.CharFieldWithSynonyms(document=True, use_template=True, boost=10.0) autocomplete = indexes.EdgeNgramField(use_template=True, indexed=True) url = indexes.CharField(use_template=True, indexed=False) tags = indexes.MultiValueField(indexed=True, boost=10.0) language = indexes.CharField(model_attr='language') suggestions = indexes.FacetCharField() def prepare_answer(self, obj): data = super(AnswerBaseIndex, self).prepare(obj) if obj.question.lower().startswith('what is'): data['boost'] = 2.0 return data def prepare_tags(self, obj): return obj.clean_search_tags def prepare(self, obj): data = super(AnswerBaseIndex, self).prepare(obj) data['suggestions'] = data['text'] return data def get_model(self): return AnswerPage def index_queryset(self, using=None): return self.get_model().objects.filter(live=True, redirect_to_page=None)
class UserInfoIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) courses = indexes.MultiValueField(indexed=True, stored=True) suggestions = indexes.FacetCharField() def prepare(self, obj): prepared_data = super(UserInfoIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data def prepare_courses(self, obj): return [str(s) for s in obj.courses.all()] def index_queryset(self): """Used when the entire index for model is updated.""" return self.get_model().objects.filter(user__is_active=True) def get_model(self): return UserInfo def should_update(self, instance, **kwargs): if True: return True else: self.remove_object(instance, **kwargs) return False
class MeagazinesIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) Title = indexes.CharField(model_attr='Title') Keywords = indexes.CharField(model_attr='Keywords') Author = indexes.CharField(model_attr='Author') Description = indexes.CharField(model_attr='Description') FiledOfStudies = indexes.CharField(model_attr='FiledOfStudies') content_auto_1 = indexes.EdgeNgramField(model_attr='Title') content_auto_2 = indexes.EdgeNgramField(model_attr='Keywords') content_auto_3 = indexes.EdgeNgramField(model_attr='Author') content_auto_4 = indexes.EdgeNgramField(model_attr='Description') content_auto_5 = indexes.EdgeNgramField(model_attr='FiledOfStudies') suggestions = indexes.FacetCharField() def prepare(self, obj): prepared_data = super(MeagazinesIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data def get_model(self): return Meagazines def index_queryset(self, using=None): """Used when the entire index for model is updated.""" return self.get_model().objects.all()
class ProductIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField( document=True, use_template=True, template_name= '/home/gublu/Desktop/DjangoHasytackElasticSearchDemo/searchDemo/templates/search/indexes/product_text.txt' ) title = indexes.EdgeNgramField(model_attr='title') description = indexes.EdgeNgramField(model_attr="description", null=True) category = indexes.CharField(model_attr='category', faceted=True) brand = indexes.CharField(model_attr='brand', faceted=True) # for auto complete content_auto = indexes.EdgeNgramField(model_attr='title') # Spelling suggestions suggestions = indexes.FacetCharField() def get_model(self): return Product def index_queryset(self, using=None): """Used when the entire index for model is updated.""" return self.get_model().objects.filter(timestamp__lte=timezone.now())
class ClassNumberIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) suggestions = indexes.FacetCharField() def prepare(self, obj): prepared_data = super(ClassNumberIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data def prepare_text(self, obj): return obj.number + " " + obj.class_obj.title def index_queryset(self): """Used when the entire index for model is updated.""" return self.get_model().objects.all() def get_model(self): return ClassNumber def should_update(self, instance, **kwargs): if True: return True else: self.remove_object(instance, **kwargs) return False
class MyfeedIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField( document=True, use_template=True, template_name='/home/aptus/rssfeeds/Td/feed/templates/search/indexes/myfeed_text.txt') title = indexes.EdgeNgramField(model_attr='title') slug = indexes.EdgeNgramField(model_attr='slug', null=True) description = indexes.EdgeNgramField(model_attr="description", null=True) category = indexes.CharField(model_attr='category', null=True, faceted=True) main_link = indexes.CharField(model_attr='main_link', null=True, faceted=True) sub_link = indexes.CharField(model_attr='sub_link', null=True, faceted=True) tag_id = indexes.CharField(model_attr='tag_id', null=True, faceted=True) published = indexes.CharField(model_attr='published', null=True, faceted=True) updated = indexes.CharField(model_attr='updated', null=True, faceted=True) # for auto complete content_auto = indexes.EdgeNgramField(model_attr='title') # Spelling suggestions suggestions = indexes.FacetCharField() def get_model(self): return Myfeed def index_queryset(self, using=None): """Used when the entire index for model is updated.""" return self.get_model().objects.filter(timestamp__lte=timezone.now())
class CardIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) SubjectName = indexes.CharField(model_attr='SubjectName', faceted=True, null=True) SubjectDescription = indexes.CharField(model_attr="SubjectDescription", faceted=True, null=True) PhotoDescription = indexes.CharField(model_attr="PhotoDescription", faceted=True, null=True) Photographer = indexes.CharField(model_attr="Photographer", faceted=True, null=True) Location = indexes.CharField(model_attr="Location", faceted=True, null=True) BoxNumber = indexes.MultiValueField(indexed=True, stored=True) Negative = indexes.CharField(model_attr="Negative", faceted=True, null=True) Year = indexes.IntegerField(model_attr="Year", faceted=True, null=True) Day = indexes.IntegerField(model_attr="Day", faceted=True, null=True) Month = indexes.IntegerField(model_attr="Month", faceted=True, null=True) date = indexes.CharField(model_attr="date", faceted=True, null=True) Quantity = indexes.IntegerField(model_attr="Quantity", faceted=True, null=True) suggestions = indexes.FacetCharField() def get_model(self): return Card def prepare_BoxNumber(self, object): return [BoxNumber.box for BoxNumber in object.BoxNumber.all()]
class PublicBodyIndex(SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField(document=True, use_template=True) name = indexes.CharField(model_attr='name', boost=1.5) name_auto = indexes.NgramField(model_attr='name') jurisdiction = indexes.FacetCharField(model_attr='jurisdiction__name', default='') tags = indexes.FacetMultiValueField() url = indexes.CharField(model_attr='get_absolute_url') def get_model(self): return PublicBody def index_queryset(self, **kwargs): """Used when the entire index for model is updated.""" return self.get_model().objects.get_for_search_index() def prepare_tags(self, obj): return [t.name for t in obj.tags.all()] def prepare(self, obj): data = super(PublicBodyIndex, self).prepare(obj) if obj.classification in PUBLIC_BODY_BOOSTS: data['boost'] = PUBLIC_BODY_BOOSTS[obj.classification] print("Boosting %s at %f" % (obj, data['boost'])) return data
class PublicBodyIndex(SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField(document=True, use_template=True) name = indexes.CharField(model_attr='name', boost=1.5) name_auto = SuggestField(model_attr='all_names', boost=2.5) jurisdiction = indexes.FacetCharField(model_attr='jurisdiction__name', default='') classification = indexes.FacetMultiValueField() categories = indexes.FacetMultiValueField() def get_model(self): return PublicBody def index_queryset(self, **kwargs): """Used when the entire index for model is updated.""" return self.get_model().objects.get_for_search_index() def prepare_classification(self, obj): if obj.classification is None: return [] return [obj.classification.name ] + [c.name for c in obj.classification.get_ancestors()] def prepare_categories(self, obj): cats = obj.categories.all() return [o.name for o in cats ] + [c.name for o in cats for c in o.get_ancestors()]
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 ProductIndex(indexes.SearchIndex, indexes.Indexable): # template_name='/home/manhee/anaconda3/envs/djviews1/src/templates/product_text.txt' text = indexes.EdgeNgramField(model_attr='name', document=True, use_template=True) category = indexes.CharField(model_attr='cat_id__rus_name', faceted=True) name = indexes.EdgeNgramField(model_attr='name') price = indexes.IntegerField(model_attr='price') cond = indexes.CharField(model_attr='cond', faceted=True) brand = indexes.CharField(model_attr='brand', faceted=True) car = indexes.CharField(model_attr='car', faceted=True) car_model = indexes.CharField(model_attr='car_model', faceted=True) cat_n = indexes.CharField(model_attr='cat_n') color = indexes.CharField(model_attr='color') fuel = indexes.CharField(model_attr='fuel', faceted=True) value = indexes.CharField(model_attr='value', faceted=True) cat_id = indexes.IntegerField(model_attr='cat_id__id') # for auto complete content_auto = indexes.EdgeNgramField(model_attr='name') # Spelling suggestions suggestions = indexes.FacetCharField() def get_model(self): return AlegroGoodsSpec def index_queryset(self, using=None): """Used when the entire index for model is updated.""" return self.get_model().objects.all()
class ProjectIndex(AbstractIndex, indexes.ModelSearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) # facets years = indexes.FacetMultiValueField() # facets for code-lists recipient = indexes.FacetCharField() agencies = indexes.FacetMultiValueField() aid_types = indexes.FacetMultiValueField() channels = indexes.FacetMultiValueField() finance_types = indexes.FacetMultiValueField() sectors = indexes.FacetMultiValueField() def prepare_recipient(self, obj): return obj.recipient.code def prepare_agencies(self, obj): return self._prepare_codelist(obj.agencies(), roots=False) def prepare_aid_types(self, obj): return self._prepare_codelist(obj.aid_types()) def prepare_channels(self, obj): return self._prepare_codelist(obj.channels()) def prepare_finance_types(self, obj): return self._prepare_codelist(obj.finance_types()) def prepare_sectors(self, obj): return self._prepare_codelist(obj.sectors()) def get_facets_counts(self): return self.objects.facet('year').facet_counts().get('fields', {}) class Meta: model = Project # fields = ['years', 'markers', 'recipient', 'agency', 'aid_type', # 'channel', 'finance_type', 'sector', 'initiative', # 'crsid', 'start_year', 'end_year', 'has_focus'] excludes = [ 'is_suspended', 'status', 'expected_start_year', 'expected_completion_year', 'expected_start_date', 'completion_date', 'last_update', 'outcome', 'beneficiaries', 'beneficiaries_female', 'total_project_costs', 'other_financiers', 'loan_amount_approved', 'grant_amount_approved', 'counterpart_authority', 'email', 'location', 'description', 'title', 'title_it', 'title_en', 'description_it', 'description_en', 'number', 'outcome_it', 'beneficiaries_it', 'other_financiers_it', 'counterpart_authority_it', 'location_it', 'outcome_en', 'beneficiaries_en', 'other_financiers_en', 'counterpart_authority_en', 'location_en' ]
class ElasticsearchFacetingMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) author = indexes.CharField(model_attr='author', faceted=True) editor = indexes.CharField(model_attr='editor', faceted=True) pub_date = indexes.DateField(model_attr='pub_date') facet_field = indexes.FacetCharField(model_attr='author') def prepare_text(self, obj): return '%s %s' % (obj.author, obj.editor) def get_model(self): return AFourthMockModel
class SubcategoryIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) name = indexes.CharField(model_attr='name') slug_sub = indexes.CharField(model_attr='slug_sub') suggestions = indexes.FacetCharField() def get_model(self): return Subcategory def prepare(self, obj): prepared_data = super(SubcategoryIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data
class OrganizationIndex(CelerySearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) created = indexes.DateTimeField(model_attr='created') modified = indexes.DateTimeField(model_attr='modified') state = indexes.FacetCharField(model_attr='state') tags = indexes.FacetMultiValueField() def prepare_tags(self, my_model): return [tag.id for tag in my_model.tags.all()] def get_model(self): return models.Organization
class CommunityIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField(document=True, model_attr='name') category = indexes.CharField(model_attr='category', faceted=True) created_at = indexes.DateTimeField(model_attr='created_at', faceted=True) # for spelling suggestions suggestions = indexes.FacetCharField() def get_model(self): return Community def index_queryset(self, using=None): # """Used when the entire index for model is updated.""" return self.get_model().objects.all()
class ServerIndex(indexes.SearchIndex, indexes.Indexable): name = indexes.CharField(model_attr='name') hostname = indexes.CharField(model_attr='hostname') ip = indexes.CharField(model_attr='ip') category = indexes.FacetCharField(model_attr='category__name') description = indexes.CharField(model_attr='description') fqdn = indexes.CharField() text = indexes.CharField(document=True) operating_system = indexes.FacetCharField(model_attr='operating_system') distribution = indexes.FacetCharField( model_attr='operating_system__distribution') platform = indexes.FacetCharField(model_attr='operating_system__platform') def get_model(self): return Server def index_queryset(self, using=None): return self.get_model().objects.all() def prepare_fqdn(self, object): return '{}.{}'.format(object.hostname, object.domain.fqdn)
class PublisherIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) document = indexes.FacetCharField(default='Publisher') title = indexes.CharField() url = indexes.CharField(model_attr='url', indexed=False) def get_model(self): return Publisher def index_queryset(self, using=None): return self.get_model().objects.filter(live=True) def prepare_title(self, publisher): return publisher.__unicode__()
class AddressIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) city = indexes.CharField(model_attr='city__name') company = indexes.CharField(model_attr='company__pk') suggestions = indexes.FacetCharField() def prepare(self, obj): prepared_data = super(AddressIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data def get_model(self): return Address
class BaseIndex(indexes.SearchIndex): text = indexes.CharField(document=True, use_template=True) name = indexes.CharField(model_attr='name') slug = indexes.CharField(model_attr='slug') file = indexes.CharField(model_attr='file') suggestions = indexes.FacetCharField() class Meta: abstract = True def prepare(self, obj): prepared_data = super(BaseIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data
class WorkIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) document = indexes.FacetCharField(default='General information') title = indexes.CharField(model_attr='title') sort_order = indexes.FloatField(model_attr='sort_order') url = indexes.CharField(model_attr='url', indexed=False) def get_model(self): return Work def index_queryset(self, using=None): return self.get_model().objects.filter(live=True) def prepare_text(self, work): return work.heading
class GoodFacetedMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author") author_foo = indexes.FacetCharField(facet_for="author") pub_date = indexes.DateTimeField(model_attr="pub_date") pub_date_exact = indexes.FacetDateTimeField(facet_for="pub_date") def get_model(self): return MockModel def prepare_author(self, obj): return "Hi, I'm %s" % self.prepared_data["author"] def prepare_pub_date_exact(self, obj): return "2010-10-26T01:54:32"
class ProductIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.EdgeNgramField(document=True, use_template=True, template_name="search/product_text.txt") name = indexes.EdgeNgramField(model_attr='name') description = indexes.EdgeNgramField(model_attr='description') category = indexes.CharField(model_attr='category', faceted=True) producer = indexes.CharField(model_attr='producer', faceted=True) content_auto = indexes.EdgeNgramField(model_attr='name') suggestions = indexes.FacetCharField() def get_model(self): return Product def index_queryset(self, using=None): return self.get_model().objects.all()
class PostIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr='user') pub_date = indexes.DateTimeField(model_attr='pub_date') suggestions = indexes.FacetCharField() def prepare(self, obj): prepared_data = super(PostIndex, self).prepare(obj) prepared_data['suggestions'] = prepared_data['text'] return prepared_data def get_model(self): return Post 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())