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)
