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 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_tests() _patch_atomic() _patch_orm_write() _patch_orm_read() PATCHED = True
load_sql_files(app_label) def check_srid_has_meter_unit(sender, **kwargs): if not hasattr(check_srid_has_meter_unit, '_checked'): cursor = connection.cursor() cursor.execute(""" SELECT * FROM spatial_ref_sys WHERE srtext ILIKE '%%meter%%' AND srid=%s;""", [settings.SRID]) results = cursor.fetchall() if len(results) == 0: err_msg = 'Unit of SRID EPSG:%s is not meter.' % settings.SRID raise ImproperlyConfigured(err_msg) check_srid_has_meter_unit._checked = True if settings.TEST and not settings.SOUTH_TESTS_MIGRATE: pre_syncdb.connect(check_srid_has_meter_unit, dispatch_uid="geotrek.core.checksrid") post_syncdb.connect(run_initial_sql_post_syncdb, dispatch_uid="geotrek.core.sqlautoload") # During tests, the signal is received twice unfortunately # https://code.djangoproject.com/ticket/17977 else: pre_migrate.connect(check_srid_has_meter_unit, dispatch_uid="geotrek.core.checksrid") post_migrate.connect(run_initial_sql_post_migrate, dispatch_uid="geotrek.core.sqlautoload") """ Computed client-side setting. """ settings.LEAFLET_CONFIG['SPATIAL_EXTENT'] = api_bbox(settings.SPATIAL_EXTENT, buffer=0.5)
from south import migration from south.signals import post_migrate from boris import reporting # Get a list of all the apps that use migrations. APPS_TO_WAIT_FOR = map(methodcaller('app_label'), migration.all_migrations()) def install_views(app, **kwargs): global APPS_TO_WAIT_FOR APPS_TO_WAIT_FOR.remove(app) if len(APPS_TO_WAIT_FOR) == 0: print "Installing reporting views ..." cursor = connection.cursor() sql_file = open( join(dirname(reporting.__file__), 'sql', 'reporting-views.mysql.sql'), 'r') try: cursor.execute(sql_file.read()) finally: sql_file.close() post_migrate.connect(install_views)
from south.signals import post_migrate def update_permissions(**kwargs): import sys sys.stdout.write("If there are new content types or permissions added, remember to run-> labgeeks update_permissions\n\n") post_migrate.connect(update_permissions)
# # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # from django.conf import settings def create_permissions_compat(app, **kwargs): ''' Creates permissions like syncdb would if we were not using South See http://south.aeracode.org/ticket/211 ''' # This fails with Django 1.7, but the code is used only for 1.6 # pylint: disable=E0611 from django.db.models import get_app, get_models from django.contrib.auth.management import create_permissions if app in ('trans', 'lang', 'accounts'): try: create_permissions(get_app(app), get_models(), 2 if settings.DEBUG else 0) except AttributeError as error: # See https://code.djangoproject.com/ticket/20442 print 'Failed to create permission objects: {0}'.format(error) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(create_permissions_compat)
# -*- coding: utf-8 -*- from __future__ import unicode_literals from south.signals import post_migrate def update_permissions_after_migration(app, **kwargs): """ Update app permission just after every migration. This is based on the django_extensions' update_permissions management command. """ from django.db.models import get_app, get_models from django.contrib.auth.management import create_permissions create_permissions(get_app(app), get_models(), 2) post_migrate.connect(update_permissions_after_migration)
def create_admin_group(app, **kwargs): """\ Create a basic admin group with permissions for managing basic autotest objects. """ print "Creatin/updating Basic admin group" admin_group, created = auth.models.Group.objects.get_or_create( name=BASIC_ADMIN) admin_group.save() # must save before adding permissions PermissionModel = auth.models.Permission have_permissions = list(admin_group.permissions.all()) for model_name in ('host', 'label', 'test', 'aclgroup', 'profiler', 'atomicgroup'): for permission_type in ('add', 'change', 'delete'): codename = permission_type + '_' + model_name permissions = list(PermissionModel.objects.filter( codename=codename)) if len(permissions) == 0: print ' No permission ' + codename continue for permission in permissions: if permission not in have_permissions: print ' Adding permission ' + codename admin_group.permissions.add(permission) if created: print 'Created group "%s"' % BASIC_ADMIN else: print 'Group "%s" already exists' % BASIC_ADMIN post_migrate.connect(create_admin_group)
continue role.save() role.permission_flags.add(permissionflag) role.save() if verbosity >= 2: print "Created new role '%s' for group '%s' and assigned permission '%s'" % (rolename, group.name, permissionflag.name) # handle both post_syncdb and post_migrate (if south is used) def syncdb_compat(app_label, handler=None, *args, **kwargs): if app_label=='community': app = get_app(app_label) models = get_models(app) handler(app=app, created_models=models, verbosity=1, **kwargs) def syncdb_compat_init_data(app, *args, **kwargs): syncdb_compat(app, handler=init_data, *args, **kwargs) def syncdb_compat_create_permission_flags(app, *args, **kwargs): syncdb_compat(app, handler=create_permission_flags, *args, **kwargs) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(syncdb_compat_init_data, dispatch_uid="communitytools.sphenecoll.sphene.community.management") post_migrate.connect(syncdb_compat_create_permission_flags) else: from django.db.models.signals import post_syncdb post_syncdb.connect(init_data, sender=models, dispatch_uid="communitytools.sphenecoll.sphene.community.management") post_syncdb.connect(create_permission_flags)
def create_permission(codename, description): permission_content_type = ContentType.objects.get( app_label='auth', name='permission') permission, created = Permission.objects.get_or_create( codename=codename, name=description, content_type=permission_content_type) return permission def init_user_group(app, **kwargs): print 'init user group' if app != 'w3af_webui': return create_superuser() create_permission('view_all_data', 'Can use other user`s objects') view_stat = create_permission('view_stats', 'Can use statistic reports') # user groups for user_group in settings.USER_GROUPS: group_name = user_group['name'] group, created = Group.objects.get_or_create(name=group_name) group.permissions.clear() for codename in user_group['permissions']: permission = Permission.objects.get(codename=codename) group.permissions.add(permission) group.save() post_migrate.connect(init_user_group)
# Table is typically appname_modelname, but it could be different # always best to be sure. mdl = models.get_model(app_name, model_name) fld = "%s.%s.%s" % (app_name, model_name, field_name) if isinstance(field_registry[fld], CategoryFKField): print "Dropping ForeignKey %s from %s" % (field_name, model_name) try: db.start_transaction() table_name = mdl._meta.db_table db.delete_column(table_name, field_name) db.commit_transaction() except DatabaseError, e: db.rollback_transaction() raise e elif isinstance(field_registry[fld], CategoryM2MField): print "Dropping Many2Many table between %s and %s" % (model_name, 'category') table_name = "%s_%s" % (mdl._meta.db_table, 'categories') try: db.start_transaction() db.delete_table(table_name, cascade=False) db.commit_transaction() except DatabaseError, e: db.rollback_transaction() raise e post_migrate.connect(migrate_app)
def create_default_states_handler(sender, instance, **kwargs): created = kwargs.pop('created', False) if created and instance.is_empty(): populate_workflow(instance) def populate_initial_workflow_handler(sender, **kwargs): app = kwargs['app'] if app == 'workflow': try: workflow = Workflow.objects.default_workflow() if not workflow.states.all().exists(): # never has been populated populate_workflow(workflow) except Workflow.DoesNotExist: pass # maybe has been deleted elif app == 'base': from merengue.base.models import BaseContent try: workflow = Workflow.objects.default_workflow() if not WorkflowModelRelation.objects.filter(workflow=workflow).exists(): content_type = ContentType.objects.get_for_model(BaseContent) WorkflowModelRelation.objects.create( content_type=content_type, workflow=workflow, ) except Workflow.DoesNotExist: pass # maybe has been deleted post_migrate.connect(populate_initial_workflow_handler) post_save.connect(create_default_states_handler, sender=Workflow)
from south.signals import post_migrate def _migrate_perms(*args, **kwargs): """ Ensure that all declared permissions on a model have been installed once South migrations have been run. """ import sys from django.contrib.auth.models import Permission from django.contrib.contenttypes.models import ContentType from django.db.models import get_app, get_models for model in get_models(get_app(kwargs['app'])): content_type = ContentType.objects.get_for_model(model) for codename, name in model._meta.permissions: perm, created = Permission.objects.get_or_create( content_type=content_type, codename=codename, defaults={'name': name}) if created: sys.stdout.write( "Installed new permission {app_label}.{codename}\n".format( app_label=model._meta.app_label, codename=codename)) post_migrate.connect(_migrate_perms)
user.social_auth.all().delete() @receiver(post_syncdb) def sync_create_groups(sender, app, **kwargs): ''' Create groups on syncdb. ''' if (app == 'accounts' or getattr(app, '__name__', '') == 'weblate.accounts.models'): create_groups(False) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(sync_create_groups) @receiver(post_save, sender=User) def create_profile_callback(sender, instance, created=False, **kwargs): ''' Automatically adds user to Users group. ''' if created: # Add user to Users group if it exists try: group = Group.objects.get(name='Users') instance.groups.add(group) except Group.DoesNotExist: pass
fsusers_group = auth.models.Group.objects.create( name="filesystem_users") # For modifying his own account grant_write(fsusers_group, django.contrib.auth.models.User) if settings.DEBUG and auth.models.User.objects.count() == 0: print("***\n" * 3), print( "*** SECURITY WARNING: You are running in DEBUG mode and default users have been created" ) print("***\n" * 3) user = auth.models.User.objects.create_superuser( "admin", "*****@*****.**", "lustre") user.groups.add(auth.models.Group.objects.get(name="superusers")) user = auth.models.User.objects.create_user("debug", "*****@*****.**", "lustre") user.groups.add( auth.models.Group.objects.get(name="filesystem_administrators")) user = auth.models.User.objects.create_user("user", "*****@*****.**", "lustre") user.groups.add(auth.models.Group.objects.get(name="filesystem_users")) # Ensure that the auto post_syncdb hook is installed # before our hook, so that Permission objects will be there # by the time we are called. import django.contrib.auth.management post_migrate.connect(setup_groups)
# Thi gives us a clean slate. ui.reset() ui.setup_indexes() models.signals.pre_save.connect(load_indexes, dispatch_uid='setup_index_signals') models.signals.pre_delete.connect(load_indexes, dispatch_uid='setup_index_signals') if 'south' in settings.INSTALLED_APPS: # South causes a little mayhem, as when you run a ``syncdb``, it'll setup # the apps *without* migrations using Django's built-in ``syncdb``. When # this happens, ``INSTALLED_APPS`` consists of only those apps, NOT all # apps.At the end of that sync, Django runs ``create_permissions``, which # of course uses the ORM, causing the ``pre_save`` above to fire. # The effect is that Haystack runs its setup against the then-subset of # ``INSTALLED_APPS``. Once that's done, it won't re-setup the # ``UnifiedIndex`` again, since the signal has a ``dispatch_uid``. # This bug gets exposed only either when people run tests that *use* # the South migrations OR when they have a data migration & the changed # data isn't picked up by ``RealTimeSearchIndex`` (or similar). # In the event of this, the only safe route is to listen for # ``south.signals.post_migrate``, then re-run setup. This will # unfortunately happen per-app, but should be quick & reliable. from south.signals import post_migrate post_migrate.connect(reload_indexes)
auth = resource._meta.authorization content_type = ContentType.objects.get_for_model(resource._meta.queryset.model) if isinstance(auth, SpiffAuthorization): conditions = auth.conditions() operations = auth.operations() if len(conditions) == 0: conditions = (None,) for condition in conditions: for operation in operations: # build our permission slug if condition: codename = "%s_%s_%s" % (operation[0], condition[0], content_type.model) name = "Can %s %s, when %s" % (operation[1], content_type.name, condition[1]) else: codename = "%s_%s" % (operation[1], content_type.model) name = "Can %s %s" % (operation[1], content_type.name) # 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=name[:49]) funcLog().debug("Created permission %s.%s (%s)", content_type.app_label, codename, name) # check for all our view permissions after a syncdb post_migrate.connect(add_resource_permissions) post_syncdb.connect(add_resource_permissions)
def _migrate_perms(*args, **kwargs): """ Ensure that all declared permissions on a model have been installed once South migrations have been run. """ import sys from django.contrib.auth.models import Permission from django.contrib.contenttypes.models import ContentType from django.db.models import get_app, get_models for model in get_models(get_app(kwargs['app'])): content_type = ContentType.objects.get_for_model(model) for codename, name in model._meta.permissions: perm, created = Permission.objects.get_or_create( content_type=content_type, codename=codename, defaults={ 'name': name } ) if created: sys.stdout.write( "Installed new permission {app_label}.{codename}\n".format( app_label=model._meta.app_label, codename=codename ) ) post_migrate.connect(_migrate_perms)
from django.db import connection from south import migration from south.signals import post_migrate from boris import reporting # Get a list of all the apps that use migrations. APPS_TO_WAIT_FOR = map(methodcaller('app_label'), migration.all_migrations()) def install_views(app, **kwargs): global APPS_TO_WAIT_FOR APPS_TO_WAIT_FOR.remove(app) if len(APPS_TO_WAIT_FOR) == 0: print "Installing reporting views ..." cursor = connection.cursor() sql_file = open(join(dirname(reporting.__file__), 'sql', 'reporting-views.mysql.sql'), 'r') try: cursor.execute(sql_file.read()) finally: sql_file.close() post_migrate.connect(install_views)
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): from django.db.models import get_app from django.contrib.auth.management import create_permissions create_permissions(get_app(app), (), 0) post_migrate.connect(create_permissions_compat) except ImportError: from django.db.models.signals import pre_syncdb def import_flows(sender, **kwargs): """Pre-import flows to allow permissions auto-creation.""" try: __import__('{}.flows'.format(sender.__package__)) except ImportError: pass pre_syncdb.connect(import_flows, dispatch_uid="viewflow.management.import_flows")
callback = models.TextField() def __unicode__(self): return "Achievement(%s, %s)" % (self.name, self.bonus) class UserAchievement(models.Model): user = models.ForeignKey(User) achievement = models.ForeignKey(Achievement, related_name="userachievements") registered_at = models.DateTimeField(auto_now_add=True) class AchievementEngineConf(AppConf): """ Configuration class used by Django AppConf to ease the setup""" USE_CELERY = False CLASSES = [] class Meta: prefix = 'achievement' #def configure_classes(self, value): # pass # connect to the end of the syncdb command signal to reload achievements at that time. if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(load_classes) else: from django.db.models.signals import post_syncdb post_syncdb.connect(load_classes)
# register a signal do update permissions every migration. # This is based on app django_extensions update_permissions command from south.signals import post_migrate def update_permissions_after_migration(app,**kwargs): """ Update app permission just after every migration. This is based on app django_extensions update_permissions management command. """ import settings from django.db.models import get_app, get_models from django.contrib.auth.management import create_permissions create_permissions(get_app(app), get_models(), 2 if settings.DEBUG else 0) post_migrate.connect(update_permissions_after_migration)
password='', first_name='Guest', last_name='McGuesterson', ) user.set_unusable_password() user.save() member = Member.objects.get(user=user) member.hidden = True member.save() else: user = User.objects.get(id=settings.ANONYMOUS_USER_ID) try: member = user.member except Member.DoesNotExist: user.member, created = Member.objects.get_or_create(user=user) user.save() return user post_save.connect(create_member, sender=AnonymousUser) post_save.connect(create_rank, sender=AuthenticatedUserGroup) def ensure_auth_objects(*args, **kwargs): try: get_anonymous_user() get_authenticated_user_group() except: pass post_migrate.connect(ensure_auth_objects) post_syncdb.connect(ensure_auth_objects)
perm, created = Permission.objects.get_or_create(codename='can_view', name='Can View Users', content_type=ct) group, created = Group.objects.get_or_create(name='Volunteer') if created: p = Permission.objects.get(codename='add_userevent') group.permissions.add(p) group, created = Group.objects.get_or_create(name='Org_Admin') if created: p = Permission.objects.get(codename='add_organization') group.permissions.add(p) group, created = Group.objects.get_or_create(name='NHS_Admin') if created: p = Permission.objects.get(codename='can_view') group.permissions.add(p) if not SiteSettings.objects.exists(): settings = SiteSettings(site=Site.objects.get(pk=1), candidate_leadership_hours=50, candidate_service_hours=100, member_service_hours=6).save() def create_userprof(sender, instance, created, **kwargs): """for when the user is created on the first syncdb""" if created and instance.is_superuser: try: up = instance.user_profile except ObjectDoesNotExist: UserProfile(user=instance, email_valid=True, grad_class=2000, membership_status='MEM').save() #post_migrate.connect(add_user_permissions, sender=auth_models) post_migrate.connect(add_groups) post_save.connect(create_userprof, sender=User, dispatch_uid="create_userprof")
# coding:utf-8 from django.contrib.contenttypes.models import ContentType from django.db.models import signals from django.utils.encoding import smart_unicode from django.conf import settings def update_contenttypes(app, **kwargs): #No post_syncdb o app é um object, já no post_migrate é uma string if not isinstance(app, str): app = app.__name__.split('.')[-2] for ct in ContentType.objects.filter(app_label=app): try: name = smart_unicode(ct.model_class()._meta.verbose_name_raw) if ct.name != name: print "Updating ContentType's name: '%s' -> '%s'" % (ct.name, name) ct.name=name ct.save() except: pass # Se tiver a aplicação south no INSTALLED_APPS, # ele conecta o update_contenttypes ao post_migrate if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(update_contenttypes) signals.post_syncdb.connect(update_contenttypes)
result = cursor.fetchone() if not result[0]: # Create View sql = model.create_sql() cursor.execute(*sql) if issubclass(model, MatView): sql = MatView.storedproc_check() expected_resp = sql[2] sql = sql[:2] cursor.execute(*sql) res = cursor.fetchall() if res[0][0] != expected_resp: for sql in MatView.storedproc_sql(): cursor.execute(sql, ()) func = model.create_matview() try: cursor.execute(*func) transaction.commit() except DatabaseError as e: if e.message.startswith('MatView') and e.message.find('already exists') != -1: transaction.rollback() else: raise signals.post_syncdb.connect(create_views) try: from south.signals import post_migrate post_migrate.connect(create_views) except ImportError: pass
if os.path.isfile(theme_info_file): config = ConfigParser.ConfigParser() config.read(theme_info_file) default = ConfigParser.DEFAULTSECT theme_name = config.get(default, 'name', self.directory_name) theme_description = config.get(default, 'description', '') else: theme_name = self.directory_name theme_description = '' self.name = theme_name self.description = theme_description if commit: self.save() def post_save_handler(sender, instance, **kwargs): if instance.active: for theme in Theme.objects.filter(active=True).exclude(id=instance.id): theme.active = False theme.save() Theme.objects.clear_cache() def check_for_themes(sender, **kwargs): from merengue.theming.checker import check_themes check_themes() signals.post_save.connect(post_save_handler, sender=Theme) post_migrate.connect(check_for_themes)
def create_permission(codename, description): permission_content_type = ContentType.objects.get(app_label='auth', name='permission') permission, created = Permission.objects.get_or_create( codename=codename, name=description, content_type=permission_content_type) return permission def init_user_group(app, **kwargs): print 'init user group' if app != 'w3af_webui': return create_superuser() create_permission('view_all_data', 'Can use other user`s objects') view_stat = create_permission('view_stats', 'Can use statistic reports') # user groups for user_group in settings.USER_GROUPS: group_name = user_group['name'] group, created = Group.objects.get_or_create(name=group_name) group.permissions.clear() for codename in user_group['permissions']: permission = Permission.objects.get(codename=codename) group.permissions.add(permission) group.save() post_migrate.connect(init_user_group)
try: from management.commands.discipline_migrate import Command from south.signals import post_migrate def command(app, *args, **kwargs): print "Discipline detected a South migration, it will now save the new" \ " schema state automatically." Command().handle() # Every time a user performs a South migration, Discipline should # perform a migration of its own, this is in case the user forgets # to run "manage.py pervert_migrate" post_migrate.connect(command) except ImportError: pass __version__ = "0.9.1"
# référence. cursor = db.connection.cursor() cursor.execute( """ SELECT c.CONSTRAINT_SCHEMA, c.TABLE_NAME, c.CONSTRAINT_NAME FROM information_schema.REFERENTIAL_CONSTRAINTS c INNER JOIN information_schema.VIEWS v ON v.TABLE_SCHEMA = c.CONSTRAINT_SCHEMA AND v.TABLE_NAME = c.REFERENCED_TABLE_NAME WHERE c.REFERENCED_TABLE_NAME LIKE 'ref\\_%%' """ ) for schema, table, constraint in cursor: if verbosity > 0: print "Suppression de la contrainte %s sur la table %s.%s..." % ( constraint, schema, table ) db.connection.cursor().execute( 'ALTER TABLE `%s`.`%s` DROP FOREIGN KEY `%s`' % (schema, table, constraint) ) # Supprimer les clés étrangères aussi après un migrate try: from south.signals import post_migrate except ImportError: pass else: post_migrate.connect(supprimer_cles_etrangeres)
sync_docs.copy_designs( db=self.db(app_label), design_name=app_label, temp=temp, delete=delete, ) def get_preindex_plugins(): return PREINDEX_PLUGINS.values() def catch_signal(app, **kwargs): """Function used by syncdb signal""" app_name = app.__name__.rsplit('.', 1)[0] app_label = app_name.split('.')[-1] if app_label in PREINDEX_PLUGINS: PREINDEX_PLUGINS[app_label].sync_design_docs() signals.post_syncdb.connect(catch_signal) # and totally unrelatedly... def sync_south_app(app, **kwargs): syncdb(get_app(app), None, **kwargs) post_migrate.connect(sync_south_app)
for plugin_dir in settings.REQUIRED_PLUGINS: active_plugin_with_deps(plugin_dir) # populate menu from merengue.section.models import Menu name_attr = get_fallback_fieldname('name') attrs = {name_attr: 'Portal menu', 'slug': settings.MENU_PORTAL_SLUG} try: portal_menu = Menu.objects.get(slug=settings.MENU_PORTAL_SLUG) except Menu.DoesNotExist: # creating portal menu if does not exist portal_menu = Menu.objects.create(**attrs) for lang_code, lang_text in settings.LANGUAGES: setattr(portal_menu, 'name_%s' % lang_code, ugettext('portal menu')) portal_menu.save() def active_plugin_with_deps(plugin_dir): """ active plugins with its dependences """ from merengue.pluggable.utils import install_plugin registered_plugin = register_plugin(plugin_dir) plugin = registered_plugin.get_registry_item() for dep in getattr(plugin, 'required_plugins', []): active_plugin_with_deps(dep) registered_plugin.installed = True registered_plugin.active = True registered_plugin.save() install_plugin(registered_plugin) post_migrate.connect(active_default_plugins)
try: thread_info = ThreadInformation.objects.type_default().filter( root_post=thread).get() except ThreadInformation.DoesNotExist: thread_info = ThreadInformation(root_post=thread, category=thread.category, thread_type=THREAD_TYPE_DEFAULT) thread_info.update_cache() thread_info.save() # handle both post_syncdb and post_migrate (if south is used) def syncdb_compat(app_label, handler=None, *args, **kwargs): if app_label == 'sphboard': app = get_app(app_label) models = get_models(app) handler(app=app, created_models=models, verbosity=1, **kwargs) def syncdb_compat_init_data(app, *args, **kwargs): syncdb_compat(app, handler=init_data, *args, **kwargs) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(syncdb_compat_init_data) else: from django.db.models.signals import post_syncdb post_syncdb.connect(init_data, sender=models)
import forum.models def install_pg_fts(**kwargs): f = open(os.path.join(os.path.dirname(__file__), 'pg_fts_install.sql'), 'r') try: cursor = connection.cursor() cursor.execute(f.read()) transaction.commit_unless_managed() except: pass finally: cursor.close() f.close() if settings.DATABASE_ENGINE in ( 'postgresql_psycopg2', 'postgresql', ): from django.db.models.signals import post_syncdb post_syncdb.connect(install_pg_fts, sender=forum.models, weak=False) try: from south.signals import post_migrate post_migrate.connect(install_pg_fts, weak=False) except: pass
UserProfile.objects.create(user=instance) except DatabaseError: # Creating fresh db from manage.py pass post_save.connect(create_user_profile, sender=User) def user_login_changed(sender, instance=None, reverse=None, model=None, action=None, **kwargs): if action[:4] == 'pre_': return login = model if reverse else instance login.is_dirty = True login.save() m2m_changed.connect(user_login_changed, sender=Login.users.through) def force_one_app_key(app, **kwargs): if app == 'ssheepdog': ApplicationKey.get_latest() post_migrate.connect(force_one_app_key)
# License, or (at your option) any later version. # # Freesound is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # Authors: # See AUTHORS file. # from accounts import models as auth_models from django.contrib.auth.models import User from accounts.models import Profile from south.signals import post_migrate import logging logger = logging.getLogger("web") def create_super_profile(**kwargs): for user in User.objects.filter(profile=None): # create profiles for all users that don't have profiles yet logger.info("\tcreating profile for super user: %s", user) profile = Profile(user=user) profile.save() post_migrate.connect(create_super_profile, sender=auth_models)
""" name = app or sender.name if South and not name == 'notifier': return for installed_app in settings.INSTALLED_APPS: try: import_module(installed_app + '.' + notifier_settings.AUTO_CREATE_MODULE_NAME) except ImportError: pass if South: post_migrate.connect(create_backends, dispatch_uid="notifier.management.create_backends") post_migrate.connect( create_notifications, dispatch_uid="notifier.management.create_notifications", ) else: post_syncdb.connect(create_backends, dispatch_uid="notifier.management.create_backends", sender=notifier.models) post_syncdb.connect( create_notifications, dispatch_uid="notifier.management.create_notifications", sender=notifier.models)
if not hasattr(check_srid_has_meter_unit, '_checked'): cursor = connection.cursor() cursor.execute( """ SELECT * FROM spatial_ref_sys WHERE srtext ILIKE '%%meter%%' AND srid=%s;""", [settings.SRID]) results = cursor.fetchall() if len(results) == 0: err_msg = 'Unit of SRID EPSG:%s is not meter.' % settings.SRID raise ImproperlyConfigured(err_msg) check_srid_has_meter_unit._checked = True if settings.TEST and not settings.SOUTH_TESTS_MIGRATE: pre_syncdb.connect(check_srid_has_meter_unit, dispatch_uid="geotrek.core.checksrid") post_syncdb.connect(run_initial_sql_post_syncdb, dispatch_uid="geotrek.core.sqlautoload") # During tests, the signal is received twice unfortunately # https://code.djangoproject.com/ticket/17977 else: pre_migrate.connect(check_srid_has_meter_unit, dispatch_uid="geotrek.core.checksrid") post_migrate.connect(run_initial_sql_post_migrate, dispatch_uid="geotrek.core.sqlautoload") """ Computed client-side setting. """ settings.LEAFLET_CONFIG['SPATIAL_EXTENT'] = api_bbox( settings.SPATIAL_EXTENT, buffer=settings.VIEWPORT_MARGIN)
return [ DesignInfo(app_label=app_label, db=self.db(app_label), design_path=os.path.join(self.dir, app_label)) for app_label in self.get_couchapps() ] def get_preindex_plugins(): return PREINDEX_PLUGINS.values() def catch_signal(app, **kwargs): """Function used by syncdb signal""" app_name = app.__name__.rsplit('.', 1)[0] app_label = app_name.split('.')[-1] if app_label in PREINDEX_PLUGINS: PREINDEX_PLUGINS[app_label].sync_design_docs() signals.post_syncdb.connect(catch_signal) # and totally unrelatedly... def sync_south_app(app, **kwargs): syncdb(get_app(app), None, **kwargs) post_migrate.connect(sync_south_app)
# Remove all social auth associations user.social_auth.all().delete() @receiver(post_syncdb) def sync_create_groups(sender, app, **kwargs): ''' Create groups on syncdb. ''' if (app == 'accounts' or getattr(app, '__name__', '') == 'weblate.accounts.models'): create_groups(False) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(sync_create_groups) @receiver(post_save, sender=User) def create_profile_callback(sender, instance, created=False, **kwargs): ''' Automatically adds user to Users group. ''' if created: # Add user to Users group if it exists try: group = Group.objects.get(name='Users') instance.groups.add(group) except Group.DoesNotExist: pass
_('Event Added'), _('An event has been added')) notification.create_notice_type( 'event_edited', _('Event Edited'), _('An event has been edited')) notification.create_notice_type( 'event_deleted', _('Event Deleted'), _('An event has been deleted')) notification.create_notice_type( 'event_registration_confirmation', _('Event Registration Confirmation'), _('The email you receive confirming your registration')) notification.create_notice_type( 'event_registration_cancelled', _('Event Registration Cancelled'), _('Notify administrators that someone has cancelled their event registration')) notification.create_notice_type( 'event_registration_end_recap', _('Recap of end of event registration'), _('Notify administrators that registration for the event has ended.')) post_syncdb.connect(create_notice_types, sender=notification) post_migrate.connect(create_notice_types, sender=notification)
# coding: utf-8 from south.signals import post_migrate, pre_migrate from new_django_project._lib.db import load_customized_sql pre_migrate.connect(load_customized_sql(name='pre_migrate'), weak=False) post_migrate.connect(load_customized_sql(name='post_migrate'), weak=False)
from operator import methodcaller from django.core.management import call_command from south.signals import post_migrate from south import migration # Get a list of all the apps that use migrations. APPS_TO_WAIT_FOR = map(methodcaller('app_label'), migration.all_migrations()) def load_static_data(app, **kwargs): global APPS_TO_WAIT_FOR APPS_TO_WAIT_FOR.remove(app) if len(APPS_TO_WAIT_FOR) == 0: print "Loading static fixtures..." call_command('loaddata', 'groups') post_migrate.connect(load_static_data)
# Note: Unlike above, we're resetting the ``UnifiedIndex`` here. # Thi gives us a clean slate. ui.reset() ui.setup_indexes() models.signals.pre_save.connect(load_indexes, dispatch_uid='setup_index_signals') models.signals.pre_delete.connect(load_indexes, dispatch_uid='setup_index_signals') if 'south' in settings.INSTALLED_APPS: # South causes a little mayhem, as when you run a ``syncdb``, it'll setup # the apps *without* migrations using Django's built-in ``syncdb``. When # this happens, ``INSTALLED_APPS`` consists of only those apps, NOT all # apps.At the end of that sync, Django runs ``create_permissions``, which # of course uses the ORM, causing the ``pre_save`` above to fire. # The effect is that Haystack runs its setup against the then-subset of # ``INSTALLED_APPS``. Once that's done, it won't re-setup the # ``UnifiedIndex`` again, since the signal has a ``dispatch_uid``. # This bug gets exposed only either when people run tests that *use* # the South migrations OR when they have a data migration & the changed # data isn't picked up by ``RealTimeSearchIndex`` (or similar). # In the event of this, the only safe route is to listen for # ``south.signals.post_migrate``, then re-run setup. This will # unfortunately happen per-app, but should be quick & reliable. from south.signals import post_migrate post_migrate.connect(reload_indexes)
# coding:utf-8 from django.contrib.contenttypes.models import ContentType from django.db.models import signals from django.utils.encoding import smart_unicode from django.conf import settings def update_contenttypes(app, **kwargs): #No post_syncdb o app é um object, já no post_migrate é uma string if not isinstance(app, str): app = app.__name__.split('.')[-2] for ct in ContentType.objects.filter(app_label=app): try: name = smart_unicode(ct.model_class()._meta.verbose_name_raw) if ct.name != name: print "Updating ContentType's name: '%s' -> '%s'" % (ct.name, name) ct.name = name ct.save() except: pass # Se tiver a aplicação south no INSTALLED_APPS, # ele conecta o update_contenttypes ao post_migrate if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(update_contenttypes) signals.post_syncdb.connect(update_contenttypes)
return errors @receiver(post_syncdb) def setup_lang(sender, app, **kwargs): ''' Hook for creating basic set of languages on database migration. ''' if app == 'lang' or getattr(app, '__name__', '') == 'weblate.lang.models': with transaction.atomic(): Language.objects.setup(False) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(setup_lang) class Language(models.Model, PercentMixin): PLURAL_CHOICES = ( (data.PLURAL_NONE, 'None'), (data.PLURAL_ONE_OTHER, 'One/other (classic plural)'), (data.PLURAL_ONE_FEW_OTHER, 'One/few/other (Slavic languages)'), (data.PLURAL_ARABIC, 'Arabic languages'), (data.PLURAL_ZERO_ONE_OTHER, 'Zero/one/other'), (data.PLURAL_ONE_TWO_OTHER, 'One/two/other'), (data.PLURAL_ONE_TWO_FEW_OTHER, 'One/two/few/other'), (data.PLURAL_ONE_TWO_THREE_OTHER, 'One/two/three/other'), (data.PLURAL_ONE_OTHER_ZERO, 'One/other/zero'), (data.PLURAL_ONE_FEW_MANY_OTHER, 'One/few/many/other'), (data.PLURAL_TWO_OTHER, 'Two/other'),
return errors @receiver(post_syncdb) def setup_lang(sender, app, **kwargs): ''' Hook for creating basic set of languages on database migration. ''' if app == 'lang' or getattr(app, '__name__', '') == 'weblate.lang.models': with transaction.atomic(): Language.objects.setup(False) if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(setup_lang) class Language(models.Model, PercentMixin): PLURAL_CHOICES = ( (data.PLURAL_NONE, 'None'), (data.PLURAL_ONE_OTHER, 'One/other (classic plural)'), (data.PLURAL_ONE_FEW_OTHER, 'One/few/other (Slavic languages)'), (data.PLURAL_ARABIC, 'Arabic languages'), (data.PLURAL_ZERO_ONE_OTHER, 'Zero/one/other'), (data.PLURAL_ONE_TWO_OTHER, 'One/two/other'), (data.PLURAL_ONE_TWO_FEW_OTHER, 'One/two/few/other'), (data.PLURAL_ONE_TWO_THREE_OTHER, 'One/two/three/other'), (data.PLURAL_ONE_OTHER_ZERO, 'One/other/zero'), (data.PLURAL_ONE_FEW_MANY_OTHER, 'One/few/many/other'), (data.PLURAL_TWO_OTHER, 'Two/other'),
from operator import methodcaller from django.core.management import call_command from south.signals import post_migrate from south import migration # Get a list of all the apps that use migrations. APPS_TO_WAIT_FOR = map(methodcaller('app_label'), migration.all_migrations()) def load_static_data(app, **kwargs): global APPS_TO_WAIT_FOR APPS_TO_WAIT_FOR.remove(app) if len(APPS_TO_WAIT_FOR) == 0: print "Loading static fixtures..." call_command('loaddata', 'groups') post_migrate.connect(load_static_data)
from django.contrib.contenttypes.models import ContentType from south.signals import post_migrate from .models import SignalProcessor def object_listener(sender, **kwargs): if sender is SignalProcessor or kwargs.get('raw', False): return action = 'D' if not 'created' in kwargs else 'C' if kwargs[ 'created'] else 'U' try: ct = ContentType.objects.get_for_model(sender) SignalProcessor(app_name=ct.app_label, model_name=ct.model, action=action, object_pk=kwargs['instance'].pk).save() except DatabaseError: pass pass def load_fixtures(sender, **kwargs): from django.core.management import call_command call_command("loaddata", "initial_data.json") post_save.connect(object_listener) post_delete.connect(object_listener) post_migrate.connect(load_fixtures)
def modelLibrary(self): if self._modelLibrary is None: self._modelLibrary = self.buildModelLibrary() return self._modelLibrary library = StoredProcedureLibary() def registerProcedure(procedure): """Registers a procedure with the libary.""" library.registerProcedure(procedure) def resetProcedures(verbosity = 2): """Resets all procedures registered with the library in the database.""" library.resetProcedures(verbosity) def reset(sender, **kwargs): resetProcedures(1) # Connect to syncdb # post_syncdb.connect(reset) # Connect to south's handler try: from south.signals import post_migrate post_migrate.connect(reset) except ImportError: pass
from south.signals import post_migrate from django.db import connection from tendenci.core.site_settings.models import Setting from tendenci.apps.entities.models import Entity from tendenci.core.site_settings.utils import get_setting def create_default_entity(sender, app, **kwargs): """ Auto-create an entity with id=1 if none exist. """ if app == "entities": if not Entity.objects.filter(pk=1): site_name = "Default" table_exists = Setting._meta.db_table in \ connection.introspection.table_names() if table_exists and get_setting("site", "global", "sitedisplayname"): site_name = get_setting("site", "global", "sitedisplayname") entity = Entity() entity.allow_anonymous_view = False entity.entity_name = site_name entity.id = 1 entity.save() post_migrate.connect(create_default_entity)
chroma_core = os.path.abspath(os.path.dirname(chroma_core.__file__)) with open(os.path.join(chroma_core, "fixtures/default_power_types.json")) as f: default_types = json.load(f) for power_type in default_types: try: PowerControlType.objects.get(agent = power_type['agent'], make = power_type['make'], model = power_type['model']) except PowerControlType.DoesNotExist: PowerControlType.objects.create(**power_type) print "Loaded %d default power device types." % len(default_types) post_migrate.connect(create_default_power_types) @receiver(pre_delete, sender = PowerControlType) def delete_power_control_units(sender, instance, **kwargs): [d.mark_deleted() for d in instance.instances.all()] class PowerControlDeviceUnavailableAlert(AlertStateBase): # This is WARNING because if a power control device is out # of touch it may be behaving in an undefined way, therefore # may be unable to participate in a failover operation, resulting # in a reduced level of filesystem availability. default_severity = logging.WARNING class Meta:
def base_content_pre_save_handler(sender, instance, **kwargs): if isinstance(instance, BaseContent) and not instance.id: calculate_class_name(instance) def update_permission_handler(sender, instance, created, **kwargs): if Base in instance.__class__.mro(): instance.populate_workflow_status() signals.pre_save.connect(base_content_pre_save_handler) signals.post_save.connect(update_permission_handler) signals.post_save.connect(notify_status_changes) pre_migrate.connect(pre_migrate_handler) post_migrate.connect(post_migrate_handler) max_file_size = getattr(settings, 'MERENGUE_MAX_FILE_SIZE', None) max_image_size = getattr(settings, 'MERENGUE_MAX_IMAGE_SIZE', None) if max_file_size or max_image_size: from django.forms.fields import FileField, ImageField, Field class MerengueFileField(Field): def clean(self, data): max_size = getattr(self, 'merengue_max_file_size', None) if data and max_size and len(data) > max_size: raise ValidationError(_('File to large. Max size restricted to %s bytes') % max_size) return super(MerengueFileField, self).clean(data)
registered_at = models.DateTimeField(auto_now_add=True) class AchievementEngineConf(AppConf): """ Configuration class used by Django AppConf to ease the setup""" USE_CELERY = False CLASSES = [] class Meta: prefix = 'achievement' def configure_classes(self, value): pass class View(models.Model): view = models.CharField(max_length=30, unique=True) url = models.CharField(max_length=30, unique=True, default="/"+str(view)) class Task(models.Model): task = models.CharField(max_length=30, unique=True) views = models.ManyToManyField(View) achievements = models.ManyToManyField(Achievement) # connect to the end of the syncdb command signal to reload achievements at that time. if 'south' in settings.INSTALLED_APPS: from south.signals import post_migrate post_migrate.connect(load_classes) else: from django.db.models.signals import post_migrate post_migrate.connect(load_classes)
# coding: utf-8 from django.conf import settings from django.db.models.signals import post_syncdb from south.signals import post_migrate from django.utils.translation import ugettext_noop as _ from django.contrib.sites.models import Site def register_site(app, created_models=None, verbosity=None, **kwargs): for (name, domain) in settings.OI_DOMAINS: site, created = Site.objects.get_or_create(name = name) site.domain = domain site.save() if created: print "%s registered"%name post_syncdb.connect(register_site) post_migrate.connect(register_site)