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"]