def ready(self):
"""
Perform other one-time initialization steps.
"""
from django.db.models.signals import post_save, pre_migrate, pre_save
from registrar.apps.core.models import (
OrganizationGroup,
ProgramOrganizationGroup,
User,
)
from registrar.apps.core.signals import (
handle_organization_group_pre_save,
handle_program_group_pre_save,
handle_user_post_save,
)
post_save.connect(
handle_user_post_save,
sender=User,
dispatch_uid=self.USER_POST_SAVE_DISPATCH_UID
)
pre_save.connect(
handle_organization_group_pre_save,
sender=OrganizationGroup,
)
pre_save.connect(
handle_program_group_pre_save,
sender=ProgramOrganizationGroup,
)
pre_migrate.connect(self._disconnect_user_post_save_for_migrations)
def ready(self):
stylesSet = force_text(settings.CKEDITOR_SETTINGS.get('stylesSet'))
if stylesSet != 'default:{}'.format(reverse('admin:cascade_texteditor_config')):
msg = "settings.CKEDITOR_SETTINGS['stylesSet'] should be `format_lazy('default:{}', reverse_lazy('admin:cascade_texteditor_config'))`"
raise ImproperlyConfigured(msg)
pre_migrate.connect(self.__class__.pre_migrate, sender=self)
post_migrate.connect(self.__class__.post_migrate, sender=self)
def ready(self):
stylesSet = str(settings.CKEDITOR_SETTINGS.get('stylesSet'))
if stylesSet != 'default:{}'.format(reverse('admin:cascade_texteditor_config')):
msg = "settings.CKEDITOR_SETTINGS['stylesSet'] should be `format_lazy('default:{}', reverse_lazy('admin:cascade_texteditor_config'))`"
raise ImproperlyConfigured(msg)
pre_migrate.connect(self.__class__.pre_migrate, sender=self)
post_migrate.connect(self.__class__.post_migrate, sender=self)
def ready(self):
if 'cmsplugin_cascade.icon' in settings.INSTALLED_APPS:
stylesSet = force_text(settings.CKEDITOR_SETTINGS.get('stylesSet'))
if stylesSet != 'default:{}'.format(reverse('admin:cascade_texticon_wysiwig_config')):
msg = "settings.CKEDITOR_SETTINGS['stylesSet'] should be `format_lazy('default:{}', reverse_lazy('admin:cascade_texticon_wysiwig_config'))`"
raise ImproperlyConfigured(msg)
pre_migrate.connect(self.__class__.pre_migrate, sender=self)
post_migrate.connect(self.__class__.post_migrate, sender=self)
def ready(self):
"""
Connect post_save handler during routine operation. Disconnect it during migrations.
"""
connect_post_save_handler()
pre_migrate.connect(disconnect_post_save_handler)
# now, we need to reconnect the post_save handler because unittests run
# immediately after running migrate, in the same process
post_migrate.connect(connect_post_save_handler)
def ready(self):
"""
Connect post_save handler during routine operation. Disconnect it during migrations.
"""
connect_post_save_handler()
pre_migrate.connect(disconnect_post_save_handler)
# now, we need to reconnect the post_save handler because unittests run
# immediately after running migrate, in the same process
post_migrate.connect(connect_post_save_handler)
def ready(self):
if 'cmsplugin_cascade.icon' in settings.INSTALLED_APPS:
stylesSet = force_text(settings.CKEDITOR_SETTINGS.get('stylesSet'))
if stylesSet != 'default:{}'.format(reverse('admin:cascade_texticon_wysiwig_config')):
msg = "settings.CKEDITOR_SETTINGS['stylesSet'] should be `format_lazy('default:{}', reverse_lazy('admin:cascade_texticon_wysiwig_config'))`"
raise ImproperlyConfigured(msg)
pre_migrate.connect(self.__class__.pre_migrate, sender=self)
post_migrate.connect(self.__class__.post_migrate, sender=self)
def ready(self):
"""
Perform other one-time initialization steps.
"""
from enterprise.signals import handle_user_post_save
from django.db.models.signals import pre_migrate, post_save
post_save.connect(handle_user_post_save, sender=self.auth_user_model, dispatch_uid=USER_POST_SAVE_DISPATCH_UID)
pre_migrate.connect(self._disconnect_user_post_save_for_migrations)
def ready(self):
"""
Perform other one-time initialization steps.
"""
from enterprise.signals import handle_user_post_save # pylint: disable=import-outside-toplevel
from django.db.models.signals import post_save, pre_migrate # pylint: disable=C0415, # isort:skip
post_save.connect(handle_user_post_save, sender=self.auth_user_model, dispatch_uid=USER_POST_SAVE_DISPATCH_UID)
pre_migrate.connect(self._disconnect_user_post_save_for_migrations)
def ready(self):
"""
Perform other one-time initialization steps.
"""
from django.db.models.signals import pre_migrate, post_save
from registrar.apps.core.models import User
from registrar.apps.core.signals import handle_user_post_save
post_save.connect(handle_user_post_save,
sender=User,
dispatch_uid=self.USER_POST_SAVE_DISPATCH_UID)
pre_migrate.connect(self._disconnect_user_post_save_for_migrations)
def ready(self):
super().ready()
# Register default listeners
pre_migrate.connect(self.pre_migrate, sender=self)
post_migrate.connect(self.post_migrate, sender=self)
preference_updated.connect(self.preference_updated)
user_logged_in.connect(self.user_logged_in)
user_logged_out.connect(self.user_logged_out)
# Getting an app ready means it should look at its config once
self.preference_updated(self)
def ready(self):
from .signals import handlers
from .models.collection import CollectionBase
from .admin import CollectionAdminBase
# Переименование поля файла или модели-владельца файла,
# изменит также и соответствующие значения, хранящиеся в БД
pre_migrate.connect(handlers.inject_rename_filefield_operations, sender=self)
# автоматическая регистрация моделей галерей в админке
for model in apps.get_models():
if issubclass(model, CollectionBase) and not site.is_registered(model):
site.register(model, CollectionAdminBase)
def ready(self):
from .patches import json
json.patch()
from djangae.db.backends.appengine.caching import reset_context
from djangae.db.migrations.signals import check_migrations
from django.core.signals import request_finished, request_started
from django.db.models.signals import pre_migrate
request_finished.connect(reset_context, dispatch_uid="request_finished_context_reset")
request_started.connect(reset_context, dispatch_uid="request_started_context_reset")
pre_migrate.connect(check_migrations, dispatch_uid="pre_migrate_check_connections")
self._check_content_types()
def ready(self):
super(WorkAppConfig, self).ready()
from work.models import create_unit_types, create_exchange_skills, fill_empty_languages
from general.models import create_general_types
from work.signals import comment_notification
from django.db import DEFAULT_DB_ALIAS
if not settings.TESTING and is_database_synchronized(DEFAULT_DB_ALIAS):
pre_migrate.connect(fill_empty_languages, sender=self)
post_migrate.connect(create_general_types, sender=self)
post_migrate.connect(create_unit_types, sender=self)
post_migrate.connect(create_exchange_skills, sender=self)
comment_was_posted.connect(comment_notification,
sender=self) #Comment)
def ready(self):
from .patches import json
json.patch()
from djangae.db.backends.appengine.caching import reset_context
from djangae.db.migrations.signals import check_migrations
from django.core.signals import request_finished, request_started
from django.db.models.signals import pre_migrate
request_finished.connect(reset_context,
dispatch_uid="request_finished_context_reset")
request_started.connect(reset_context,
dispatch_uid="request_started_context_reset")
pre_migrate.connect(check_migrations,
dispatch_uid="pre_migrate_check_connections")
self._check_content_types()
def prepare(self):
"""Connect testing ``pre_migrate`` and ``post_migrate`` receivers."""
self.pre_migrate_receiver_mock = mock.MagicMock()
self.post_migrate_receiver_mock = mock.MagicMock()
# ``old_apps`` is not real ``ProjectState`` instance, so we cannot use
# it to get "original" main_app ``AppConfig`` instance needed to
# connect signal receiver, that's the reason we are using
# ``apps`` imported directly from ``django.apps``
self.main_app_config = apps.get_app_config('main_app')
pre_migrate.connect(
self.pre_migrate_receiver_mock,
sender=self.main_app_config,
)
post_migrate.connect(
self.post_migrate_receiver_mock,
sender=self.main_app_config,
)
def test_signals(self):
""" Test the signals emitted during the migration """
app_config = apps.get_app_config('event_calendar')
pre_migrate_callback = mock.MagicMock()
post_migrate_callback = mock.MagicMock()
pre_migrate.connect(pre_migrate_callback, sender=app_config)
post_migrate.connect(post_migrate_callback, sender=app_config)
self.test_routine_migration()
pre_migrate.disconnect(pre_migrate_callback, sender=app_config)
post_migrate.disconnect(post_migrate_callback, sender=app_config)
self.assertEqual(pre_migrate_callback.call_count, 3)
self.assertEqual(post_migrate_callback.call_count, 3)
def ready(self, *args, **kwargs):
from django.core import checks
from django.core.signals import request_started
from django.db.models.signals import post_migrate
from django.db.models.signals import pre_migrate
super(TalosAppConfig, self).ready(*args, **kwargs)
post_migrate.disconnect(
dispatch_uid='django.contrib.auth.management.create_permissions')
pre_migrate.connect(_pre_migrate,
dispatch_uid='{0}.{1}'.format(
_pre_migrate.__module__,
_pre_migrate.__name__))
post_migrate.connect(_post_migrate,
dispatch_uid='{0}.{1}'.format(
_post_migrate.__module__,
_post_migrate.__name__))
checks.register(_model_checks, checks.Tags.models)
request_started.connect(_request_started,
dispatch_uid=_REQUEST_STARTED_UID)
def ready(self):
"""
This supports two use cases for using tsvector_field:
1. Configure your Django project to use tsvecotr_field's DatabaseSchemaEditor
directly by creating your own DatabaseWrapper and referencing
tsvector_field.DatabaseSchemaEditor in the SchemaEditorClass attribute.
See: tsvector_field/schema.py for more info.
2. Just add `tsvector_field` to your project's INSTALLED_APPS setting and this
will use the `pre_migrate` mechanism. Note: `pre_migrate` is not fired for
./manage.py migrate --run-syncdb. So if you are building apps without migrations
you will have to use the more reliable approach in option #1.
"""
from django.db import connection
from . import DatabaseSchemaEditor
if not isinstance(connection.schema_editor(), DatabaseSchemaEditor):
# only register for pre_migrate if we're not already configured
# with the DatabaseSchemaEditor, see option #1 in doc above
from django.db.models.signals import pre_migrate
from .receivers import inject_trigger_operations
pre_migrate.connect(inject_trigger_operations)
def ready(self):
pre_migrate.connect(raise_migration_flag, sender=self)
def ready(self):
pre_migrate.connect(ensure_azure_container, sender=self)
if Permission.objects.filter(codename=codename).exclude(
content_type=activity_content_type).exists():
# app_label.codename should match activity_content_type, otherwise that doesn't really make sense
raise ValueError(
"A permission for {}.{} with a different content type already"
" exists. Set auto_create_permission to False or remove the other"
" permission")
if app_label != activity_content_type.app_label:
raise ValueError(
"The permission {} has an app label {} that "
"does not match the activity model's app_label {}".format(
activity.permission, app_label,
activity_content_type.app_label))
name = activity.verbose_name or activity.name
Permission.objects.update_or_create(
content_type=activity_content_type,
codename=codename,
defaults={
"name":
"{} - {}".format(six.text_type(flow), six.text_type(name))
},
)
pre_migrate.connect(
lambda *args, **kwargs: autodiscover_flows(),
dispatch_uid="processlib.signals.autodiscover_flows",
)
def ready(self):
pre_migrate.connect(self.enforce_database_constraint_callback)
"""Import flows before auth permission setup."""
try:
from django.db.models.signals import pre_migrate
def import_flows(app_config, **kwargs):
"""Pre-import flows to allow permissions auto-creation."""
try:
__import__('{}.flows'.format(app_config.module.__name__))
except ImportError:
pass
pre_migrate.connect(import_flows, dispatch_uid="viewflow.management.import_flows")
except ImportError:
# django 1.6
try:
from south.signals import pre_migrate, post_migrate
from ..compat import get_app_package
def import_flows(app, **kwargs):
try:
__import__('{}.flows'.format(get_app_package(app)))
except ImportError:
pass
pre_migrate.connect(import_flows, dispatch_uid="viewflow.management.import_flows")
from django.conf import settings
if 'django.contrib.auth' in settings.INSTALLED_APPS:
def create_permissions_compat(app, **kwargs):
def create_test_db(self, *args, **kwargs):
pre_migrate.connect(_create_heroku_connect_schema)
return super().create_test_db(*args, **kwargs)
from stream_django.conf import FEED_MANAGER_CLASS
from stream_django.conf import DJANGO_MAJOR_VERSION
from django.db.models.signals import class_prepared
from stream_django.utils import get_class_from_string
feed_manager_class = get_class_from_string(FEED_MANAGER_CLASS)
feed_manager = feed_manager_class()
class_prepared = class_prepared.connect(feed_manager.bind_model)
def disable_model_tracking(sender, **kwargs):
feed_manager.disable_model_tracking()
if DJANGO_MAJOR_VERSION == 1.6:
from django.db.models.signals import pre_syncdb
pre_syncdb.connect(disable_model_tracking)
elif DJANGO_MAJOR_VERSION > 1.6:
from django.db.models.signals import pre_migrate
pre_migrate.connect(disable_model_tracking)
def ready(self):
pre_migrate.connect(inject_rename_contenttypes_operations, sender=self)
post_migrate.connect(create_contenttypes)
checks.register(check_generic_foreign_keys, checks.Tags.models)
# ##############################################################################
from django.apps import AppConfig
from django.db.models.signals import post_migrate, pre_migrate
# noinspection PyUnresolvedReferences
import df_config.checks
from df_config.config.base import merger
class MigrationCounter:
def __init__(self):
self.last_app_config = None
# noinspection PyUnusedLocal
def pre_migrate(self, *args, app_config: AppConfig = None, **kwargs):
if self.last_app_config is None: # this is the pre_migrate of first app
merger.call_method_on_config_values("pre_migrate")
self.last_app_config = app_config.name
# noinspection PyUnusedLocal
def post_migrate(self, *args, app_config: AppConfig = None, **kwargs):
if (app_config.name == self.last_app_config
): # this is the post_migrate of the last app
merger.call_method_on_config_values("post_migrate")
migration_counter = MigrationCounter()
pre_migrate.connect(migration_counter.pre_migrate)
post_migrate.connect(migration_counter.post_migrate)
def ready(self):
pre_migrate.connect(create_index, sender=self)
post_migrate.connect(reindex, sender=self)
def ready(self):
"""
Listen for pre-migrate signals and prompt for migration docs.
"""
pre_migrate.connect(sync_docs_on_pre_migrate,
dispatch_uid='sync_docs_on_pre_migrate')
def __init__(self, *args, **kwargs):
pre_migrate.connect(check_srid_has_meter_unit, sender=self, dispatch_uid='geotrek.core.checksrid')
super(GeotrekConfig, self).__init__(*args, **kwargs)
def ready(self):
pre_migrate.connect(start_migration, sender=self)
post_migrate.connect(end_migration, sender=self)
def ready(self):
from .signals import pre_migrate_copy_opencart_data, post_migrate_clear_foreignkeys
pre_migrate.connect(pre_migrate_copy_opencart_data, sender=self)
post_migrate.connect(post_migrate_clear_foreignkeys, sender=self)
def ready(self):
pre_migrate.connect(inject_rename_contenttypes_operations, sender=self)
post_migrate.connect(create_contenttypes)
all_perms = set(
Permission.objects.using(using).filter(
content_type__in=ctypes, ).values_list("content_type", "codename"))
perms = [
Permission(codename=codename, name=name, content_type=ct)
for ct, (codename, name) in searched_perms
if (ct.pk, codename) not in all_perms
]
Permission.objects.using(using).bulk_create(perms)
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s'" % perm)
def import_flows(app_config, **kwargs):
"""Pre-import flows to allow permissions auto-creation."""
try:
__import__('{}.flows'.format(app_config.module.__name__))
except ImportError:
pass
pre_migrate.connect(import_flows,
dispatch_uid="viewflow.management.import_flows")
if django.VERSION >= (1, 10):
post_migrate.connect(create_permissions,
dispatch_uid="viewflow.management.create_permissions")
def ready(self):
pre_migrate.connect(inject_rename_contenttypes_operations, sender=self)
post_migrate.connect(update_contenttypes)
checks.register(check_generic_foreign_keys, checks.Tags.models)
def handle(self, *args, **options):
# Only connect the handler when this command is run to
# avoid running for tests.
pre_migrate.connect(self.pre_migrate_receiver,
dispatch_uid="django_safemigrate")
super().handle(*args, **options)
CITextField = six.add_metaclass(models.SubfieldBase)(CITextField)
CICharField = six.add_metaclass(models.SubfieldBase)(CICharField)
CIEmailField = six.add_metaclass(models.SubfieldBase)(CIEmailField)
if "south" in settings.INSTALLED_APPS:
from south.modelsinspector import add_introspection_rules
add_introspection_rules(
[], ["^sentry\.db\.models\.fields\.citext\.CITextField"])
add_introspection_rules(
[], ["^sentry\.db\.models\.fields\.citext\.CICharField"])
add_introspection_rules(
[], ["^sentry\.db\.models\.fields\.citext\.CIEmailField"])
def create_citext_extension(using, **kwargs):
from sentry.utils.db import is_postgres
# We always need the citext extension installed for Postgres,
# and for tests, it's not always guaranteed that we will have
# run full migrations which installed it.
if is_postgres(using):
cursor = connections[using].cursor()
try:
cursor.execute("CREATE EXTENSION IF NOT EXISTS citext")
except Exception:
pass
pre_migrate.connect(create_citext_extension)
from stream_django.conf import FEED_MANAGER_CLASS
from stream_django.conf import DJANGO_MAJOR_VERSION
from django.db.models.signals import class_prepared
from stream_django.utils import get_class_from_string
feed_manager_class = get_class_from_string(FEED_MANAGER_CLASS)
feed_manager = feed_manager_class()
class_prepared = class_prepared.connect(feed_manager.bind_model)
def disable_model_tracking(sender, **kwargs):
feed_manager.disable_model_tracking()
if DJANGO_MAJOR_VERSION == 1.6:
from django.db.models.signals import pre_syncdb
pre_syncdb.connect(disable_model_tracking)
elif DJANGO_MAJOR_VERSION > 1.6:
from django.db.models.signals import pre_migrate
pre_migrate.connect(disable_model_tracking)
