def ready(self):
# Load projector elements.
# Do this by just importing all from these files.
from . import projector # noqa
# Import all required stuff.
from openslides.core.config import config
from openslides.utils.rest_api import router
from .config_variables import get_config_variables
from .signals import create_builtin_workflows
from .views import CategoryViewSet, MotionViewSet, MotionBlockViewSet, MotionPollViewSet, MotionChangeRecommendationViewSet, WorkflowViewSet
# Define config variables
config.update_config_variables(get_config_variables())
# Connect signals.
post_migrate.connect(create_builtin_workflows, dispatch_uid='motion_create_builtin_workflows')
# Register viewsets.
router.register(self.get_model('Category').get_collection_string(), CategoryViewSet)
router.register(self.get_model('Motion').get_collection_string(), MotionViewSet)
router.register(self.get_model('MotionBlock').get_collection_string(), MotionBlockViewSet)
router.register(self.get_model('Workflow').get_collection_string(), WorkflowViewSet)
router.register(self.get_model('MotionChangeRecommendation').get_collection_string(),
MotionChangeRecommendationViewSet)
router.register('motions/motionpoll', MotionPollViewSet)
def ready(self):
from .management import create_initial_superuser
from .models import Account
services.register(Account, menu=False, dashboard=False)
accounts.register(Account, icon='Face-monkey.png')
post_migrate.connect(create_initial_superuser,
dispatch_uid="orchestra.contrib.accounts.management.createsuperuser")
def ready(self):
from metadata.handlers import save_db_state, populate_values_list_cache
# Hooking to post_migrate is the only way I've found to
# make sure the db is really available and can be queried
# to populate the values list cache
post_migrate.connect(save_db_state, sender=self)
post_migrate.connect(populate_values_list_cache, sender=self)
def ready(self):
post_migrate.connect(
create_permissions,
dispatch_uid="django.contrib.auth.management.create_permissions"
)
checks.register(check_user_model, checks.Tags.models)
checks.register(check_models_permissions, checks.Tags.models)
def setUp(self):
from django.db.models.signals import post_save, post_delete
try:
from django.db.models.signals import post_migrate
except ImportError: # django <= 1.6
from django.db.models.signals import post_syncdb as post_migrate
from django_elasticsearch.models import es_save_callback
from django_elasticsearch.models import es_delete_callback
from django_elasticsearch.models import es_syncdb_callback
try:
from django.apps import apps
app = apps.get_app_config('django_elasticsearch')
except ImportError: # django 1.4
from django.db.models import get_app
app = get_app('django_elasticsearch')
post_save.connect(es_save_callback)
post_delete.connect(es_delete_callback)
post_migrate.connect(es_syncdb_callback)
if int(get_version()[2]) >= 6:
sender = app
else:
sender = None
post_migrate.send(sender=sender,
app_config=app,
app=app, # django 1.4
created_models=[TestModel,],
verbosity=2)
self.instance = TestModel.objects.create(username=u"1",
first_name=u"woot",
last_name=u"foo")
self.instance.es.do_index()
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):
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):
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 ready(self):
post_migrate.connect(
create_permissions,
dispatch_uid="django.contrib.auth.management.create_permissions"
)
if hasattr(get_user_model(), 'last_login'):
from .models import update_last_login
user_logged_in.connect(update_last_login, dispatch_uid='update_last_login')
checks.register(check_user_model, checks.Tags.models)
checks.register(check_models_permissions, checks.Tags.models)
def ready(self) -> None:
# We import zerver.signals here for the side effect of
# registering the user_logged_in signal receiver. This import
# needs to be here (rather than e.g. at top-of-file) to avoid
# running that code too early in Django's setup process, but
# in any case, this is an intentionally unused import.
import zerver.signals
if settings.POST_MIGRATION_CACHE_FLUSHING:
post_migrate.connect(flush_cache, sender=self)
def ready(self):
"""
For postgresql only, remove like indexes for uuid columns and
create version-unique indexes.
This will only be run in django >= 1.7.
:return: None
"""
if connection.vendor == 'postgresql':
post_migrate.connect(index_adjustments, sender=self)
def ready(self):
from . import signals
from django.contrib.auth.models import User
post_migrate.connect(signals.create_groups)
if DJANGO_AUTH_TYPE == 'SIMPLE':
post_save.connect(signals.create_user, sender=User, dispatch_uid="create_user")
import django_auth_ldap.backend
django_auth_ldap.backend.populate_user.connect(signals.update_ldap_groups)
def ready(self):
from .utils import create_perms
post_migrate.connect(
create_perms,
sender=__import__('disguise')
)
post_save.connect(
create_perms,
sender=apps.get_model('auth.Permission')
)
def ready(self):
from django.contrib.sites.models import Site
from job_board.signals import gen_site_config_post_migrate
from job_board.signals import gen_site_config_post_save
post_save.connect(gen_site_config_post_save, sender=Site)
# NOTE: We list sites before job_board in INSTALLED_APPS, failing to
# do that will result in this post_migrate signal firing before
# the default site has been created.
post_migrate.connect(gen_site_config_post_migrate, sender=self)
def ready(self):
post_migrate.connect(
create_permissions,
dispatch_uid="django.contrib.auth.management.create_permissions"
)
last_login_field = getattr(get_user_model(), 'last_login', None)
# Register the handler only if UserModel.last_login is a field.
if isinstance(last_login_field, DeferredAttribute):
from .models import update_last_login
user_logged_in.connect(update_last_login, dispatch_uid='update_last_login')
checks.register(check_user_model, checks.Tags.models)
checks.register(check_models_permissions, checks.Tags.models)
def patch():
global PATCHED
post_migrate.connect(_invalidate_on_migration)
if 'south' in settings.INSTALLED_APPS:
from south.signals import post_migrate as south_post_migrate
south_post_migrate.connect(_invalidate_on_migration)
_patch_cursor()
_patch_atomic()
_patch_orm()
PATCHED = True
def ready(self):
# Ensure everything below is only ever run once
if getattr(AppConfig, 'has_run_ready', False):
return
AppConfig.has_run_ready = True
if 'django.contrib.sites' in settings.INSTALLED_APPS:
from .management import create_default_site
post_migrate.connect(create_default_site, sender=self)
try:
importlib.import_module('localsite.receivers')
except ImportError:
pass
def ready(self):
if django_version() == DjangoVersion.DJANGO_21:
# Disable silently the package for Django => 2.1. We don't override
# admin_site neither the default ModelAdmin.
warnings.warn(
'The package `admin_view_permission is deprecated in '
'Django 2.1. Django added this functionality into the core.',
DeprecationWarning
)
return
if not isinstance(admin.site, AdminViewPermissionAdminSite):
admin.site = AdminViewPermissionAdminSite('admin')
admin.sites.site = admin.site
post_migrate.connect(update_permissions)
def ready(self):
# Import all required stuff.
from .config import config
from ..utils.rest_api import router
from .config_variables import get_config_variables
from .projector import get_projector_elements
from .signals import (
delete_django_app_permissions,
get_permission_change_data,
permission_change,
post_permission_creation,
required_users,
user_data_required,
)
from .views import (
ChatMessageViewSet,
ConfigViewSet,
CountdownViewSet,
ProjectorMessageViewSet,
ProjectorViewSet,
TagViewSet,
)
# Define config variables and projector elements.
config.update_config_variables(get_config_variables())
register_projector_elements(get_projector_elements())
# Connect signals.
post_permission_creation.connect(
delete_django_app_permissions,
dispatch_uid='delete_django_app_permissions')
permission_change.connect(
get_permission_change_data,
dispatch_uid='core_get_permission_change_data')
user_data_required.connect(
required_users,
dispatch_uid='core_required_users')
post_migrate.connect(call_save_default_values, sender=self, dispatch_uid='core_save_config_default_values')
# Register viewsets.
router.register(self.get_model('Projector').get_collection_string(), ProjectorViewSet)
router.register(self.get_model('ChatMessage').get_collection_string(), ChatMessageViewSet)
router.register(self.get_model('Tag').get_collection_string(), TagViewSet)
router.register(self.get_model('ConfigStore').get_collection_string(), ConfigViewSet, 'config')
router.register(self.get_model('ProjectorMessage').get_collection_string(), ProjectorMessageViewSet)
router.register(self.get_model('Countdown').get_collection_string(), CountdownViewSet)
def setUp(self):
post_save.connect(manage_meetup_location_groups, sender=MeetupLocation,
dispatch_uid="manage_groups")
post_delete.connect(remove_meetup_location_groups, sender=MeetupLocation,
dispatch_uid="remove_groups")
m2m_changed.connect(add_meetup_location_members, sender=MeetupLocation.members.through,
dispatch_uid="add_members")
m2m_changed.connect(add_meetup_location_moderators,
sender=MeetupLocation.moderators.through,
dispatch_uid="add_moderators")
m2m_changed.connect(delete_meetup_location_members, sender=MeetupLocation.members.through,
dispatch_uid="delete_members")
m2m_changed.connect(delete_meetup_location_moderators,
sender=MeetupLocation.moderators.through,
dispatch_uid="delete_moderators")
post_migrate.connect(create_notice_types, dispatch_uid="create_notice_types")
self.password = "******"
def ready(self):
# Import all required stuff.
from openslides.core.config import config
from openslides.core.signals import permission_change, user_data_required
from openslides.utils.rest_api import router
from .config_variables import get_config_variables
from .projector import get_projector_elements
from .signals import (
create_builtin_workflows,
get_permission_change_data,
required_users,
)
from .views import (
CategoryViewSet,
MotionViewSet,
MotionBlockViewSet,
MotionPollViewSet,
MotionChangeRecommendationViewSet,
StateViewSet,
WorkflowViewSet,
)
# Define config variables and projector elements.
config.update_config_variables(get_config_variables())
register_projector_elements(get_projector_elements())
# Connect signals.
post_migrate.connect(
create_builtin_workflows,
dispatch_uid='motion_create_builtin_workflows')
permission_change.connect(
get_permission_change_data,
dispatch_uid='motions_get_permission_change_data')
user_data_required.connect(
required_users,
dispatch_uid='motions_required_users')
# Register viewsets.
router.register(self.get_model('Category').get_collection_string(), CategoryViewSet)
router.register(self.get_model('Motion').get_collection_string(), MotionViewSet)
router.register(self.get_model('MotionBlock').get_collection_string(), MotionBlockViewSet)
router.register(self.get_model('Workflow').get_collection_string(), WorkflowViewSet)
router.register(self.get_model('MotionChangeRecommendation').get_collection_string(),
MotionChangeRecommendationViewSet)
router.register(self.get_model('MotionPoll').get_collection_string(), MotionPollViewSet)
router.register(self.get_model('State').get_collection_string(), StateViewSet)
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):
# Load projector elements.
# Do this by just importing all from these files.
from . import projector # noqa
# Import all required stuff.
from openslides.core.signals import config_signal
from openslides.utils.rest_api import router
from .signals import create_builtin_workflows, setup_motion_config
from .views import CategoryViewSet, MotionViewSet, MotionPollViewSet, WorkflowViewSet
# Connect signals.
config_signal.connect(setup_motion_config, dispatch_uid='setup_motion_config')
post_migrate.connect(create_builtin_workflows, dispatch_uid='motion_create_builtin_workflows')
# Register viewsets.
router.register('motions/category', CategoryViewSet)
router.register('motions/motion', MotionViewSet)
router.register('motions/motionpoll', MotionPollViewSet)
router.register('motions/workflow', WorkflowViewSet)
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 ready(self):
super(WorkAppConfig, self).ready()
from work.models import create_unit_types, create_exchange_skills
from general.models import create_general_types
from work.signals import comment_notification
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)
#comment_will_be_posted.connect(pre_comment, sender=Comment)
logger.debug("Connected signals to post_migrate and comment_was_posted")
def ready(self):
post_migrate.connect(create_global_settings, sender=self)
self.module.autodiscover()
def ready(self):
post_migrate.connect(create_default_kafka_group, sender=self)
def ready(self):
post_migrate.connect(init_users_groups, sender=self)
# noinspection PyUnresolvedReferences
import grandchallenge.core.signals # noqa: F401
def ready(self):
post_migrate.connect(create_CMSpages)
from institutions.models import Institution
from users.models import User, AccountType
for model in apps.get_app_config('common').models.values():
admin.site.register(model)
def add_default_user(sender, **kwargs):
if User.objects.count() == 0:
AccountType.objects.all().delete()
print 'Creating Account Types'
for account_type in ['Teacher', 'Parent', 'Student']:
AccountType.objects.create(name=account_type)
print 'Creating User'
user = User.objects.create(
'tweechy',
'Peter',
'tweechy!@#',
last_name='Saruni',
middle_name='Njenga',
account_type=AccountType.objects.get(name='Teacher'))
print 'Creating Default Institution'
institution = Institution.objects.create(name='Starehe Boys Centre',
created_by=user)
# Add default user to database
post_migrate.connect(add_default_user)
def ready(self):
super().ready()
post_migrate.connect(permission_callback, sender=self)
def auto_create_superuser(sender, **kwargs):
if not settings.USERS_CREATE_SUPERUSER:
return
email = settings.USERS_SUPERUSER_EMAIL
password = settings.USERS_SUPERUSER_PASSWORD
#name=UsersAppConf.SUPERUSER_NAEM
User = get_user_model()
try:
User.base_objects.get(email=email)
except User.DoesNotExist:
print('Creating superuser ({0}:{1})'.format(email, password))
User.objects.create_superuser(email, password)
post_migrate.connect(auto_create_superuser, sender=None)
class EmailActivationTokenGenerator(object):
def make_token(self, user):
return self._make_token_with_timestamp(user,
self._num_days(self._today()))
def check_token(self, user, token):
"""
Check that a activation token is correct for a given user.
"""
# Parse the token
try:
ts_b36, hash = token.split('-')
except ValueError:
def ready(self):
post_migrate.connect(init_workstation_creators_group, sender=self)
post_migrate.connect(init_session_permissions, sender=self)
import os
from django.db.models.signals import post_migrate
from django.contrib.auth import get_user_model
from django.contrib import admin
admin.site.site_header = 'BI-transactions Admin'
User = get_user_model()
def add_initial_super_admin(sender, **kwargs):
if User.objects.count() == 0:
print('Creating a superAdmin')
User.objects.create_superuser(username=os.getenv('SUPER_NAME'),
email=os.getenv('SUPER_EMAIL'),
password=os.getenv('SUPER_PASS'))
post_migrate.connect(add_initial_super_admin)
def ready(self):
post_migrate.connect(post_migrate_callback, sender=self)
from vehicles.importers import register_importers_from_settings
register_importers_from_settings()
def ready(self):
super(PagesConfig, self).ready()
post_migrate.connect(create_notice_types, sender=self)
def ready(self):
post_migrate.connect(ensure_django_comment_object_pk_is_int)
"""
# for each of our content types
for content_type in ContentType.objects.all():
# build our permission slug
codename = "view_%s" % content_type.model
# if it doesn't exist..
if not Permission.objects.filter(content_type=content_type, codename=codename):
# add it
Permission.objects.create(content_type=content_type,
codename=codename,
name="Can view %s" % content_type.name)
# print "Added view permission for %s" % content_type.name
# check for all our view permissions after a syncdb
post_migrate.connect(add_view_permissions)
class Bookmark(models.Model):
title = models.CharField(_(u'Title'), max_length=128)
user = models.ForeignKey(AUTH_USER_MODEL, on_delete=models.CASCADE, verbose_name=_(u"user"), blank=True, null=True)
url_name = models.CharField(_(u'Url Name'), max_length=64)
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
query = models.CharField(_(u'Query String'), max_length=1000, blank=True)
is_share = models.BooleanField(_(u'Is Shared'), default=False)
@property
def url(self):
base_url = reverse(self.url_name)
if self.query:
base_url = base_url + '?' + self.query
def ready(self):
post_migrate.connect(create_index, sender=self)
def ready(self):
post_migrate.connect(signals.signal_post_migrate, sender=self)
def ready(self):
post_migrate.connect(my_callback, sender=self)
def append(self, field):
self._fields.append([field.model._meta.app_label, field.model.__name__])
def __iter__(self):
return iter([get_model(*i)._concurrencymeta.field for i in self._fields])
def __contains__(self, field):
target = [field.model._meta.app_label, field.model.__name__]
return target in self._fields
_TRIGGERS = TriggerRegistry()
# _TRIGGERS = []
if not conf.MANUAL_TRIGGERS:
post_migrate.connect(post_syncdb_concurrency_handler, dispatch_uid='post_syncdb_concurrency_handler')
class VersionField(Field):
""" Base class """
def __init__(self, *args, **kwargs):
verbose_name = kwargs.get('verbose_name', None)
name = kwargs.get('name', None)
db_tablespace = kwargs.get('db_tablespace', None)
db_column = kwargs.get('db_column', None)
help_text = kwargs.get('help_text', _('record revision number'))
super(VersionField, self).__init__(verbose_name, name,
help_text=help_text,
default=0,
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))
User.objects.create_superuser(email, password)
post_migrate.connect(auto_create_superuser, sender=None)
class EmailActivationTokenGenerator(object):
def make_token(self, user):
return self._make_token_with_timestamp(user, self._num_days(self._today()))
def check_token(self, user, token):
"""
Check that a activation token is correct for a given user.
"""
# Parse the token
try:
ts_b36, hash = token.split('-')
except ValueError:
def ready(self):
# start email reminder task once migrations have completed
post_migrate.connect(start_reminder_email_task, sender=self)
def ready(self):
super(DocumentStatesApp, self).ready()
from actstream import registry
Action = apps.get_model(app_label='actstream', model_name='Action')
Document = apps.get_model(app_label='documents', model_name='Document')
DocumentType = apps.get_model(app_label='documents',
model_name='DocumentType')
ErrorLogEntry = apps.get_model(app_label='common',
model_name='ErrorLogEntry')
Workflow = self.get_model('Workflow')
WorkflowInstance = self.get_model('WorkflowInstance')
WorkflowInstanceLogEntry = self.get_model('WorkflowInstanceLogEntry')
WorkflowRuntimeProxy = self.get_model('WorkflowRuntimeProxy')
WorkflowState = self.get_model('WorkflowState')
WorkflowStateAction = self.get_model('WorkflowStateAction')
WorkflowStateRuntimeProxy = self.get_model('WorkflowStateRuntimeProxy')
WorkflowTransition = self.get_model('WorkflowTransition')
WorkflowTransitionField = self.get_model('WorkflowTransitionField')
WorkflowTransitionTriggerEvent = self.get_model(
'WorkflowTransitionTriggerEvent')
Document.add_to_class(name='workflow',
value=DocumentStateHelper.constructor)
ErrorLogEntry.objects.register(model=WorkflowStateAction)
WorkflowAction.initialize()
ModelAttribute(
model=Document,
name='workflow.< workflow internal name >.get_current_state',
label=_('Current state of a workflow'),
description=_('Return the current state of the selected workflow'))
ModelAttribute(
model=Document,
name=
'workflow.< workflow internal name >.get_current_state.completion',
label=_('Current state of a workflow'),
description=_(
'Return the completion value of the current state of the '
'selected workflow'))
ModelEventType.register(event_types=(event_workflow_edited, ),
model=Workflow)
ModelPermission.register(model=Document,
permissions=(permission_workflow_view, ))
ModelPermission.register(model=Workflow,
permissions=(
permission_error_log_view,
permission_workflow_delete,
permission_workflow_edit,
permission_workflow_transition,
permission_workflow_view,
))
ModelPermission.register(
model=WorkflowTransition,
permissions=(permission_workflow_transition, ))
ModelPermission.register_inheritance(
model=WorkflowInstance,
related='workflow',
)
ModelPermission.register_inheritance(
model=WorkflowInstanceLogEntry,
related='workflow_instance__workflow',
)
ModelPermission.register_inheritance(
model=WorkflowState,
related='workflow',
)
ModelPermission.register_inheritance(
model=WorkflowStateAction,
related='state__workflow',
)
ModelPermission.register_inheritance(
model=WorkflowTransition,
related='workflow',
)
ModelPermission.register_inheritance(
model=WorkflowTransitionField,
related='transition',
)
ModelPermission.register_inheritance(
model=WorkflowTransitionTriggerEvent,
related='transition__workflow',
)
SourceColumn(attribute='label', is_sortable=True, source=Workflow)
column_workflow_internal_name = SourceColumn(attribute='internal_name',
is_sortable=True,
source=Workflow)
column_workflow_internal_name.add_exclude(source=WorkflowRuntimeProxy)
SourceColumn(attribute='get_initial_state',
empty_value=_('None'),
source=Workflow)
SourceColumn(source=WorkflowInstance,
label=_('Current state'),
attribute='get_current_state')
SourceColumn(
source=WorkflowInstance,
label=_('User'),
func=lambda context: getattr(
context['object'].get_last_log_entry(), 'user', _('None')))
SourceColumn(source=WorkflowInstance,
label=_('Last transition'),
attribute='get_last_transition')
SourceColumn(
source=WorkflowInstance,
label=_('Date and time'),
func=lambda context: getattr(
context['object'].get_last_log_entry(), 'datetime', _('None')))
SourceColumn(
source=WorkflowInstance,
label=_('Completion'),
func=lambda context: getattr(context['object'].get_current_state(),
'completion', _('None')))
SourceColumn(source=WorkflowInstanceLogEntry,
label=_('Date and time'),
attribute='datetime')
SourceColumn(source=WorkflowInstanceLogEntry,
label=_('User'),
attribute='user')
SourceColumn(source=WorkflowInstanceLogEntry,
attribute='transition__origin_state',
is_sortable=True)
SourceColumn(source=WorkflowInstanceLogEntry,
attribute='transition',
is_sortable=True)
SourceColumn(source=WorkflowInstanceLogEntry,
attribute='transition__destination_state',
is_sortable=True)
SourceColumn(source=WorkflowInstanceLogEntry,
attribute='comment',
is_sortable=True)
SourceColumn(source=WorkflowInstanceLogEntry,
attribute='get_extra_data',
label=_('Additional details'),
widget=WorkflowLogExtraDataWidget)
SourceColumn(attribute='label', is_sortable=True, source=WorkflowState)
SourceColumn(attribute='initial',
is_sortable=True,
source=WorkflowState,
widget=TwoStateWidget)
SourceColumn(
attribute='completion',
source=WorkflowState,
is_sortable=True,
)
SourceColumn(attribute='label',
is_sortable=True,
source=WorkflowStateAction)
SourceColumn(attribute='enabled',
is_sortable=True,
source=WorkflowStateAction,
widget=TwoStateWidget)
SourceColumn(attribute='get_when_display',
label=_('When?'),
source=WorkflowStateAction)
SourceColumn(attribute='get_class_label',
label=_('Action type'),
source=WorkflowStateAction)
SourceColumn(
attribute='label',
is_sortable=True,
source=WorkflowTransition,
)
SourceColumn(attribute='origin_state',
is_sortable=True,
source=WorkflowTransition)
SourceColumn(attribute='destination_state',
is_sortable=True,
source=WorkflowTransition)
SourceColumn(source=WorkflowTransition,
label=_('Triggers'),
func=lambda context: widget_transition_events(
transition=context['object']))
SourceColumn(attribute='name',
is_identifier=True,
is_sortable=True,
source=WorkflowTransitionField)
SourceColumn(attribute='label',
is_sortable=True,
source=WorkflowTransitionField)
SourceColumn(attribute='get_field_type_display',
label=_('Type'),
source=WorkflowTransitionField)
SourceColumn(attribute='required',
is_sortable=True,
source=WorkflowTransitionField,
widget=TwoStateWidget)
SourceColumn(attribute='get_widget_display',
label=_('Widget'),
is_sortable=False,
source=WorkflowTransitionField)
SourceColumn(attribute='widget_kwargs',
is_sortable=True,
source=WorkflowTransitionField)
SourceColumn(source=WorkflowRuntimeProxy,
label=_('Documents'),
func=lambda context: context['object'].get_document_count(
user=context['request'].user),
order=99)
SourceColumn(source=WorkflowStateRuntimeProxy,
label=_('Documents'),
func=lambda context: context['object'].get_document_count(
user=context['request'].user),
order=99)
menu_facet.bind_links(links=(link_workflow_instance_list, ),
sources=(Document, ))
menu_list_facet.bind_links(
links=(link_acl_list, link_events_for_object,
link_object_event_types_user_subcriptions_list,
link_workflow_template_document_types,
link_workflow_template_state_list,
link_workflow_template_transition_list,
link_workflow_template_preview),
sources=(Workflow, ))
menu_list_facet.unbind_links(
links=(link_acl_list, link_events_for_object,
link_object_event_types_user_subcriptions_list,
link_workflow_template_document_types,
link_workflow_template_state_list,
link_workflow_template_transition_list,
link_workflow_template_preview),
sources=(WorkflowRuntimeProxy, ))
menu_list_facet.bind_links(
links=(link_document_type_workflow_templates, ),
sources=(DocumentType, ))
menu_main.bind_links(links=(link_workflow_runtime_proxy_list, ),
position=10)
menu_object.bind_links(links=(link_workflow_template_delete,
link_workflow_template_edit),
sources=(Workflow, ))
menu_object.bind_links(links=(link_workflow_template_state_edit,
link_workflow_template_state_action_list,
link_workflow_template_state_delete),
sources=(WorkflowState, ))
menu_object.bind_links(
links=(link_workflow_template_transition_edit,
link_workflow_template_transition_events,
link_workflow_template_transition_field_list, link_acl_list,
link_workflow_template_transition_delete),
sources=(WorkflowTransition, ))
menu_object.bind_links(
links=(link_workflow_template_transition_field_delete,
link_workflow_template_transition_field_edit),
sources=(WorkflowTransitionField, ))
menu_object.bind_links(links=(link_workflow_instance_detail,
link_workflow_instance_transition),
sources=(WorkflowInstance, ))
menu_list_facet.bind_links(links=(
link_workflow_runtime_proxy_document_list,
link_workflow_runtime_proxy_state_list,
),
sources=(WorkflowRuntimeProxy, ))
menu_list_facet.bind_links(
links=(link_workflow_runtime_proxy_state_document_list, ),
sources=(WorkflowStateRuntimeProxy, ))
menu_object.bind_links(links=(
link_workflow_template_state_action_edit,
link_object_error_list,
link_workflow_template_state_action_delete,
),
sources=(WorkflowStateAction, ))
menu_secondary.bind_links(
links=(link_workflow_template_list, link_workflow_template_create),
sources=(Workflow, 'document_states:workflow_template_create',
'document_states:workflow_template_list'))
menu_secondary.bind_links(
links=(link_workflow_template_transition_field_create, ),
sources=(WorkflowTransition, ))
menu_secondary.bind_links(links=(link_workflow_runtime_proxy_list, ),
sources=(WorkflowRuntimeProxy, ))
menu_secondary.bind_links(
links=(link_workflow_template_state_action_selection, ),
sources=(WorkflowState, ))
menu_secondary.bind_links(
links=(link_workflow_template_transition_create, ),
sources=(
WorkflowTransition,
'document_states:workflow_template_transition_list',
))
menu_secondary.bind_links(
links=(link_workflow_template_state_create, ),
sources=(
WorkflowState,
'document_states:workflow_template_state_list',
))
menu_setup.bind_links(links=(link_workflow_template_list, ))
menu_tools.bind_links(links=(link_tool_launch_workflows, ))
post_save.connect(dispatch_uid='workflows_handler_launch_workflow',
receiver=handler_launch_workflow,
sender=Document)
# Index updating
post_migrate.connect(
dispatch_uid='workflows_handler_create_workflow_image_cache',
receiver=handler_create_workflow_image_cache,
)
post_save.connect(dispatch_uid='workflows_handler_index_document_save',
receiver=handler_index_document,
sender=WorkflowInstanceLogEntry)
post_save.connect(dispatch_uid='workflows_handler_trigger_transition',
receiver=handler_trigger_transition,
sender=Action)
registry.register(Workflow)
def ready(self):
super(UserManagerConfig, self).ready()
post_migrate.connect(init_user, sender=self)
def ready(self):
import tracker.signals
post_migrate.connect(tracker.signals.create_default_settings, sender=self)
def ready(self):
post_migrate.connect(create_superuser, sender=self)
try:
from django.db.models.signals import post_migrate as db_ready
except ImportError:
from django.db.models.signals import post_syncdb as db_ready
def sync_badges_to_db(**kwargs):
from .utils import registered_badges
for badge in registered_badges.values():
badge.badge
db_ready.connect(sync_badges_to_db)
def ready(self):
post_migrate.connect(pm_callback, sender=self, dispatch_uid='geotrek.core.movetoschemas')
def ready(self):
from .security import Management
post_migrate.connect(Management.init_groups,
sender=self.apps.app_configs["auth"])
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)
checks.register(check_model_name_lengths, checks.Tags.models)
def ready(self):
post_migrate.connect(post_migration_callback, sender=self)
def ready(self):
# Import all required stuff.
# Let all client websocket message register
from ..utils.rest_api import router
from . import serializers # noqa
from .config import config
from .signals import (
autoupdate_for_many_to_many_relations,
cleanup_unused_permissions,
delete_django_app_permissions,
get_permission_change_data,
permission_change,
post_permission_creation,
)
from .views import (
ConfigViewSet,
CountdownViewSet,
ProjectionDefaultViewSet,
ProjectorMessageViewSet,
ProjectorViewSet,
TagViewSet,
)
# Collect all config variables before getting the constants.
config.collect_config_variables_from_apps()
# Connect signals.
post_permission_creation.connect(
delete_django_app_permissions,
dispatch_uid="delete_django_app_permissions")
post_permission_creation.connect(
cleanup_unused_permissions,
dispatch_uid="cleanup_unused_permissions")
permission_change.connect(
get_permission_change_data,
dispatch_uid="core_get_permission_change_data")
post_migrate.connect(manage_config,
sender=self,
dispatch_uid="core_manage_config")
pre_delete.connect(
autoupdate_for_many_to_many_relations,
dispatch_uid="core_autoupdate_for_many_to_many_relations",
)
# Register viewsets.
router.register(
self.get_model("Projector").get_collection_string(),
ProjectorViewSet)
router.register(
self.get_model("Projectiondefault").get_collection_string(),
ProjectionDefaultViewSet,
)
router.register(
self.get_model("Tag").get_collection_string(), TagViewSet)
router.register(
self.get_model("ConfigStore").get_collection_string(),
ConfigViewSet,
"config",
)
router.register(
self.get_model("ProjectorMessage").get_collection_string(),
ProjectorMessageViewSet,
)
router.register(
self.get_model("Countdown").get_collection_string(),
CountdownViewSet)
if "runserver" in sys.argv or "changeconfig" in sys.argv:
from openslides.utils.startup import run_startup_hooks
run_startup_hooks()
def ready(self):
post_migrate.connect(init_default_interfaces, sender=self)
def class_hierarchy(clslist):
"""Recursively yield a class hierarchy"""
for cls in clslist:
subclass_list = cls.__subclasses__()
if subclass_list:
for subcls in class_hierarchy(subclass_list):
yield subcls
else:
yield cls
for cls in class_hierarchy([SharedMemoryModel]):
cls.flush_instance_cache()
# run the python garbage collector
return gc.collect()
#request_finished.connect(flush_cache)
post_migrate.connect(flush_cache)
def flush_cached_instance(sender, instance, **kwargs):
"""
Flush the idmapper cache only for a given instance.
"""
# XXX: Is this the best way to make sure we can flush?
if not hasattr(instance, 'flush_cached_instance'):
return
sender.flush_cached_instance(instance, force=True)
pre_delete.connect(flush_cached_instance)
def update_cached_instance(sender, instance, **kwargs):
def ready(self):
# type: () -> None
import zerver.signals
if settings.POST_MIGRATION_CACHE_FLUSHING:
post_migrate.connect(flush_cache, sender=self)
def ready(self):
import account.signals as ss
post_migrate.connect(
ss.create_admin,
sender=self
)
def ready(self):
post_migrate.connect(update_admin_index, sender=self)
