class MyModelDocument(Document):
# year = fields.CompletionField()
# name = fields.CompletionField()
# country = fields.CompletionField()
# productID = fields.CompletionField()
# id = fields.CompletionField()
class Index:
name = 'mymodels'
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
id = fields.IntegerField(attr='id')
name = fields.TextField(
# analyzer=html_strip,
fields={'raw': fields.KeywordField()})
country = fields.TextField(
# analyzer=html_strip,
fields={'raw': fields.KeywordField()})
year = fields.TextField(
# analyzer=html_strip,
fields={'raw': fields.KeywordField()})
productID = fields.FloatField(
# analyzer=html_strip,
fields={'raw': fields.KeywordField()})
class Django:
model = MyModel
fields = []
class ConventionDocument(DocType):
label = fields.KeywordField()
slot = fields.KeywordField()
class Meta:
model = Convention
fields = ('year', )
class DocketEntryDocument(DocType):
court = fields.ObjectField(properties={
'description': fields.TextField(),
'name': fields.KeywordField(),
})
case = fields.ObjectField(
properties={
'year': fields.KeywordField(),
'number': fields.KeywordField(),
'office': fields.KeywordField(),
'type': fields.KeywordField(),
})
class Meta:
model = models.DocketEntry
fields = [
'case_number',
'case_name',
'title',
'time_filed',
]
# related_models = [models.Court]
ignore_signals = True
auto_refresh = False
def get_queryset(self):
qs = super().get_queryset().select_related('court')
# FIXME out of +1M entries, only 10 have a blank case_name, for now just exclude them
qs = qs.exclude(
case_name='') # ES doesn't allow emtpy values on completions
qs = qs[:1000] # for testing only index the first X items
return qs
class MeetingDoc(Document):
id = fields.IntegerField()
title = fields.StringField()
description = fields.TextField()
venue = fields.StringField()
start_date = fields.DateField()
start_time = fields.KeywordField(attr='start_time_str')
end_time = fields.KeywordField(attr='end_time_str')
materials = fields.NestedField(
properties={
'id': fields.IntegerField(),
'download_url': fields.KeywordField(),
'name': fields.KeywordField(),
})
class Index:
name = mcs.ELASTICSEARCH_INDEX_NAMES['meetings']
settings = mcs.ELASTICSEARCH_DSL_INDEX_SETTINGS
class Django:
model = Meeting
related_models = [
MeetingFile,
]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, MeetingFile):
return related_instance.meeting
def get_queryset(self):
return super().get_queryset().published()
class NoteDocument(Document):
"""Note Elastic search document."""
class Django:
model = Note
id = fields.StringField(attr='id', analyzer="standard")
title = fields.StringField(fields={
'raw': fields.KeywordField(),
})
user = fields.StringField(attr='user_indexing',
fields={
'raw': fields.KeywordField(),
})
content = fields.StringField(fields={
'raw': fields.KeywordField(),
})
label = fields.StringField(attr='label_indexing',
fields={'raw': fields.KeywordField()})
collaborator = fields.StringField(attr='collaborator_indexing',
fields={
'raw': fields.KeywordField(),
})
is_archive = fields.BooleanField()
is_pin = fields.BooleanField()
is_trash = fields.BooleanField()
reminder = fields.DateField()
class OrganizationDocument(Document):
class Index:
name = 'organizations'
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
last_update = fields.DateField(attr='updated_at')
public_can_view = fields.BooleanField(attr='public_can_view')
name = fields.KeywordField(attr='name', normalizer="lowercase")
mnemonic = fields.KeywordField(attr='mnemonic', normalizer="lowercase")
extras = fields.ObjectField()
user = fields.ListField(fields.KeywordField())
class Django:
model = Organization
fields = [
'is_active',
'company',
'location',
]
@staticmethod
def prepare_extras(instance):
return instance.extras or {}
@staticmethod
def prepare_user(instance):
return list(instance.members.values_list('username', flat=True))
def datasets_field(**kwargs):
return fields.NestedField(properties={
'id':
fields.IntegerField(),
'title':
TranslatedTextField('title'),
'notes':
TranslatedTextField('notes'),
'category':
fields.KeywordField(attr='category.title'),
'formats':
fields.KeywordField(attr='formats', multi=True),
'downloads_count':
fields.IntegerField(attr='computed_downloads_count'),
'views_count':
fields.IntegerField(attr='computed_views_count'),
'openness_scores':
fields.IntegerField(attr='openness_scores'),
'modified':
fields.DateField(),
'slug':
TranslatedKeywordField('slug'),
'verified':
fields.DateField(),
},
**kwargs)
class UniversityDocument(Document):
"""University Elasticsearch document."""
id = fields.IntegerField(attr='id')
name = fields.TextField(fields={
'raw':
fields.KeywordField(normalizer=keyword_normalizer),
}, )
domain = fields.TextField(
fields={'raw': fields.KeywordField(normalizer=keyword_normalizer)})
web_page = fields.TextField(
fields={'raw': fields.KeywordField(normalizer=keyword_normalizer)})
country = fields.ObjectField(
properties={
'name':
fields.TextField(),
'code':
fields.TextField(
fields={
'raw': fields.KeywordField(normalizer=keyword_normalizer)
}),
})
createdAt = fields.DateField()
isDelete = fields.BooleanField()
class Django(object):
"""Meta options."""
model = University # The model associate with this DocType
class ExperimentDocument(Document):
class Index:
name = 'experiments'
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
id = fields.IntegerField()
title = fields.TextField(fields={'raw': fields.KeywordField()},
analyzer=analyzer)
description = fields.TextField(fields={'raw': fields.KeywordField()},
analyzer=analyzer)
public_access = fields.IntegerField()
created_time = fields.DateField()
start_time = fields.DateField()
end_time = fields.DateField()
update_time = fields.DateField()
institution_name = fields.StringField()
created_by = fields.ObjectField(properties={
'username':
fields.StringField(fields={'raw': fields.KeywordField()}, )
})
objectacls = fields.ObjectField(properties={
'pluginId': fields.StringField(),
'entityId': fields.StringField()
})
class Django:
model = Experiment
related_models = [User, ObjectACL]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, User):
return related_instance.experiment_set.all()
if isinstance(related_instance, ObjectACL):
return related_instance.content_object
return None
class LabEventDoc(Document):
id = fields.IntegerField()
title = TranslatedTextField('title')
notes = TranslatedTextField('notes')
event_type = fields.KeywordField()
execution_date = fields.DateField()
reports = fields.NestedField(
properties={
'type': fields.KeywordField(attr='report_type'),
'download_url': fields.TextField(),
'link': fields.StringField(),
}
)
class Index:
name = settings.ELASTICSEARCH_INDEX_NAMES['lab_events']
settings = settings.ELASTICSEARCH_DSL_INDEX_SETTINGS
class Django:
model = LabEvent
related_models = [LabReport, ]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, LabReport):
return related_instance.lab_event
def get_queryset(self):
return super().get_queryset().filter(status='published')
class NoteDocument(Document):
"""
Document for the Note index.
"""
id = fields.IntegerField(attr='id')
user = fields.KeywordField(attr='user_id')
course_id = fields.KeywordField()
usage_id = fields.KeywordField()
quote = fields.TextField(analyzer=html_strip)
text = fields.TextField(analyzer=html_strip)
ranges = fields.KeywordField()
created = fields.DateField()
updated = fields.DateField()
tags = fields.TextField(multi=True, analyzer=case_insensitive_keyword)
def prepare_data(self, instance):
"""
Prepare data.
"""
return '{0}{1}'.format(instance.text, instance.tags)
def prepare_tags(self, instance):
return json.loads(instance.tags)
class Django:
model = Note
class Meta:
parallel_indexing = True
queryset_pagination = 50
class SiteReportDocument(Document):
class Index:
# Name of the Elasticsearch index
name = "site_reports"
# See Elasticsearch Indices API reference for available settings
settings = {"number_of_shards": 1, "number_of_replicas": 0}
campaign = fields.ObjectField(properties={"slug": fields.KeywordField()})
topic = fields.ObjectField(properties={"slug": fields.KeywordField()})
class Django:
model = SiteReport
fields = [
"created_on",
"assets_total",
"assets_published",
"assets_not_started",
"assets_in_progress",
"assets_waiting_review",
"assets_completed",
"assets_unpublished",
"items_published",
"items_unpublished",
"projects_published",
"projects_unpublished",
"anonymous_transcriptions",
"transcriptions_saved",
"distinct_tags",
"tag_uses",
"campaigns_published",
"campaigns_unpublished",
"users_registered",
"users_activated",
]
class UserDocument(Document):
id = fields.IntegerField()
username = fields.TextField(fields={
'raw': fields.KeywordField(),
'suggest': fields.CompletionField(),
}, )
username_color = fields.KeywordField()
role = fields.IntegerField(attr='role_id')
role_icon = fields.IntegerField(attr='icon')
active_badge = fields.IntegerField(attr='badge')
custom_images = fields.IntegerField(attr='custom_images_indexing',
multi=True)
class Index:
name = 'user'
class Django:
model = User
related_models = Image,
def get_queryset(self):
return super().get_queryset().select_related(
'role').prefetch_related_images()
@staticmethod
def get_instances_from_related(related_instance) -> (list, None):
if related_instance.is_icon:
return related_instance.icon_owners.values_list('id', flat=True)
if related_instance.is_custom:
return related_instance.custom_owners.values_list('id', flat=True)
class ProductDocument(Document):
title = fields.TextField(
analyzer=custom_analyzer,
fields={ 'raw' : fields.KeywordField() }
)
description = fields.TextField(
analyzer=custom_analyzer,
fields={'raw' : fields.KeywordField()}
)
features = fields.TextField(
analyzer=custom_analyzer,
fields={'raw' : fields.KeywordField()}
)
class Index:
name = 'products'
settings = {'number_of_shards': 1,
'number_of_replicas': 0}
class Django:
model = Product
fields = [
'id',
# 'description',
# 'features',
# 'title',
]
class TenderDoc(DocType):
description = fields.TextField(
analyzer=case_insensitive_analyzer,
fielddata=True,
fields={
'raw':
fields.KeywordField(multi=True,
ignore_above=256,
normalizer=case_insensitive_normalizer)
})
title = fields.TextField(analyzer=case_insensitive_analyzer,
fielddata=True,
fields={
'raw':
fields.KeywordField(
multi=True,
ignore_above=256,
normalizer=case_insensitive_normalizer)
})
reference = fields.KeywordField(attr='reference')
class Meta:
model = Tender
fields = [
'unspsc_codes',
'cpv_codes',
'organization',
'source',
'notified',
]
class AssetDocument(Document):
class Index:
# Name of the Elasticsearch index
name = "assets"
# See Elasticsearch Indices API reference for available settings
settings = {"number_of_shards": 1, "number_of_replicas": 0}
item = fields.ObjectField(
properties={
"item_id": fields.KeywordField(),
"project": fields.ObjectField(
properties={
"slug": fields.KeywordField(),
"campaign": fields.ObjectField(
properties={"slug": fields.KeywordField()}
),
"topics": fields.NestedField(
properties={"slug": fields.KeywordField()}
),
}
),
}
)
transcription_status = fields.KeywordField()
latest_transcription = fields.ObjectField(
properties={
"created_on": fields.DateField(),
"updated_on": fields.DateField(),
"accepted": fields.DateField(),
"rejected": fields.DateField(),
"submitted": fields.DateField(),
}
)
submission_count = fields.IntegerField()
def prepare_submission_count(self, instance):
return Transcription.objects.filter(
asset=instance, submitted__isnull=True
).count()
class Django:
model = Asset
fields = ["published", "difficulty", "slug", "sequence", "year"]
def get_queryset(self):
return (
super()
.get_queryset()
.order_by("pk")
.prefetch_related(
"item",
"item__project",
"item__project__topics",
"item__project__campaign",
)
)
class TranscriptionDocument(Document):
class Index:
# Name of the Elasticsearch index
name = "transcriptions"
# See Elasticsearch Indices API reference for available settings
settings = {"number_of_shards": 1, "number_of_replicas": 0}
asset = fields.ObjectField(
properties={
"title": fields.TextField(),
"slug": fields.TextField(),
"transcription_status": fields.KeywordField(),
"item": fields.ObjectField(
properties={
"item_id": fields.TextField(),
"project": fields.ObjectField(
properties={
"slug": fields.KeywordField(),
"campaign": fields.ObjectField(
properties={"slug": fields.KeywordField()}
),
"topics": fields.NestedField(
properties={"slug": fields.KeywordField()}
),
}
),
}
),
}
)
user = fields.ObjectField(properties={"id": fields.IntegerField()})
reviewed_by = fields.ObjectField(properties={"id": fields.IntegerField()})
supersedes = fields.ObjectField(properties={"id": fields.IntegerField()})
class Django:
model = Transcription
fields = [
"id",
"created_on",
"updated_on",
"text",
"accepted",
"rejected",
"submitted",
]
def get_queryset(self):
return (
super()
.get_queryset()
.order_by("pk")
.prefetch_related(
"asset__item",
"asset__item__project",
"asset__item__project__topics",
"asset__item__project__campaign",
)
)
class PublicBodyDocument(DocType):
name = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
name_auto = fields.TextField(attr='all_names', analyzer=ngram_analyzer)
content = fields.TextField(analyzer=analyzer)
jurisdiction = fields.IntegerField(attr='jurisdiction_id')
classification = fields.ListField(fields.IntegerField())
categories = fields.ListField(fields.IntegerField())
regions = fields.ListField(fields.IntegerField())
regions_exact = fields.ListField(fields.IntegerField())
regions_kind = fields.ListField(fields.KeywordField())
class Meta:
model = PublicBody
queryset_chunk_size = 100
def get_queryset(self):
"""Not mandatory but to improve performance we can select related in one sql request"""
return super().get_queryset().select_related(
'jurisdiction').prefetch_related('classification', 'categories',
'regions')
def prepare_content(self, obj):
content = [
obj.name, obj.other_names,
obj.jurisdiction.name if obj.jurisdiction else '', obj.email or '',
obj.description, obj.contact, obj.address, obj.url,
obj.classification.name if obj.classification else ''
] + [o.name for o in obj.categories.all()]
return ' '.join(c for c in content if c)
def prepare_classification(self, obj):
if obj.classification is None:
return []
return [obj.classification.id
] + [c.id for c in obj.classification.get_ancestors()]
def prepare_categories(self, obj):
cats = obj.categories.all()
return [o.id for o in cats
] + [c.id for o in cats for c in o.get_ancestors()]
def prepare_regions(self, obj):
regs = obj.regions.all()
return [o.id for o in regs
] + [c.id for o in regs for c in o.get_ancestors()]
def prepare_regions_exact(self, obj):
regs = obj.regions.all()
return [o.id for o in regs]
def prepare_regions_kind(self, obj):
regs = obj.regions.all()
return [o.kind for o in regs]
class PageDocument(DocType):
# Metadata
project = fields.KeywordField(attr='project.slug')
version = fields.KeywordField(attr='version.slug')
path = fields.KeywordField(attr='processed_json.path')
# Searchable content
title = fields.TextField(attr='processed_json.title')
headers = fields.TextField(attr='processed_json.headers')
content = fields.TextField(attr='processed_json.content')
class Meta(object):
model = HTMLFile
fields = ('commit',)
ignore_signals = True
@classmethod
def faceted_search(
cls, query, user, projects_list=None, versions_list=None, filter_by_user=True
):
from readthedocs.search.faceted_search import PageSearch
kwargs = {
'user': user,
'query': query,
'filter_by_user': filter_by_user,
}
filters = {}
if projects_list:
filters['project'] = projects_list
if versions_list:
filters['version'] = versions_list
kwargs['filters'] = filters
return PageSearch(**kwargs)
def get_queryset(self):
"""Overwrite default queryset to filter certain files to index"""
queryset = super(PageDocument, self).get_queryset()
# Exclude some files to not index
excluded_files = [
'search.html',
'genindex.html',
'py-modindex.html',
'search/index.html',
'genindex/index.html',
'py-modindex/index.html',
]
# Do not index files that belong to non sphinx project
# Also do not index certain files
queryset = queryset.filter(project__documentation_type__contains='sphinx')
for ending in excluded_files:
queryset = queryset.exclude(path__endswith=ending)
return queryset
class HyperManagerDocument(Document):
id = fields.IntegerField()
name = KeywordField()
url = fields.KeywordField()
online = fields.BooleanField()
version = fields.KeywordField()
class Django(object):
model = HyperManager
class ArticleDocument(Document):
title = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
url = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
description = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
start_publication = fields.DateField()
author = fields.ListField(fields.IntegerField())
category = fields.ListField(fields.IntegerField())
content = fields.TextField(analyzer=analyzer,
search_analyzer=search_analyzer,
search_quote_analyzer=search_quote_analyzer,
index_options='offsets')
special_signals = True
class Django:
model = Article
queryset_chunk_size = 100
def get_queryset(self):
return Article.published.all()
def prepare_content(self, obj):
html = obj.get_html_content()
return ' '.join([obj.title, obj.description,
strip_tags(html)] +
[o.title for o in obj.categories.all()] +
[t.name for t in obj.tags.all()])
def prepare_description(self, obj):
return strip_tags(obj.description)
def prepare_url(self, obj):
return obj.get_absolute_url()
def prepare_title(self, obj):
return obj.title
def prepare_start_publication(self, obj):
return obj.start_publication
def prepare_category(self, obj):
cats = obj.categories.all()
return [o.id for o in cats]
def prepare_author(self, obj):
authors = obj.authors.all()
return [o.id for o in authors]
class RepositoryExampleDocument(Document):
time_based = False
repository_version_language = fields.ObjectField(
properties={
"pk": fields.IntegerField(),
"language": fields.TextField(fields={"raw": fields.KeywordField()}),
}
)
intent = fields.ObjectField(
properties={"text": fields.TextField(fields={"raw": fields.KeywordField()})}
)
entities = fields.NestedField(
properties={
"entity": fields.ObjectField(
properties={
"value": fields.TextField(fields={"raw": fields.KeywordField()}),
}
),
}
)
pk = fields.IntegerField()
class Django:
model = RepositoryExample
fields = [
"id",
"text",
]
related_models = [
RepositoryVersionLanguage,
RepositoryIntent,
RepositoryExampleEntity,
]
def get_queryset(self):
return (
super(RepositoryExampleDocument, self)
.get_queryset()
.select_related(
"repository_version_language",
"intent",
)
.prefetch_related(
"entities",
"translations",
)
)
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, RepositoryVersionLanguage):
return related_instance.added.all()
elif isinstance(related_instance, RepositoryIntent):
return related_instance.repositoryexample_set.all()
elif isinstance(related_instance, RepositoryExampleEntity):
return related_instance.repository_example
class CLCEntry(InnerDoc):
rating = fields.KeywordField(
fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),},
copy_to="wildcard",
)
text = fields.TextField(copy_to="wildcard", analyzer=descriptive_text_analyzer)
category = fields.KeywordField(
fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),},
)
parent = fields.ObjectField(doc_class=CLCEntryParent)
class AwardDoc(DocType):
tender_title = fields.KeywordField(attr='tender.title')
vendors_name = fields.KeywordField(attr='get_vendors')
value = fields.TextField(attr="convert_value_to_string")
class Meta:
model = Award
fields = [
'currency',
]
class ExperimentDocument(Document):
""" Our Experiment ElasticSearch Document, which
corresponds to our Experiment model. """
# Keyword Fields
title = fields.TextField(analyzer=html_strip,
fielddata=True,
fields={"raw": fields.KeywordField()})
publication_title = fields.TextField(analyzer=html_strip,
fielddata=True,
fields={"raw": fields.KeywordField()})
description = fields.TextField(analyzer=html_strip,
fielddata=True,
fields={"raw": fields.KeywordField()})
publication_authors = fields.TextField(
analyzer=html_strip,
fielddata=True,
fields={"raw": fields.KeywordField()})
technology = fields.TextField(analyzer=html_strip_no_stop,
fielddata=True,
fields={"raw": fields.KeywordField()})
organism_names = fields.TextField(analyzer=html_strip_no_ngram,
fielddata=True,
fields={"raw": fields.KeywordField()})
platform_names = fields.TextField(analyzer=standard_keyword,
fielddata=True,
fields={"raw": fields.TextField()})
platform_accession_codes = fields.TextField(
analyzer=standard_keyword,
fielddata=True,
fields={"raw": fields.TextField()})
# Basic Fields
accession_code = fields.KeywordField()
alternate_accession_code = fields.KeywordField()
submitter_institution = fields.TextField()
publication_doi = fields.TextField()
has_publication = fields.BooleanField()
sample_metadata_fields = fields.TextField()
pubmed_id = fields.TextField()
num_total_samples = fields.IntegerField()
num_processed_samples = fields.IntegerField()
num_downloadable_samples = fields.IntegerField()
source_first_published = fields.DateField()
# Index all downloadable samples as keywords so that we can calculate unique counts on the facets
downloadable_samples = fields.ListField(fields.KeywordField())
class Django:
model = Experiment
parallel_indexing = True
queryset_pagination = 3000
fields = [
"id",
]
def get_queryset(self):
""" Override default queryset """
return super(ExperimentDocument, self).get_queryset().order_by("id")
class SourceDocument(Document):
class Index:
name = 'sources'
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
locale = fields.ListField(fields.KeywordField())
last_update = fields.DateField(attr='updated_at')
owner = fields.KeywordField(attr='parent_resource', normalizer='lowercase')
owner_type = fields.KeywordField(attr='parent_resource_type')
public_can_view = fields.TextField(attr='public_can_view')
source_type = fields.KeywordField(attr='source_type',
normalizer='lowercase')
is_active = fields.KeywordField(attr='is_active')
version = fields.KeywordField(attr='version')
name = fields.KeywordField(attr='name', normalizer='lowercase')
canonical_url = fields.KeywordField(attr='canonical_url',
normalizer='lowercase')
mnemonic = fields.KeywordField(attr='mnemonic', normalizer='lowercase')
extras = fields.ObjectField()
class Django:
model = Source
fields = [
'full_name',
'custom_validation_schema',
]
@staticmethod
def prepare_locale(instance):
return get(instance.supported_locales, [])
@staticmethod
def prepare_extras(instance):
return instance.extras or {}
class Party(InnerDoc):
name = fields.TextField(attr="party.name", copy_to="wildcard", analyzer=descriptive_text_analyzer)
address = fields.TextField(attr="party.address", copy_to="wildcard", analyzer=address_analyzer,)
type = fields.KeywordField(
attr="party.type",
fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),},
)
country = fields.KeywordField(
fields={"raw": fields.KeywordField(normalizer=lowercase_normalizer), "suggest": fields.CompletionField(),},
attr="party.country.name",
)
class ArticleDoc(DocType):
id = fields.IntegerField()
slug = fields.KeywordField()
title = fields.TextField(analyzer=polish_analyzer,
fields={
'raw': fields.KeywordField(),
'suggest': fields.CompletionField()
})
notes = fields.TextField(analyzer=polish_analyzer,
fields={
'raw': fields.TextField(),
})
author = fields.TextField(
analyzer=standard_analyzer,
fields={
'raw': fields.KeywordField(),
# TODO: fix author data before this
# 'suggest': fields.CompletionField()
})
datasets = datasets_field(attr='published_datasets')
license = fields.NestedField(
properties={
'id': fields.IntegerField(),
'name': fields.TextField(),
'title': fields.TextField(),
'url': fields.TextField()
})
tags = fields.KeywordField(attr='tags_list', multi=True)
views_count = fields.IntegerField()
users_following = fields.KeywordField(attr='users_following_list',
multi=True)
status = fields.TextField()
modified = fields.DateField()
created = fields.DateField()
class Meta:
doc_type = 'article'
model = Article
related_models = [Tag, Dataset, UserFollowingArticle]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, UserFollowingArticle):
return related_instance.follower.followed_applications.all()
if isinstance(related_instance, Dataset):
return related_instance.articles.all()
if isinstance(related_instance, Tag):
return related_instance.articles.all()
def get_queryset(self):
return self._doc_type.model.objects.filter(
status__in=['published', 'draft'])
class ArticleDocument(DocType):
title = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
url = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
description = fields.TextField(
fields={'raw': fields.KeywordField()},
analyzer=analyzer,
)
start_publication = fields.DateField()
author = fields.ListField(fields.IntegerField())
category = fields.ListField(fields.IntegerField())
content = fields.TextField(
analyzer=analyzer
)
special_signals = True
class Meta:
model = Article
queryset_chunk_size = 100
def get_queryset(self):
return Article.published.all()
def prepare_content(self, obj):
html = obj.get_html_content()
return strip_tags(html)
def prepare_description(self, obj):
return strip_tags(obj.description)
def prepare_url(self, obj):
return obj.get_absolute_url()
def prepare_title(self, obj):
return obj.title
def prepare_start_publication(self, obj):
return obj.start_publication
def prepare_category(self, obj):
cats = obj.categories.all()
return [o.id for o in cats]
def prepare_author(self, obj):
authors = obj.authors.all()
return [o.id for o in authors]
class Rating(InnerDoc):
rating = fields.KeywordField(
fields={
"raw": fields.KeywordField(normalizer=lowercase_normalizer),
"suggest": fields.CompletionField(),
},
copy_to="wildcard",
)
text = fields.TextField(
copy_to="wildcard",
analyzer=descriptive_text_analyzer,
)
