class CarDocument(DocType):
manufacturer = fields.ObjectField(
properties={
'name': fields.StringField(),
'country': fields.StringField(),
'logo': fields.FileField(),
})
ads = fields.NestedField(
properties={
'description': fields.StringField(analyzer=html_strip),
'title': fields.StringField(),
'pk': fields.IntegerField(),
})
categories = fields.NestedField(properties={
'title': fields.StringField(),
})
class Meta:
model = Car
related_models = [Manufacturer, Category]
fields = [
'name',
'launched',
'type',
]
def get_queryset(self):
return super(CarDocument,
self).get_queryset().select_related('manufacturer')
def get_instances_from_related(self, related_instance):
return related_instance.car_set.all()
class MotionDocument(DocType):
convention = fields.ObjectField(
properties={
'label': fields.KeywordField(),
'slot': fields.KeywordField(),
'year': fields.DateField(),
})
section = fields.ObjectField(properties={
'name': fields.KeywordField(),
})
identifier = fields.KeywordField()
submitters = fields.NestedField(properties={'name': fields.KeywordField()})
referrals = fields.NestedField(properties={'name': fields.KeywordField()})
status = fields.KeywordField()
created = fields.DateField()
class Meta:
model = Motion
fields = [
'title',
'body',
]
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 CarDocument(DocType):
# test can override __init__
def __init__(self, *args, **kwargs):
super(CarDocument, self).__init__(*args, **kwargs)
manufacturer = fields.ObjectField(properties={
'name': fields.StringField(),
'country': fields.StringField(),
})
ads = fields.NestedField(
properties={
'description': fields.StringField(analyzer=html_strip),
'title': fields.StringField(),
'pk': fields.IntegerField(),
})
categories = fields.NestedField(
properties={
'title': fields.StringField(),
'slug': fields.StringField(),
'icon': fields.FileField(),
})
class Meta:
model = Car
fields = [
'name',
'launched',
'type',
]
def get_queryset(self):
return super(CarDocument,
self).get_queryset().select_related('manufacturer')
class BillDocument(DocType):
sponsors = fields.NestedField()
action_dates = fields.ObjectField()
companions = fields.NestedField()
votes = fields.ObjectField()
sources = fields.ObjectField()
documents = fields.ObjectField()
bill_versions = fields.NestedField()
bill_text = fields.TextField()
bill_text_analysis = fields.ObjectField()
class Meta:
model = Bill
fields = [
'created',
'modified',
'state',
'state_id',
'remote_id',
'session',
'chamber',
'title',
'summary',
'type',
'content',
'bill_raw_text',
]
class ProfilDocument(Document):
name = fields.TextField(fielddata=True,
attr='lastname',
fields={
'suggest': fields.Completion(),
})
works = fields.NestedField(properties={
"job": fields.TextField(),
"title": fields.TextField()
})
promo = fields.TextField(attr="promo")
links = fields.NestedField(properties={
"url": fields.TextField(),
"text": fields.TextField()
})
public_url = fields.TextField(attr="public_url")
class Index:
name = 'profils'
settings = {"number_of_shards": 1, "number_of_replicas": 0}
class Django(object):
model = Profil
fields = [
"id", "firstname", "lastname", "acceptSponsor", "email",
"department", "cp", "cursus", "mobile", "photo", "address", "town",
"degree_year", "dtLastUpdate"
]
def get_queryset(self):
return super().get_queryset().select_related('extrauser')
class BasketballRatingsDocument(Document):
ratedBy = fields.NestedField(properties={
'pk': fields.TextField(),
'account_type': fields.TextField(),
})
player = fields.NestedField(properties={
'pk': fields.TextField(),
})
class Index:
# Name of the Elasticsearch index
name = 'metrics'
# See Elasticsearch Indices API reference for available settings
settings = {'number_of_shards': 1,
'number_of_replicas': 1}
class Django:
model = BasketballRatings # The model associated with this Document
# The fields of the model you want to be indexed in Elasticsearch
fields = [
"rebounding",
"defence",
"scoring",
"leadership",
"discipline",
"basketballIQ",
"energy",
"determination",
"clutch",
"proPotential",
]
# 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
# 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 = 5000ss
def get_instances_from_related(self, related_instance):
"""If related_models is set, define how to retrieve the Car instance(s) from the related model.
The related_models option should be used with caution because it can lead in the index
to the updating of a lot of items.
"""
if isinstance(related_instance, Profile):
return related_instance.basketballRatings_set.all()
elif isinstance(related_instance, Profile):
return related_instance.basketballRatings
class ErrorLogObjectDocument(Document):
service = fields.TextField()
message = fields.TextField(analyzer=NGRAM)
stacktrace = fields.TextField(analyzer=NGRAM)
loginstances = fields.NestedField(
properties={
'timestamp': fields.TextField(),
'type': fields.TextField(),
'log': fields.TextField(analyzer=NGRAM),
})
userinteractions = fields.NestedField(properties={
'element': fields.TextField(),
'innerText': fields.TextField()
})
count = fields.IntegerField()
def prepare_service(self, instance):
services = Service.objects.filter(ticket=instance.ticket)
if services.exists():
return services[0].name
else:
return f"tkt: {instance.ticket}"
def prepare_count(self, instance):
return instance.count
def prepare_loginstances(self, instance):
instances = LogInstance.objects.filter(log_id=instance.id)
ser = LogInstanceSerializer(instances, many=True)
serdata = ser.data
ddata = dict()
for i in range(len(instances)):
ddata[instances[i].id] = serdata[i]
return ddata
def prepare_userinteractions(self, instance):
instances = UserInteraction.objects.filter(log_id=instance.id)
ser = UserInteractionSerializer(instances, many=True)
serdata = ser.data
ddata = dict()
for i in range(len(instances)):
ddata[instances[i].id] = serdata[i]
return ddata
class Index:
name = "error_logs"
class Django:
model = ErrorLogObject
fields = ('timestamp', )
class JobDocument(Document):
# Object/List fields
analyzers_to_execute = fields.ListField(fields.KeywordField())
connectors_to_execute = fields.ListField(fields.KeywordField())
# Normal fields
errors = fields.TextField()
# Keyword fields to allow aggregations/vizualizations
source = fields.KeywordField()
status = fields.KeywordField()
md5 = fields.KeywordField()
tlp = fields.KeywordField()
observable_name = fields.KeywordField()
observable_classification = fields.KeywordField()
file_name = fields.KeywordField()
file_mimetype = fields.KeywordField()
# Nested (ForeignKey) fields
tags = fields.NestedField(
properties={"label": fields.KeywordField(), "color": fields.TextField()}
)
analyzer_reports = fields.NestedField(
properties={
"name": fields.KeywordField(),
"status": fields.KeywordField(),
"report": fields.ObjectField(),
"errors": fields.TextField(),
"start_time": fields.DateField(),
"end_time": fields.DateField(),
}
)
connector_reports = fields.NestedField(
properties={
"name": fields.KeywordField(),
"status": fields.KeywordField(),
"report": fields.ObjectField(),
"errors": fields.TextField(),
"start_time": fields.DateField(),
"end_time": fields.DateField(),
}
)
class Index:
# Name of the Elasticsearch index
name = "jobs"
class Django:
model = Job # The model associated with this Document
# The fields of the model you want to be indexed in Elasticsearch
fields = [
"is_sample",
"received_request_time",
"finished_analysis_time",
]
class PostDocument(Document):
author = fields.ObjectField(
properties={
'username': fields.TextField(analyzer=html_strip),
})
post_ingredients = fields.NestedField(
properties={
'name': fields.TextField(analyzer=html_strip),
'amount': fields.DoubleField(),
'unit': fields.TextField(),
'pk': fields.IntegerField(),
})
post_steps = fields.NestedField(
properties={
'text':
fields.TextField(analyzer=html_strip,
fields={'raw': fields.KeywordField()}),
'pk':
fields.IntegerField(),
})
post_comments = fields.NestedField(
properties={
'text': fields.TextField(analyzer=html_strip),
'pk': fields.IntegerField(),
})
class Index:
name = 'posts'
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
class Django:
model = Post
fields = ['title', 'created_on', 'cook_time']
related_models = [UserProfile, Ingredient, Step, Comment]
def get_queryset(self):
"""Not mandatory but to improve performance we can select related in one sql request"""
return super(PostDocument,
self).get_queryset().select_related('author')
def get_instances_from_related(self, related_instance):
"""If related_models is set, define how to retrieve the Post instance(s) from the related model.
The related_models option should be used with caution because it can lead in the index
to the updating of a lot of items.
"""
if isinstance(related_instance, UserProfile):
return related_instance.post_author.all()
elif isinstance(related_instance, Ingredient):
return related_instance.post
elif isinstance(related_instance, Step):
return related_instance.post
elif isinstance(related_instance, Comment):
return related_instance.post
class AcceptedDatasetSubmissionDoc(Document):
id = fields.IntegerField()
is_active = fields.BooleanField()
title = TranslatedTextField('title')
notes = TranslatedTextField('notes')
organization_name = TranslatedTextField('organization_name')
potential_possibilities = TranslatedTextField('potential_possibilities')
data_link = fields.TextField()
comment = fields.TextField()
submission_date = fields.DateField()
decision = fields.TextField()
decision_date = fields.DateField()
published_at = fields.DateField()
is_published_for_all = fields.BooleanField()
feedback = fields.NestedField(properties={
'user_id': fields.IntegerField(),
'opinion': fields.StringField()
})
feedback_counters = fields.NestedField(properties={
'plus': fields.IntegerField(),
'minus': fields.IntegerField(),
})
status = fields.TextField()
def prepare_feedback(self, instance):
return [{
'user_id': fb.user.id,
'opinion': fb.opinion
} for fb in instance.feedback.all()]
def prepare_feedback_counters(self, instance):
return instance.feedback_counters
class Index:
name = mcs.ELASTICSEARCH_INDEX_NAMES['accepted_dataset_submissions']
settings = mcs.ELASTICSEARCH_DSL_INDEX_SETTINGS
class Django:
model = AcceptedDatasetSubmission
related_models = [
SubmissionFeedback,
]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, SubmissionFeedback):
return related_instance.submission
def get_queryset(self):
return super().get_queryset().filter(
status__in=AcceptedDatasetSubmission.PUBLISHED_STATUSES)
class StartupDocument(DocType):
user = fields.ObjectField(
properties={
'is_active': fields.BooleanField(),
'is_founder': fields.BooleanField(),
'is_account_disabled': fields.BooleanField(),
'first_name': fields.StringField(),
'last_name': fields.StringField(),
})
job_set = fields.NestedField(
properties={
'title': fields.StringField(),
'description': fields.StringField(),
'level': fields.StringField(attr="get_level_display"),
'pay': fields.StringField(attr="get_pay_display")
})
logo = fields.StringField(attr="logo_to_string")
get_stage_display = fields.StringField(attr="get_stage_display")
get_field_display = fields.StringField(attr="get_field_display")
stage = fields.StringField(attr='stage', analyzer=leave_default)
field = fields.StringField(attr='field', analyzer=leave_default)
class Meta:
model = Founder
fields = ['startup_name', 'description', 'is_filled', 'employee_count']
class TagCollectionDocument(DocType):
tags = fields.NestedField(properties={"value": fields.TextField()})
asset = fields.ObjectField(
properties={
"title":
fields.TextField(),
"slug":
fields.TextField(),
"transcription_status":
fields.TextField(),
"item":
fields.ObjectField(
properties={
"item_id":
fields.TextField(),
"project":
fields.ObjectField(
properties={
"slug":
fields.TextField(),
"campaign":
fields.ObjectField(
properties={"slug": fields.TextField()}),
}),
}),
})
user = fields.ObjectField(properties={"username": fields.TextField()})
class Meta:
model = UserAssetTagCollection
fields = ["created_on", "updated_on"]
class ApplicationDocument(ExtendedDocument):
image_alt = TranslatedTextField('image_alt')
has_image_thumb = fields.BooleanField()
url = fields.KeywordField()
illustrative_graphics_url = fields.KeywordField()
illustrative_graphics_alt = TranslatedTextField(
'illustrative_graphics_alt')
image_url = fields.TextField()
image_thumb_url = fields.KeywordField()
author = fields.KeywordField()
datasets = datasets_field(attr='published_datasets')
external_datasets = fields.NestedField(properties={
'title': fields.KeywordField(),
'url': fields.KeywordField(),
})
main_page_position = fields.IntegerField()
class Index:
name = mcs.ELASTICSEARCH_INDEX_NAMES['applications']
settings = mcs.ELASTICSEARCH_DSL_SEARCH_INDEX_SETTINGS
aliases = mcs.ELASTICSEARCH_DSL_SEARCH_INDEX_ALIAS
class Django:
model = Application
class ForumPostDocument(Document):
forum_comments = fields.NestedField(
properties={
'author':
fields.TextField(
attr="author",
fields={
'raw': fields.TextField(analyzer=html_strip),
'suggest': fields.Completion(analyzer=sugg_analyzer)
}),
'text':
fields.TextField(
attr="text",
fields={
'raw': fields.TextField(analyzer=html_strip),
'suggest': fields.Completion(analyzer=sugg_analyzer)
})
})
class Index:
# Name of the Elasticsearch index
name = 'forum_posts_index'
# See Elasticsearch Indices API reference for available settings
settings = {'number_of_shards': 1, 'number_of_replicas': 0}
class Django:
"""
I no longer have an autocomplete defined as the amount of requests goes
through the roof.
"""
# text = fields.TextField(
# attr='text',
# fields={
# 'raw': fields.TextField(analyzer=html_strip),
# 'suggest': fields.Completion(analyzer=sugg_analyzer),
# }
# )
# title = fields.TextField(
# attr='title',
# fields={
# 'raw': fields.TextField(analyzer=html_strip),
# 'suggest': fields.Completion(analyzer=sugg_analyzer),
# }
# )
# author = fields.TextField(
# attr='title',
# fields={
# 'raw': fields.TextField(analyzer=html_strip),
# 'suggest': fields.Completion(analyzer=sugg_analyzer),
# })
model = ForumPost
fields = [
'title',
'text',
'category',
'author',
]
class FinalProductDocument(Document):
employee = fields.ObjectField(properties={"name": fields.TextField(), "work_hours": fields.TextField()})
raw_materials = fields.NestedField(
properties={"name": fields.TextField(), "quantity_in_stock": fields.IntegerField()}
)
class Index:
name = "final_products"
settings = {"number_of_shards": 1, "number_of_replicas": 0}
class Django:
model = FinalProduct
fields = ["name"]
related_models = [Employee, RawMaterial]
def get_queryset(self):
return super().get_queryset().select_related("employee")
def get_instances_from_related(self, related_instance):
"""If related_models is set, define how to retrieve the Car instance(s) from the related model.
The related_models option should be used with caution because it can lead in the index
to the updating of a lot of items.
"""
if isinstance(related_instance, Employee):
return related_instance.finalproduct_set.all()
elif isinstance(related_instance, RawMaterial):
return related_instance.finalproduct_set.all()
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')
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 ProjectDocument(DocType):
# Metadata
url = fields.TextField(attr='get_absolute_url')
users = fields.NestedField(
properties={
'username': fields.TextField(),
'id': fields.IntegerField(),
}
)
language = fields.KeywordField()
modified_model_field = 'modified_date'
class Meta:
model = Project
fields = ('name', 'slug', 'description')
ignore_signals = True
@classmethod
def faceted_search(cls, query, user, language=None):
from readthedocs.search.faceted_search import ProjectSearch
kwargs = {
'user': user,
'query': query,
}
if language:
kwargs['filters'] = {'language': language}
return ProjectSearch(**kwargs)
def article_category_field(**kwargs):
return fields.NestedField(properties={
'id': fields.IntegerField(),
'name': TranslatedKeywordField('name'),
'description': TranslatedTextField('description')
},
**kwargs)
class MemberDocument(Document):
"""Member Elasticsearch document."""
id = fields.IntegerField(attr='id')
full_name = StringField(analyzer=html_strip,
fields={
'raw': KeywordField(),
'suggest': fields.CompletionField(),
})
birthday = fields.DateField()
roles = fields.NestedField(
properties={
'title':
fields.TextField(analyzer=html_strip,
attr='role',
fields={
'raw': KeywordField(),
}),
})
member_url = fields.TextField(attr='get_absolute_url')
image = fields.FileField(attr="image")
class Django(object):
"""Inner nested class Django."""
model = Members # The model associate with this Document
class VideoDocument(Document):
videokeywordnews = fields.NestedField(
properties={
'idx': fields.IntegerField(),
'keyword': fields.TextField(analyzer=nori_analyzer),
})
class Index:
name = 'videos'
class Django:
model = Video
fields = [
'idx',
'video_name',
'video_description',
'video_id',
'upload_time',
'thumbnail_url',
'popularity',
'views',
'views_growth',
'crawled',
]
related_models = [VideoKeywordNew]
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, VideoKeywordNew):
return related_instance.video
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 ProjectDocument(RTDDocTypeMixin, DocType):
class Meta(object):
model = Project
fields = ('name', 'slug', 'description')
auto_refresh = False
url = fields.TextField(attr='get_absolute_url')
users = fields.NestedField(properties={
'username': fields.TextField(),
'id': fields.IntegerField(),
})
language = fields.KeywordField()
@classmethod
def faceted_search(cls, query, language=None, using=None, index=None):
kwargs = {
'using': using or cls._doc_type.using,
'index': index or cls._doc_type.index,
'doc_types': [cls],
'model': cls._doc_type.model,
'query': query
}
if language:
kwargs['filters'] = {'language': language}
return ProjectSearch(**kwargs)
class StartupDocument(DocType):
user = fields.ObjectField(
properties={
'is_active': fields.BooleanField(),
'is_founder': fields.BooleanField(),
'is_account_disabled': fields.BooleanField(),
'first_name': fields.StringField(),
'last_name': fields.StringField(),
'last_activity': fields.DateField(attr='last_activity.date')
})
job_set = fields.NestedField(
properties={
'title': fields.StringField(),
'description': fields.StringField(),
'level': fields.StringField(attr='get_level_display'),
'pay': fields.StringField(attr='get_pay_display')
})
logo = fields.StringField(attr='logo_url')
# logo_thumbnail = fields.StringField(attr='logo_thumbnail_url')
get_stage_display = fields.StringField(attr='get_stage_display')
get_field_display = fields.StringField(attr='get_field_display')
stage = fields.StringField(attr='stage', analyzer=leave_default)
field = fields.StringField(attr='field', analyzer=leave_default)
class Meta:
model = Founder
related_models = [MyUser, Job]
fields = ['startup_name', 'description', 'is_filled', 'employee_count']
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, MyUser):
if hasattr(related_instance, 'founder'):
return related_instance.founder
if isinstance(related_instance, Job):
return related_instance.founder
class CarDocument(Document):
# test can override __init__
def __init__(self, *args, **kwargs):
super(CarDocument, self).__init__(*args, **kwargs)
manufacturer = fields.ObjectField(properties={
'name': fields.StringField(),
'country': fields.StringField(),
})
ads = fields.NestedField(
properties={
'description': fields.StringField(analyzer=html_strip),
'title': fields.StringField(),
'pk': fields.IntegerField(),
})
categories = fields.NestedField(
properties={
'title': fields.StringField(),
'slug': fields.StringField(),
'icon': fields.FileField(),
})
class Django:
model = Car
related_models = [Ad, Manufacturer, Category]
fields = [
'name',
'launched',
'type',
]
class Index:
name = 'test_cars'
settings = index_settings
def get_queryset(self):
return super(CarDocument,
self).get_queryset().select_related('manufacturer')
def get_instances_from_related(self, related_instance):
if isinstance(related_instance, Ad):
return related_instance.car
# otherwise it's a Manufacturer or a Category
return related_instance.car_set.all()
class RepositoryQANLPLogDocument(TimeBasedDocument):
time_based = True
user = fields.IntegerField(attr="user.id")
knowledge_base = fields.IntegerField(attr="knowledge_base.id")
nlp_log = fields.NestedField(
properties={
"answers": fields.NestedField(
properties={
"text": fields.TextField(fields={"raw": fields.KeywordField()}),
"confidence": fields.FloatField(),
}
),
"id": fields.IntegerField(),
}
)
text = fields.IntegerField()
repository_uuid = fields.TextField(
fields={"raw": fields.KeywordField()},
)
pk = fields.IntegerField()
class Django:
model = QALogs
fields = [
"id",
"answer",
"language",
"confidence",
"question",
"from_backend",
"user_agent",
"created_at",
]
def prepare_text(self, obj):
try:
return obj.knowledge_base.texts.filter(language=obj.language).first().id
except AttributeError:
return None
def prepare_nlp_log(self, obj):
return json.loads(obj.nlp_log)
def prepare_repository_uuid(self, obj):
return obj.knowledge_base.repository.uuid
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={"username": fields.KeywordField()})
reviewed_by = fields.ObjectField(
properties={"username": fields.KeywordField()})
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 PowDocument(Document):
works = fields.NestedField(properties={
"job": fields.TextField(),
"lastname": fields.TextField(),
})
links = fields.NestedField(properties={
"url": fields.TextField(),
"text": fields.TextField()
})
class Index:
name = 'pows'
settings = {"number_of_shards": 1, "number_of_replicas": 0}
class Django(object):
model = PieceOfWork
fields = ["id", "year", "visual", "title", "nature", "category"]
