def __init__(self): """Initialises the object.""" self.signal_receivers_to_add = [] self.signal_receivers_to_disable = [] self.deletions = defaultdict(list) for search_app in get_search_apps(): model = search_app.queryset.model # set up the receivers to add when collecting the deleted objects self.signal_receivers_to_add.append( SignalReceiver(post_delete, model, self._collect), ) # get the existing post/pre_delete receivers that need to be # disabled in the meantime for receiver in search_app.get_signal_receivers(): if receiver.signal in (post_delete, pre_delete): self.signal_receivers_to_disable.append(receiver)
def __init__(self, es_client, apps_to_collect): """ Initialises the collector. :param apps_to_collect: the search apps to monitor the `post_save` signal for (and sync saved objects for when `flush_and_refresh()` is called) """ self.collected_apps = set() self.es_client = es_client self.signal_receivers_to_connect = [ SignalReceiver(post_save, search_app.queryset.model, self._collect) for search_app in set(apps_to_collect) ] # Disconnect all existing search post_save signal receivers (in case they were connected) self.signal_receivers_to_disable = [ receiver for search_app in get_search_apps() for receiver in search_app.get_signal_receivers() if receiver.signal is post_save ]
from django.db import transaction from django.db.models.signals import post_save from datahub.company.models import CompanyExportCountryHistory as DBCompanyExportCountryHistory from datahub.search.export_country_history import ExportCountryHistoryApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async def export_country_history_sync_search(instance): """Sync export country history to the OpenSearch.""" transaction.on_commit( lambda: sync_object_async(ExportCountryHistoryApp, instance.pk), ) receivers = (SignalReceiver(post_save, DBCompanyExportCountryHistory, export_country_history_sync_search), )
**kwargs): """ Sync opensearch when m2m fields change on the investment project. """ if action not in ('post_add', 'post_remove', 'post_clear'): return pks = pk_set if reverse else (instance.pk, ) for pk in pks: sync_object_async(InvestmentSearchApp, pk) investment_project_m2m_receivers = (SignalReceiver( m2m_changed, getattr(DBInvestmentProject, m2m_relation).through, investment_project_sync_m2m_opensearch, forward_kwargs=True, ) for m2m_relation in [ 'business_activities', 'competitor_countries', 'uk_region_locations', 'actual_uk_regions', 'delivery_partners', 'strategic_drivers', ]) receivers = ( SignalReceiver(post_save, DBInvestmentProject, investment_project_sync_search), *investment_project_m2m_receivers, SignalReceiver(post_save, Interaction,
def investor_profile_sync_es(instance): """Sync investor profile to Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(LargeInvestorProfileSearchApp, instance.pk), ) def related_investor_profiles_sync_es(instance): """Sync related Company investor profiles to Elasticsearch.""" transaction.on_commit( lambda: sync_related_objects_async( instance, 'investor_profiles', ), ) def remove_investor_profile_from_es(instance): """Remove investor profile from es.""" transaction.on_commit( lambda pk=instance.pk: delete_document(ESLargeInvestorProfile, pk), ) receivers = ( SignalReceiver(post_save, DBLargeCapitalInvestorProfile, investor_profile_sync_es), SignalReceiver(post_save, DBCompany, related_investor_profiles_sync_es), SignalReceiver(post_delete, DBLargeCapitalInvestorProfile, remove_investor_profile_from_es), )
This is primarily to update the teams stored against the project in ES. """ def sync_es_wrapper(): queryset = DBInvestmentProject.objects.filter( Q(created_by_id=instance.pk) | Q(client_relationship_manager_id=instance.pk) | Q(project_manager_id=instance.pk) | Q(project_assurance_adviser_id=instance.pk) | Q(team_members__adviser_id=instance.pk), ) for project in queryset: sync_object_async( ESInvestmentProject, DBInvestmentProject, str(project.pk), ) transaction.on_commit(sync_es_wrapper) receivers = ( SignalReceiver(post_save, DBInvestmentProject, investment_project_sync_es), SignalReceiver(post_save, InvestmentProjectTeamMember, investment_project_sync_es), SignalReceiver(post_delete, InvestmentProjectTeamMember, investment_project_sync_es), SignalReceiver(post_save, Advisor, investment_project_sync_es_adviser_change), )
from django.db.models.signals import post_delete, pre_delete from datahub.search.signals import SignalReceiver from datahub.search.test.search_support.models import SimpleModel as DBSimpleModel def dummy_on_delete_callback(sender, instance, **kwargs): """ Function called on_delete and deliberately empty. It can be used to check if/when it's called. """ receivers = ( SignalReceiver(post_delete, DBSimpleModel, dummy_on_delete_callback), SignalReceiver(pre_delete, DBSimpleModel, dummy_on_delete_callback), )
from django.db import transaction from django.db.models.signals import post_save from datahub.event.models import Event as DBEvent from datahub.search.event.models import Event as ESEvent from datahub.search.signals import SignalReceiver from datahub.search.sync_async import sync_object_async def sync_event_to_es(sender, instance, **kwargs): """Sync event to the Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(ESEvent, DBEvent, str(instance.pk)), ) receivers = (SignalReceiver(post_save, DBEvent, sync_event_to_es),)
from datahub.omis.order.models import ( Order as DBOrder, OrderAssignee as DBOrderAssignee, OrderSubscriber as DBOrderSubscriber, ) from datahub.search.omis import OrderSearchApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async def order_sync_es(instance): """Sync an order to the Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(OrderSearchApp, instance.pk), ) def related_order_sync_es(instance): """Sync an order linked from the instance to the Elasticsearch.""" order_sync_es(instance.order) receivers = ( SignalReceiver(post_save, DBOrder, order_sync_es), SignalReceiver(post_save, DBOrderSubscriber, related_order_sync_es), SignalReceiver(post_delete, DBOrderSubscriber, related_order_sync_es), SignalReceiver(post_save, DBOrderAssignee, related_order_sync_es), SignalReceiver(post_delete, DBOrderAssignee, related_order_sync_es), )
from django.db import transaction from django.db.models.signals import post_save from datahub.event.models import Event as DBEvent from datahub.search.event import EventSearchApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async def sync_event_to_opensearch(instance): """Sync event to the OpenSearch.""" transaction.on_commit( lambda: sync_object_async(EventSearchApp, instance.pk), ) receivers = (SignalReceiver(post_save, DBEvent, sync_event_to_opensearch), )
def sync_participant_to_es(dit_participant): """Sync a DIT participant's interaction to Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(InteractionSearchApp, dit_participant. interaction_id), ) def remove_interaction_from_es(instance): """Remove interaction from es.""" transaction.on_commit( lambda pk=instance.pk: delete_document(ESInteraction, pk), ) def sync_related_interactions_to_es(instance): """Sync related interactions.""" transaction.on_commit( lambda: sync_related_objects_async(instance, 'interactions'), ) receivers = ( SignalReceiver(post_save, DBInteraction, sync_interaction_to_es), SignalReceiver(post_save, DBInteractionDITParticipant, sync_participant_to_es), SignalReceiver(post_save, DBCompany, sync_related_interactions_to_es), SignalReceiver(post_save, DBContact, sync_related_interactions_to_es), SignalReceiver(post_save, DBInvestmentProject, sync_related_interactions_to_es), SignalReceiver(post_delete, DBInteraction, remove_interaction_from_es), )
from datahub.interaction.models import Interaction as DBInteraction from datahub.search.company import CompanySearchApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async, sync_related_objects_async def company_sync_search(instance): """Sync company to the OpenSearch.""" transaction.on_commit( lambda: sync_object_async(CompanySearchApp, instance.pk), ) def company_subsidiaries_sync_search(instance): """Sync company subsidiaries to the OpenSearch.""" transaction.on_commit( lambda: sync_related_objects_async(instance, 'subsidiaries'), ) def sync_related_company_to_opensearch(instance): """Sync related company.""" transaction.on_commit( lambda: sync_object_async(CompanySearchApp, instance.company.pk), ) receivers = ( SignalReceiver(post_save, DBCompany, company_sync_search), SignalReceiver(post_save, DBCompany, company_subsidiaries_sync_search), SignalReceiver(post_save, DBInteraction, sync_related_company_to_opensearch), )
lambda: sync_object_async(LargeCapitalOpportunitySearchApp, instance.pk), ) def related_large_capital_opportunity_sync_search(instance): """Sync related large capital opportunity Promoters to OpenSearch.""" transaction.on_commit( lambda: sync_related_objects_async( instance, 'opportunities', ), ) def remove_large_capital_opportunity_from_opensearch(instance): """Remove large capital opportunity from OpenSearch.""" transaction.on_commit( lambda pk=instance.pk: delete_document(SearchLargeCapitalOpportunity, pk), ) receivers = ( SignalReceiver(post_save, DBLargeCapitalOpportunity, large_capital_opportunity_sync_search), SignalReceiver(post_save, DBCompany, related_large_capital_opportunity_sync_search), SignalReceiver( post_delete, DBLargeCapitalOpportunity, remove_large_capital_opportunity_from_opensearch, ), )
from django.db import transaction from django.db.models.signals import post_save from datahub.company.models import Company as DBCompany, Contact as DBContact from datahub.search.contact import ContactSearchApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async, sync_related_objects_async def contact_sync_search(instance): """Sync contact to the OpenSearch.""" transaction.on_commit( lambda: sync_object_async(ContactSearchApp, instance.pk), ) def related_contact_sync_search(instance): """Sync related Company Contacts.""" transaction.on_commit( lambda: sync_related_objects_async(instance, 'contacts'), ) receivers = ( SignalReceiver(post_save, DBContact, contact_sync_search), SignalReceiver(post_save, DBCompany, related_contact_sync_search), )
from django.db.models.signals import post_save from datahub.search.signals import SignalReceiver from datahub.search.test.search_support.models import ( RelatedModel as DBRelatedModel, SimpleModel as DBSimpleModel, ) def _dummy_callback(sender, instance, **kwargs): """ Function called post-save and deliberately empty. It can be used to check if/when it's called. """ def dummy_callback(*args, **kwargs): """ Forward calls to _dummy_callback. This is so that tests can patch _dummy_callback to check if it has been called. """ _dummy_callback(*args, **kwargs) receivers = ( SignalReceiver(post_save, DBSimpleModel, dummy_callback), SignalReceiver(post_save, DBRelatedModel, dummy_callback), )
def order_sync_es(instance): """Sync an order to the Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(OrderSearchApp, instance.pk), ) def related_order_sync_es(instance): """Sync an order linked from the instance to the Elasticsearch.""" order_sync_es(instance.order) def sync_related_orders_to_es(instance): """Sync related orders.""" transaction.on_commit( lambda: sync_related_objects_async(instance, 'orders'), ) receivers = ( SignalReceiver(post_save, DBOrder, order_sync_es), SignalReceiver(post_save, DBOrderSubscriber, related_order_sync_es), SignalReceiver(post_delete, DBOrderSubscriber, related_order_sync_es), SignalReceiver(post_save, DBOrderAssignee, related_order_sync_es), SignalReceiver(post_delete, DBOrderAssignee, related_order_sync_es), SignalReceiver(post_save, DBCompany, sync_related_orders_to_es), SignalReceiver(post_save, DBContact, sync_related_orders_to_es), )
from django.db import transaction from django.db.models.signals import post_save from datahub.company.models import Company as DBCompany from datahub.search.company import CompanySearchApp from datahub.search.signals import SignalReceiver from datahub.search.sync_object import sync_object_async def company_sync_es(instance): """Sync company to the Elasticsearch.""" transaction.on_commit( lambda: sync_object_async(CompanySearchApp, instance.pk), ) receivers = (SignalReceiver(post_save, DBCompany, company_sync_es), )