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'))
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',
)
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 _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',
)
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)
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 unpatch():
post_migrate.disconnect(_invalidate_on_migration)
_unpatch_cursor()
_unpatch_atomic()
_unpatch_orm()
def ready(self):
post_migrate.connect(create_proxy_permissions)
post_migrate.disconnect(update_contenttypes)
def ready(self):
post_migrate.connect(create_proxy_permissions)
post_migrate.disconnect(update_contenttypes)
