def disconnect_signals(): post_init.disconnect(post_init_treenode, dispatch_uid='post_init_treenode') post_migrate.disconnect(post_migrate_treenode, dispatch_uid='post_migrate_treenode') post_save.disconnect(post_save_treenode, dispatch_uid='post_save_treenode') post_delete.disconnect(post_delete_treenode, dispatch_uid='post_delete_treenode')
def cria_models_tipo_autor(app_config=None, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs): models = models_with_gr_for_model(Autor) print("\n\033[93m\033[1m{}\033[0m".format( _('Atualizando registros TipoAutor do SAPL:'))) for model in models: content_type = ContentType.objects.get_for_model(model) tipo_autor = TipoAutor.objects.filter( content_type=content_type.id).exists() if tipo_autor: msg1 = "Carga de {} não efetuada.".format( TipoAutor._meta.verbose_name) msg2 = " Já Existe um {} {} relacionado...".format( TipoAutor._meta.verbose_name, model._meta.verbose_name) msg = " {}{}".format(msg1, msg2) else: novo_autor = TipoAutor() novo_autor.content_type_id = content_type.id novo_autor.descricao = model._meta.verbose_name novo_autor.save() msg1 = "Carga de {} efetuada.".format(TipoAutor._meta.verbose_name) msg2 = " {} {} criado...".format(TipoAutor._meta.verbose_name, content_type.model) msg = " {}{}".format(msg1, msg2) print(msg) # Disconecta função para evitar a chamada repetidas vezes. post_migrate.disconnect(receiver=cria_models_tipo_autor)
def ready(self): """ Patch the ContentTypes app so that: * The ContentType's manager is our SimulatedContentTypeManager. * The ContentType's PK field is BigIntegerField, so that ForeignKeys which point to it will acccept our large (signed 64 bit) IDs. * The update_contenttypes management function is replaced with our alternative version. """ if django_update_contenttypes != update_contenttypes: post_migrate.disconnect(django_update_contenttypes) from django.db import models from django.contrib.contenttypes import models as django_models if not isinstance(django_models.ContentType.objects, SimulatedContentTypeManager): django_models.ContentType.objects = SimulatedContentTypeManager(django_models.ContentType) django_models.ContentType.objects.auto_created = True # Really force the default manager to use the Simulated one meta = django_models.ContentType._meta if hasattr(meta, "local_managers"): # Django >= 1.10 meta.local_managers[0] = SimulatedContentTypeManager() else: django_models.ContentType._default_manager = SimulatedContentTypeManager(django_models.ContentType) meta._expire_cache() # Our generated IDs take up a 64 bit range (signed) but aren't auto # incrementing so update the field to reflect that (for validation) meta.pk.__class__ = models.BigIntegerField
def ready(self): """ Patch the ContentTypes app so that: * The ContentType's manager is our SimulatedContentTypeManager. * The ContentType's PK field is BigIntegerField, so that ForeignKeys which point to it will acccept our large (signed 64 bit) IDs. * The update_contenttypes management function is replaced with our alternative version. """ if django_update_contenttypes != update_contenttypes: post_migrate.disconnect(django_update_contenttypes) from django.db import models from django.contrib.contenttypes import models as django_models if not isinstance(django_models.ContentType.objects, SimulatedContentTypeManager): django_models.ContentType.objects = SimulatedContentTypeManager( django_models.ContentType) django_models.ContentType.objects.auto_created = True # Really force the default manager to use the Simulated one meta = django_models.ContentType._meta if hasattr(meta, "local_managers"): # Django >= 1.10 meta.local_managers[0] = SimulatedContentTypeManager() else: django_models.ContentType._default_manager = SimulatedContentTypeManager( django_models.ContentType) meta._expire_cache() # Our generated IDs take up a 64 bit range (signed) but aren't auto # incrementing so update the field to reflect that (for validation) meta.pk.__class__ = models.BigIntegerField
def ready(self): if django_update_contenttypes != update_contenttypes: post_migrate.disconnect(django_update_contenttypes) from django.contrib.contenttypes import models as django_models if not isinstance(django_models.ContentType.objects, SimulatedContentTypeManager): django_models.ContentType.objects = SimulatedContentTypeManager( )
def ready(self): post_migrate.disconnect( dispatch_uid="django.contrib.auth.management.create_permissions") post_migrate.connect( lazy_permission_creation, sender=self, dispatch_uid="django.contrib.auth.management.create_permissions", )
def tearDown(self): """Disconnect ``pre_migrate`` and ``post_migrate`` testing receivers.""" pre_migrate.disconnect( self.pre_migrate_receiver_mock, sender=self.main_app_config, ) post_migrate.disconnect( self.post_migrate_receiver_mock, sender=self.main_app_config, )
def on_init_db(**kwargs): def _create_superuser(): has_superuser = User.objects.filter(is_superuser=True).count() > 0 if not has_superuser: print("Creating default admin") admin = User.objects.create_superuser('admin', email='', password='******') admin.save() _create_superuser() post_migrate.disconnect(on_init_db)
def ready(self): from django.contrib.contenttypes.management import create_contenttypes post_migrate.disconnect(create_contenttypes) post_migrate.disconnect( dispatch_uid='django.contrib.auth.management.create_permissions') post_migrate.connect(idseq_update_content_type_handler) post_migrate.connect(create_contenttypes) post_migrate.connect(idseq_update_others_handler) if IS_DJADMIN: logger.info(f'signals__request_finished_handler__djadmin_ignore') return request_finished.connect(request_finished_handler)
def ready(self): from django.contrib.auth.models import Group post_migrate.disconnect( django_create_permissions, dispatch_uid='django.contrib.auth.management.create_permissions') post_migrate.connect( create_permissions, dispatch_uid='quser.management.create_permissions') post_migrate.connect( patch_user_permissions, dispatch_uid='quser.management.patch_user_permissions') pre_delete.connect(can_not_delete_group, sender=Group, dispatch_uid='quser.can_not_delete_group')
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 create_extra_permission(sender, **kwargs): from django.contrib.auth.models import Permission from django.contrib.contenttypes.models import ContentType for model in apps.get_models(): for action in ('adminactions_export', 'adminactions_massupdate', 'adminactions_merge', 'adminactions_chart', 'adminactions_byrowsupdate'): opts = model._meta codename = get_permission_codename(action, opts) label = 'Can {} {} (adminactions)'.format( action.replace('adminactions_', ""), opts.verbose_name_raw) ct = ContentType.objects.get_for_model(model) params = dict(codename=codename, content_type=ct, defaults={'name': label[:50]}) p, __ = Permission.objects.get_or_create(**params) post_migrate.disconnect( dispatch_uid='adminactions.create_extra_permission')
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 _fixture_teardown(self): post_migrate.disconnect(create_default_site, sender=apps.get_app_config('sites')) post_migrate.disconnect(update_contenttypes) post_migrate.disconnect(create_permissions, dispatch_uid="django.contrib.auth.management.create_permissions") super(AskbotTestCase, self)._fixture_teardown() post_migrate.connect(update_contenttypes) post_migrate.connect(create_permissions, dispatch_uid="django.contrib.auth.management.create_permissions") post_migrate.connect(create_default_site, sender=apps.get_app_config('sites'))
from django.db.models.signals import post_migrate except ImportError: # pragma: no cover from django.db.models.signals import post_syncdb as post_migrate if settings.USERS_CREATE_SUPERUSER: try: # create_superuser is removed in django 1.7 from django.contrib.auth.management import create_superuser except ImportError: # pragma: no cover pass else: # Prevent interactive question about wanting a superuser created. from django.contrib.auth import models as auth_app post_migrate.disconnect( create_superuser, sender=auth_app, dispatch_uid='django.contrib.auth.management.create_superuser') def auto_create_superuser(sender, **kwargs): if not settings.USERS_CREATE_SUPERUSER: return email = settings.USERS_SUPERUSER_EMAIL password = settings.USERS_SUPERUSER_PASSWORD User = get_user_model() try: User.base_objects.get(email=email) except User.DoesNotExist: print('Creating superuser ({0}:{1})'.format(email, password))
def ready(self): uid = "django.contrib.auth.management.create_permissions" post_migrate.disconnect(dispatch_uid=uid)
# Excluding unrecognized models if exclude is None or ctype.model not in exclude: ctypes.add(ctype) for perm in _get_all_permissions(klass._meta): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. 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) # Disconnecting old function post_migrate.disconnect( dispatch_uid="django.contrib.auth.management.create_permissions") # Setting custom function post_migrate.connect(custom_create_permissions, dispatch_uid="custom_create_permissions")
from django.conf import settings from django.contrib.sites.management import create_default_site from django.contrib.sites import models as sites_app try: from django.db.models.signals import post_migrate except ImportError: from django.db.models.signals import post_syncdb as post_migrate if not settings.TESTING: post_migrate.disconnect(create_default_site, sender=sites_app)
if getattr(settings, 'QWERT_AUTO_CREATE_USER', None): User = models.get_model( *settings.QWERT_AUTO_CREATE_USER.rsplit('.', 1)) else: from django.contrib.auth.models import User try: User.objects.get(username=USERNAME) except User.DoesNotExist: if verbosity > 0: print('*' * 80) print('Creating test user -- login: %s, password: %s' % (USERNAME, PASSWORD)) print('*' * 80) assert User.objects.create_superuser(USERNAME, EMAIL, PASSWORD) else: if verbosity > 0: print('Test user already exists. -- login: %s, password: %s' % (USERNAME, PASSWORD)) post_migrate.disconnect( create_superuser, sender="django.contrib.auth.models", dispatch_uid='django.contrib.auth.management.create_superuser', ) post_migrate.connect( create_testuser, sender="django.contrib.auth.models", dispatch_uid='common.models.create_testuser', )
def _disconnect_receivers(): """Disconnect testing receiver of ``pre_migrate`` or ``post_migrate``.""" yield main_app_config = apps.get_app_config('main_app') pre_migrate.disconnect(sender=main_app_config, dispatch_uid=DISPATCH_UID) post_migrate.disconnect(sender=main_app_config, dispatch_uid=DISPATCH_UID)
USERNAME = getattr(settings, 'QWERT_AUTO_CREATE_USERNAME', 'admin') PASSWORD = getattr(settings, 'QWERT_AUTO_CREATE_PASSWORD', 'admin') EMAIL = getattr(settings, 'QWERT_AUTO_CREATE_EMAIL', '*****@*****.**') if getattr(settings, 'QWERT_AUTO_CREATE_USER', None): User = models.get_model(*settings.QWERT_AUTO_CREATE_USER.rsplit('.', 1)) else: from django.contrib.auth.models import User try: User.objects.get(username=USERNAME) except User.DoesNotExist: if verbosity > 0: print('*' * 80) print('Creating test user -- login: %s, password: %s' % (USERNAME, PASSWORD)) print('*' * 80) assert User.objects.create_superuser(USERNAME, EMAIL, PASSWORD) else: if verbosity > 0: print('Test user already exists. -- login: %s, password: %s' % (USERNAME, PASSWORD)) post_migrate.disconnect( create_superuser, sender="django.contrib.auth.models", dispatch_uid='django.contrib.auth.management.create_superuser', ) post_migrate.connect( create_testuser, sender="django.contrib.auth.models", dispatch_uid='common.models.create_testuser', )
def ready(self): post_migrate.disconnect( dispatch_uid='django.contrib.auth.management.create_permissions') post_migrate.connect(create_permissions) post_migrate.connect(update_extra_view_permissions)
def unpatch(): post_migrate.disconnect(_invalidate_on_migration) _unpatch_cursor() _unpatch_atomic() _unpatch_orm()
def ready(self): if django_update_contenttypes != update_contenttypes: post_migrate.disconnect(django_update_contenttypes) from django.contrib.contenttypes import models as django_models if not isinstance(django_models.ContentType.objects, SimulatedContentTypeManager): django_models.ContentType.objects = SimulatedContentTypeManager()
def disable_create_permissions(): from django.db.models.signals import post_migrate post_migrate.disconnect(dispatch_uid='django.contrib.auth.management.create_permissions')
def ready(self): post_migrate.connect(create_proxy_permissions) post_migrate.disconnect(update_contenttypes)