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 SurveyDocument(DocType):
categories = fields.NestedField(
properties={
'name': fields.TextField(),
'order': fields.IntegerField(),
'description': fields.TextField(),
})
questions = fields.NestedField(
properties={
'text': fields.TextField(),
'order': fields.IntegerField(),
'required': fields.BooleanField(),
'type': fields.TextField(),
'choices': fields.TextField(),
})
responses = fields.NestedField(properties={
'interview_uuid': fields.TextField(),
})
class Meta:
model = Survey
fields = ['name', 'description', 'is_published', 'need_logged_user']
related_models = [Category, Question, Response]
def get_instances_from_related(self, related_instance):
return self
class RaceResult(Document):
# runner info
runner_age = fields.IntegerField(attr="runner_age_during_race")
best_ten_run_in_hours = fields.DoubleField()
runner_sex = fields.StringField(attr="runner.sex")
# race info
itra_point = fields.IntegerField(attr="prediction_race.itra")
refreshment_points = fields.IntegerField(
attr="prediction_race.refreshment_points")
max_time = fields.IntegerField(attr="prediction_race.max_time")
month_of_the_race = fields.StringField(
attr="prediction_race.month_of_the_race")
distance = fields.StringField(attr="prediction_race.distance")
ascent = fields.StringField(attr="prediction_race.ascent")
descent = fields.StringField(attr="prediction_race.descent")
# result info
time_result_in_hours = fields.DoubleField(attr="time_result_in_hours")
position = fields.IntegerField(attr="position")
def prepare_best_ten_run_in_hours(self, instance):
if instance.best_10km_run_before_prediction_race:
hours = Decimal(
instance.best_10km_run_before_prediction_race.seconds / 3600)
return round(hours, 2)
else:
return None
class Index:
name = "race_results"
settings = {"number_of_shards": 1, "number_of_replicas": 0}
class Django:
model = models.PredictionRaceResult
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 PersonDocument(BaseDocument):
profile_image = es_fields.TextField(attr='profile_image_indexing')
user_reputation = es_fields.IntegerField(attr='user_reputation_indexing')
author_score = es_fields.IntegerField(attr='author_score')
description = es_fields.TextField(attr='description',
analyzer=content_analyzer)
full_name = es_fields.TextField(attr='full_name',
analyzer=content_analyzer)
person_types = es_fields.KeywordField(attr='person_types_indexing')
headline = es_fields.ObjectField(attr='headline',
properties={
'title': es_fields.TextField(),
})
class Index:
name = 'person'
class Django:
model = Author
fields = [
'id',
'first_name',
'last_name',
]
def should_remove_from_index(self, obj):
should_delete = False
try:
author_user = User.objects.get(id=obj.user_id)
if author_user.is_suspended:
should_delete = True
except Exception as e:
pass
return should_delete
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 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 ReferenceDocument(DocType):
pk = fields.IntegerField(attr='pk')
sid = fields.IntegerField(attr='sid')
pmid = string_field(attr='pmid')
study = ObjectField(properties={
"pk": fields.IntegerField(),
"name": string_field('name'),
})
name = string_field("name")
doi = string_field("doi")
title = string_field("title")
abstract = text_field("abstract")
journal = text_field("journal")
date = fields.DateField()
pdf = fields.FileField(fielddata=True)
authors = ObjectField(properties={
'first_name': string_field("first_name"),
'last_name': string_field("last_name"),
'pk': fields.IntegerField(),
})
class Meta(object):
model = Reference
# Ignore auto updating of Elasticsearch when a model is saved
# or deleted:
ignore_signals = True
# Don't perform an index refresh after every update (overrides global setting):
auto_refresh = False
class ApplicationsDoc(DocType):
id = fields.IntegerField()
slug = TranslatedKeywordField('slug')
title = TranslatedTextField(
'title', common_params={'suggest': fields.CompletionField()})
notes = TranslatedTextField('notes')
author = fields.KeywordField()
url = fields.KeywordField()
image_url = fields.KeywordField(attr='image_url')
image_thumb_url = fields.KeywordField(attr='image_thumb_url')
datasets = datasets_field(attr='published_datasets')
users_following = fields.KeywordField(attr='users_following_list',
multi=True)
tags = TranslatedKeywordsList(attr='tags_list')
views_count = fields.IntegerField()
status = fields.KeywordField()
modified = fields.DateField()
created = fields.DateField()
class Meta:
doc_type = 'application'
model = Application
def get_queryset(self):
return self._doc_type.model.objects.filter(status='published')
class ProductDocument(DocType):
id = fields.IntegerField(attr='id')
title = fields.StringField(
analyzer=html_strip,
fields={
'raw': fields.StringField(analyzer='keyword'),
}
)
store = fields.IntegerField(
attr='store_indexing',
# analyzer=html_strip,
)
# store = NestedField(properties={
# 'id': IntegerField(),
# 'title': StringField(),
# })
class Meta:
model = Product
related_models = [Store]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, Store):
return related_instance.product_set.all()
class CompanyDocument(DocType):
# ID
id = fields.IntegerField(attr='id')
avatar = fields.TextField()
slug = fields.StringField()
name = StringField(analyzer=html_strip, fields={
'raw': KeywordField(),
})
about = fields.TextField()
headquarter = fields.TextField()
is_address_public = fields.BooleanField()
website = fields.StringField()
since = fields.StringField()
size_from = fields.IntegerField()
size_to = fields.IntegerField()
creator = fields.ObjectField(attr='create_field_indexing',
properties={'id': fields.IntegerField()})
tags = fields.ObjectField(attr='tag_field_indexing',
properties={
'id': fields.IntegerField(),
'name': fields.StringField()
})
class Django:
model = Company
class IndividualDocument(Document):
"""Individual elastic search document"""
pk = fields.IntegerField(attr='pk')
name = string_field('name')
group = ObjectField(
properties={
'name': string_field('name'),
'pk': fields.IntegerField('pk'),
'count': fields.IntegerField('count')
})
study = string_field('study_name')
ex = ObjectField(properties={'pk': fields.IntegerField('pk')})
characteristica_all_normed = characteristica_object_field
access = string_field('access')
allowed_users = fields.ObjectField(
attr="allowed_users",
properties={'username': string_field("username")},
multi=True)
class Django:
model = Individual
# Ignore auto updating of Elasticsearch when a model is saved/deleted
ignore_signals = True
# Don't perform an index refresh after every update
auto_refresh = False
class Index:
name = 'individuals'
settings = elastic_settings
class CompetitionDocument(DocType):
class Meta:
model = Competition
remote_id = fields.IntegerField()
created_by = fields.TextField()
title = fields.TextField()
description = fields.TextField()
html_text = fields.TextField()
participant_count = fields.IntegerField()
is_active = fields.BooleanField()
prize = fields.IntegerField()
current_phase_deadline = fields.DateField()
url = fields.TextField()
logo = fields.TextField()
start = fields.DateField()
end = fields.DateField()
producer = fields.ObjectField(properties={
'id': fields.IntegerField(),
'url': fields.TextField(),
'name': fields.TextField()
})
# TODO: add "active" boolean field so we can add this to queries and not have a special case
def prepare_created_by(self, instance):
return instance.created_by
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 HubDocument(BaseDocument):
auto_refresh = True
paper_count = es_fields.IntegerField(attr='paper_count')
subscriber_count = es_fields.IntegerField(attr='subscriber_count')
discussion_count = es_fields.IntegerField(attr='discussion_count')
description = es_fields.TextField(attr='description',
analyzer=content_analyzer)
name = es_fields.TextField(attr='name', analyzer=title_analyzer)
class Index:
name = 'hub'
class Django:
model = Hub
fields = [
'id',
'acronym',
'is_locked',
]
def should_remove_from_index(self, obj):
if obj.is_removed or obj.is_locked:
return True
return False
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",
)
)
def files_field(**kwargs):
return fields.NestedField(properties={
'download_url': fields.TextField(),
'file_size': fields.IntegerField(),
'openness_score': fields.IntegerField(),
'format': fields.TextField()
},
**kwargs)
class GroupDocument(Document):
city = fields.ObjectField(properties={"id": fields.IntegerField()})
club = fields.ObjectField(properties={"id": fields.IntegerField()})
sports = fields.NestedField(properties={"id": fields.IntegerField()})
class Django:
model = Group
fields = ["id", "name", "description", "cover_photo", "contact_email"]
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 ApplicationsDoc(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.KeywordField(),
}
)
author = fields.TextField(
analyzer=standard_analyzer,
fields={
'raw': fields.KeywordField(),
# TODO: fix author data before this
# 'suggest': fields.CompletionField()
}
)
url = fields.KeywordField()
image_url = fields.KeywordField(
attr='image_url'
)
datasets = datasets_field(attr='published_datasets')
users_following = fields.KeywordField(attr='users_following_list', multi=True)
tags = fields.KeywordField(attr='tags_list', multi=True)
views_count = fields.IntegerField()
status = fields.KeywordField()
modified = fields.DateField()
created = fields.DateField()
class Meta:
doc_type = 'application'
model = Application
related_models = [Tag, Dataset, UserFollowingApplication]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, UserFollowingApplication):
return related_instance.follower.followed_applications.all()
if isinstance(related_instance, Dataset):
return related_instance.applications.all()
if isinstance(related_instance, Tag):
return related_instance.applications.all()
def get_queryset(self):
return self._doc_type.model.objects.filter(status='published')
class ThreadDocument(Document):
comment_count = es_fields.IntegerField(attr='comment_count_indexing')
# TODO: Make this a nested user field with author inside
created_by_author_profile = es_fields.ObjectField(
attr='created_by_author_profile_indexing',
properties={
'id': es_fields.IntegerField(),
'first_name': es_fields.TextField(),
'last_name': es_fields.TextField(),
}
)
paper = es_fields.IntegerField(attr='paper_indexing')
paper_title = es_fields.TextField(
attr='paper_title_indexing',
analyzer=title_analyzer
)
score = es_fields.IntegerField(attr='score_indexing')
plain_text = es_fields.TextField()
title = es_fields.TextField(analyzer=title_analyzer)
class Index:
name = 'discussion_thread'
class Django:
model = Thread
fields = [
'id',
'created_date',
'updated_date',
'is_public',
'is_removed',
]
# Ignore auto updating of Elasticsearch when a model is saved
# or deleted (defaults to False):
ignore_signals = (TESTING is True) or (
ELASTICSEARCH_AUTO_REINDEX is False
)
# Don't perform an index refresh after every update (False overrides
# global setting of True):
auto_refresh = (TESTING is False) or (
ELASTICSEARCH_AUTO_REINDEX is True
)
# Paginate the django queryset used to populate the index with the
# specified size (by default it uses the database driver's default
# setting)
# queryset_pagination = 5000
def update(self, *args, **kwargs):
try:
super().update(*args, **kwargs)
except ConnectionError as e:
sentry.log_info(e)
except Exception as e:
sentry.log_info(e)
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 BookDocument(Document):
"""Book Elasticsearch document."""
id = fields.IntegerField(attr='id')
title = fields.TextField(fields={
'raw': fields.KeywordField(),
})
description = fields.TextField(fields={
'raw': fields.KeywordField(),
})
summary = fields.TextField(fields={
'raw': fields.KeywordField(),
})
publisher = fields.KeywordField(
attr='publisher_indexing',
#analyzer=html_strip,
# fields={
# 'raw': fields.KeywordField(analyzer='keyword'),
# }
)
publication_date = fields.DateField()
state = fields.TextField(fields={
'raw': fields.KeywordField(),
})
isbn = fields.KeywordField(
#analyzer=html_strip,
# fields={
# 'raw': fields.KeywordField(analyzer='keyword'),
# }
)
price = fields.FloatField()
pages = fields.IntegerField()
stock_count = fields.IntegerField()
tags = fields.KeywordField(
attr='tags_indexing',
#analyzer=html_strip,
# fields={
# 'raw': fields.KeywordField(analyzer='keyword', multi=True),
# 'suggest': fields.CompletionField(multi=True),
# },
multi=True)
class Django(object):
"""Inner nested class Django."""
model = Book # The model associate with this Document
class OutputInterventionDocument(Document):
study_sid = string_field('study_sid')
study_name = string_field('study_name')
output_pk = fields.IntegerField('output_pk')
intervention_pk = fields.IntegerField('intervention_pk')
group_pk = fields.IntegerField('group_pk')
individual_pk = fields.IntegerField('individual_pk')
measurement_type = string_field("measurement_type")
substance = string_field("substance")
normed = fields.BooleanField()
calculated = fields.BooleanField()
tissue = string_field('tissue')
time = fields.FloatField('time')
time_unit = string_field('time_unit')
unit = string_field('unit')
choice = string_field('choice')
# output fields
value = fields.FloatField('value')
mean = fields.FloatField('mean')
median = fields.FloatField('median')
min = fields.FloatField('min')
max = fields.FloatField('max')
se = fields.FloatField('se')
sd = fields.FloatField('sd')
cv = fields.FloatField('cv')
# for permissions
access = string_field('access')
allowed_users = fields.ObjectField(
attr="allowed_users",
properties={'username': string_field("username")},
multi=True)
class Django:
model = OutputIntervention
# Ignore auto updating of Elasticsearch when a model is saved/deleted
ignore_signals = True
# Don't perform an index refresh after every update
auto_refresh = False
class Index:
name = 'outputs_interventions'
settings = {
'number_of_shards': 5,
'number_of_replicas': 1,
'max_result_window': 100000
}
def get_queryset(self):
"""Not mandatory but to improve performance we can select related in one sql request"""
return super(OutputInterventionDocument,
self).get_queryset().select_related(
'intervention', 'output')
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 CharacteristicaDocument(DocType):
"""Characteristica elastic search document"""
id = fields.IntegerField(attr='id')
group_name = fields.StringField(attr='group_name',
fields={
'raw':
fields.StringField(analyzer='keyword'),
})
group_pk = fields.IntegerField(attr='group_id')
individual_name = fields.StringField(
attr='individual_name',
fields={
'raw': fields.StringField(analyzer='keyword'),
})
individual_pk = fields.IntegerField(attr='individual_id')
category = fields.StringField(attr='category_key',
fields={
'raw':
fields.StringField(analyzer='keyword'),
})
choice = fields.StringField(fields={
'raw': fields.StringField(analyzer='keyword'),
})
unit = fields.StringField(fields={
'raw': fields.StringField(analyzer='keyword'),
})
count = fields.IntegerField()
value = fields.FloatField(attr='value')
mean = fields.FloatField(attr='mean')
median = fields.FloatField(attr='median')
min = fields.FloatField(attr='min')
max = fields.FloatField(attr='max')
se = fields.FloatField(attr='se')
sd = fields.FloatField(attr='sd')
cv = fields.FloatField(attr='cv')
normed = fields.BooleanField()
raw = ObjectField(properties={'pk': fields.IntegerField()})
class Meta:
model = Characteristica
# Ignore auto updating of Elasticsearch when a model is saved
# or deleted:
ignore_signals = True
# Don't perform an index refresh after every update (overrides global setting):
auto_refresh = False
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 MovieDocument(Document):
"""Movie Elasticsearch document."""
id = fields.IntegerField(attr="id")
title = fields.TextField(
fields={
"raw": fields.TextField(analyzer="keyword"),
"suggest": fields.CompletionField(),
}
)
description = fields.TextField(
fields={
"raw": fields.TextField(analyzer="keyword"),
}
)
director = fields.TextField(
fields={
"raw": fields.TextField(analyzer="keyword"),
}
)
year = fields.IntegerField()
poster = fields.TextField()
imdb_rating = fields.FloatField()
rating_average = fields.FloatField()
rating_count = fields.IntegerField()
view_count = fields.IntegerField()
slug = fields.TextField(
fields={
"raw": fields.TextField(analyzer="keyword"),
}
)
genres = fields.TextField(
attr="genres_indexing",
fields={
"raw": fields.TextField(analyzer="keyword", multi=True),
},
multi=True,
)
class Index:
# Name of the Elasticsearch index
name = "movie"
# See Elasticsearch Indices API reference for available settings
settings = {"number_of_shards": 1, "number_of_replicas": 0}
class Django:
Movie = get_movie_model()
model = Movie
class Meta:
Movie = get_movie_model()
model = Movie
class MessageDocument(Document):
id = fields.IntegerField()
broadcast = fields.IntegerField(attr='broadcast_id')
author = fields.IntegerField(attr='author_id')
deleter = fields.IntegerField(attr='deleter_id')
class Index:
name = 'message'
class Django:
model = Message
fields = 'text', 'created', 'updated'
