def forwards(self): # Update content types to last actual state update_contenttypes(noc.sa.models, None) # Convert groups to tags ctype_id = db.execute( "SELECT id FROM django_content_type WHERE model='managedobject'" )[0][0] for category, entry_id in db.execute( "SELECT g.name,o.managedobject_id FROM sa_managedobject_groups o JOIN sa_objectgroup g ON (o.objectgroup_id=g.id)" ): if db.execute("SELECT COUNT(*) FROM tagging_tag WHERE name=%s", [category])[0][0] == 0: db.execute("INSERT INTO tagging_tag(name) VALUES(%s)", [category]) tag_id = db.execute("SELECT id FROM tagging_tag WHERE name=%s", [category])[0][0] db.execute( "INSERT INTO tagging_taggeditem(tag_id,content_type_id,object_id) VALUES(%s,%s,%s)", [tag_id, ctype_id, entry_id]) # Drop groups and fields for t in [ "sa_managedobject_groups", "sa_managedobjectselector_filter_groups", "sa_objectgroup" ]: db.drop_table(t)
def add_admin_perms(models, perm_parts=('add', 'change', 'delete')): """Designed to be run from a data migration script, adds create, edit and delete permissions to the site admin group""" from django.contrib.contenttypes.management import update_contenttypes from django.contrib.contenttypes.models import ContentType from django.contrib.auth.management import create_permissions from django.apps import apps from django.contrib.auth.models import Group, Permission if not isinstance(models, tuple): # Allow single model to be passed in models = (models,) # First, we need to create permissions in case this hasn't run yet # http://andrewingram.net/2012/dec/ \ # common-pitfalls-django-south/#contenttypes-and-permissions app_set = set([model._meta.app_label for model in models]) for app in app_set: app_config = apps.get_app_config(app) update_contenttypes(app_config) create_permissions(app_config) # Get group for site admin group, created = Group.objects.get_or_create(name='site admin') # Add permissions to the site admin for model in models: for perm_part in perm_parts: codename = "%s_%s" % (perm_part, model._meta.model_name) content_type = ContentType.objects.get_for_model(model) permission = Permission.objects.get(codename=codename, content_type=content_type) group.permissions.add(permission) group.save()
def forwards(self, orm): # Adding model 'SiteCategory' db.create_table(u'public_project_sitecategory', ( (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('category', self.gf('django.db.models.fields.CharField')( unique=True, max_length=50)), ('intro_text', self.gf('django.db.models.fields.TextField')( null=True, blank=True)), ('comments', self.gf('django.db.models.fields.TextField')(blank=True)), ('date_added', self.gf('django.db.models.fields.DateTimeField')( auto_now_add=True, blank=True)), )) db.send_create_signal(u'public_project', ['SiteCategory']) # Adding M2M table for field documents on 'SiteCategory' m2m_table_name = db.shorten_name( u'public_project_sitecategory_documents') db.create_table( m2m_table_name, (('id', models.AutoField( verbose_name='ID', primary_key=True, auto_created=True)), ('sitecategory', models.ForeignKey(orm[u'public_project.sitecategory'], null=False)), ('document', models.ForeignKey(orm[u'public_project.document'], null=False)))) db.create_unique(m2m_table_name, ['sitecategory_id', 'document_id']) #Update content types (necessary for migration 0006) update_contenttypes(get_app('public_project'), get_models()) create_permissions(get_app('public_project'), get_models(), 0)
def setUpTestData(cls): # We disable synchronisation of test models. So we need to create it manually. with connection.schema_editor() as editor: for model in [Child1, Parent, Child2, GenericChild, Child3, CodedGenericChild]: editor.create_model(model) update_contenttypes(apps.get_app_config('writable_serializers'))
def create_realtime_rest_group(apps, schema_editor): """Populate Groups for realtime group. :param apps: App registry. :type apps: django.apps.apps :param schema_editor: Django db abstraction for turning model into db. :type schema_editor: django.db.backends.schema """ # import apps registry, somehow it was only loaded fully from import realtime_app_config = apps_registry.get_app_config('realtime') # update content types update_contenttypes(realtime_app_config, interactive=False) # update permissions create_permissions(realtime_app_config, interactive=False) Group = apps.get_model('auth', 'Group') try: realtime_group = Group.objects.get(name=REST_GROUP) except Group.DoesNotExist: realtime_group = Group.objects.create(name=REST_GROUP) Permission = apps.get_model('auth', 'Permission') realtime_permissions = Permission.objects.filter( content_type__app_label='realtime') realtime_group.permissions.add(*realtime_permissions) realtime_group.save()
def create_realtime_rest_group(apps, schema_editor): """Populate Groups for realtime group. :param apps: App registry. :type apps: django.apps.apps :param schema_editor: Django db abstraction for turning model into db. :type schema_editor: django.db.backends.schema """ # import apps registry, somehow it was only loaded fully from import realtime_app_config = apps_registry.get_app_config('realtime') # update content types update_contenttypes(realtime_app_config, interactive=False) # update permissions create_permissions(realtime_app_config, interactive=False) Group = apps.get_model('auth', 'Group') try: realtime_group = Group.objects.get(name=REST_GROUP) except Group.DoesNotExist: realtime_group = Group.objects.create(name=REST_GROUP) Permission = apps.get_model('auth', 'Permission') realtime_permissions = Permission.objects.filter( content_type__app_label='realtime') realtime_group.permissions.add(*realtime_permissions) realtime_group.save()
def forwards(self, orm): db.start_transaction() cursor = connection.cursor() cursor.execute('select * from zorna_forms_form') qs = cursor.fetchall() # Adding model 'FormsFormActionUrl' db.create_table('zorna_forms_form_action_urls', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')( to=orm['forms.FormsForm'], null=True)), ('url', self.gf('django.db.models.fields.CharField')(max_length=255)), )) db.send_create_signal('forms', ['FormsFormActionUrl']) # Adding model 'FormsFormAction' db.create_table('zorna_forms_form_actions', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')( to=orm['forms.FormsForm'], null=True)), ('content_type', self.gf('django.db.models.fields.related.ForeignKey')( to=orm['contenttypes.ContentType'])), ('object_id', self.gf('django.db.models.fields.IntegerField')()), )) db.send_create_signal('forms', ['FormsFormAction']) # Adding model 'FormsFormActionMessage' db.create_table('zorna_forms_form_action_messages', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')( to=orm['forms.FormsForm'], null=True)), ('message', self.gf('django.db.models.fields.TextField')()), )) db.send_create_signal('forms', ['FormsFormActionMessage']) # Deleting field 'FormsForm.response' db.delete_column('zorna_forms_form', 'response') from django.contrib.contenttypes.management import update_contenttypes from django.db.models import get_app, get_models update_contenttypes(get_app('forms'), get_models()) if not db.dry_run: db.commit_transaction() db.start_transaction() ct = orm['contenttypes.ContentType'].objects.get( app_label="forms", model="formsformactionmessage") for form in qs: rep = orm.FormsFormActionMessage(message=form[13], form_id=form[0]) rep.save() orm.FormsFormAction.objects.create(form_id=form[0], object_id=rep.pk, content_type=ct) db.commit_transaction()
def forwards(self, orm): "Write your forwards methods here." # Note: Don't use "from appname.models import ModelName". # Use orm.ModelName to refer to models in this application, # and orm['appname.ModelName'] for models in other applications. update_contenttypes(get_app('activities'), get_models()) create_permissions(get_app('activities'), get_models(), 0)
def test_interactive_false(self): """ non-interactive mode of update_contenttypes() shouldn't delete stale content types. """ management.update_contenttypes(self.app_config, interactive=False) self.assertIn("Stale content types remain.", sys.stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count + 1)
def forwards(self, orm): "Write your forwards methods here." # Note: Don't use "from appname.models import ModelName". # Use orm.ModelName to refer to models in this application, # and orm['appname.ModelName'] for models in other applications. update_contenttypes(get_app('activities'), get_models()) create_permissions(get_app('activities'), get_models(), 0)
def test_interactive_false(self): """ non-interactive mode of update_contenttypes() shouldn't delete stale content types. """ management.update_contenttypes(self.app_config, interactive=False) self.assertIn("Stale content types remain.", sys.stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count + 1)
def handle_noargs(self, **options): app = get_app('services') try: boris_config = apps.get_app_config('boris') except: raise EnvironmentError( 'Cannot find app `boris`. App configs are: %s' % apps.get_app_configs()) update_contenttypes(boris_config, 2, interactive=False) app_models = models.get_models(app) # This will hold the permissions we're looking for as # (content_type, (codename, name)) searched_perms = list() # The codenames and ctypes that should exist. ctypes = set() for model in app_models: opts = model._meta # We can't use `get_for_model` here since it doesn't return # the correct `ContentType` for proxy models. # see https://code.djangoproject.com/ticket/17648 app_label, model = opts.app_label, opts.object_name.lower() if app_label == 'services' and model == 'encounter': ctype = ContentType.objects.get_by_natural_key( app_label, model) ctypes.add(ctype) for perm in _get_all_permissions(opts, model): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. all_perms = set( Permission.objects.filter(content_type__in=ctypes, ).values_list( "content_type", "codename")) group, created = Group.objects.get_or_create(name=u'Terén') print 'group: %s' % group if created: print 'ERROR: skupina Teren neexistovala!' return for ctype, (codename, name) in searched_perms: if (ctype.pk, codename) not in all_perms: Permission.objects.filter(codename=codename, name=name).delete() perm = Permission.objects.create(codename=codename, name=name, content_type=ctype) group.permissions.add(perm) sys.stdout.write("Adding encounter permission '%s'" % perm) for perm in Permission.objects.filter( codename__endswith='_groupcontact'): group.permissions.add(perm) sys.stdout.write("Adding group encounter permission '%s'" % perm) for perm in Permission.objects.filter(codename__endswith='_encounter'): group.permissions.add(perm) sys.stdout.write("Adding service permission '%s'" % perm)
def test_interactive_true(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes. """ management.input = lambda x: force_str("yes") management.update_contenttypes(self.app_config) self.assertIn("Deleting stale content type", sys.stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count)
def test_unavailable_content_type_model(self): """ #24075 - A ContentType shouldn't be created or deleted if the model isn't available. """ apps = Apps() with self.assertNumQueries(0): contenttypes_management.update_contenttypes(self.app_config, interactive=False, verbosity=0, apps=apps) self.assertEqual(ContentType.objects.count(), self.before_count + 1)
def test_interactive_true(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes. """ management.input = lambda x: force_str("yes") management.update_contenttypes(self.app_config) self.assertIn("Deleting stale content type", sys.stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count)
def test_unavailable_content_type_model(self): """ #24075 - A ContentType shouldn't be created or deleted if the model isn't available. """ apps = Apps() with self.assertNumQueries(0): contenttypes_management.update_contenttypes(self.app_config, interactive=False, verbosity=0, apps=apps) self.assertEqual(ContentType.objects.count(), self.before_count + 1)
def test_interactive_true_without_dependent_objects(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes and inform there are no dependent objects """ contenttypes_management.input = lambda x: force_str("yes") with captured_stdout() as stdout: contenttypes_management.update_contenttypes(self.app_config) self.assertIn("Deleting stale content type", stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count)
def test_interactive_true_without_dependent_objects(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes even if there aren't any dependent objects. """ contenttypes_management.input = lambda x: force_str("yes") with captured_stdout() as stdout: contenttypes_management.update_contenttypes(self.app_config) self.assertIn("Deleting stale content type", stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count)
def cms_editor(apps, schema_editor): from django.contrib.contenttypes.management import update_contenttypes from django.apps import apps as configured_apps for app in configured_apps.get_app_configs(): update_contenttypes(app, interactive=True, verbosity=0) from django.contrib.auth.management import create_permissions for app in configured_apps.get_app_configs(): create_permissions(app, verbosity=0) create_perms(apps)
def add_episodes_to_codes(apps, schema_editor): app_config = apps.get_app_config("activities") app_config.models_module = app_config.models_module or True ContentType = apps.get_model('contenttypes', 'ContentType') Collection = apps.get_model('niqati', 'Collection') update_contenttypes(app_config) episode_content_type = ContentType.objects.get(model="episode") for collection in Collection.objects.filter(codes__isnull=False).iterator(): episode = collection.order.episode collection.codes.update(object_id=episode.pk, content_type=episode_content_type)
def handle_noargs(self, **options): app = get_app('services') try: boris_config = apps.get_app_config('boris') except: raise EnvironmentError('Cannot find app `boris`. App configs are: %s' % apps.get_app_configs()) update_contenttypes(boris_config, 2, interactive=False) app_models = models.get_models(app) # This will hold the permissions we're looking for as # (content_type, (codename, name)) searched_perms = list() # The codenames and ctypes that should exist. ctypes = set() for model in app_models: opts = model._meta # We can't use `get_for_model` here since it doesn't return # the correct `ContentType` for proxy models. # see https://code.djangoproject.com/ticket/17648 app_label, model = opts.app_label, opts.object_name.lower() if app_label == 'services' and model == 'encounter': ctype = ContentType.objects.get_by_natural_key(app_label, model) ctypes.add(ctype) for perm in _get_all_permissions(opts, model): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. all_perms = set(Permission.objects.filter( content_type__in=ctypes, ).values_list( "content_type", "codename" )) group, created = Group.objects.get_or_create(name=u'Terén') print 'group: %s' % group if created: print 'ERROR: skupina Teren neexistovala!' return for ctype, (codename, name) in searched_perms: if (ctype.pk, codename) not in all_perms: Permission.objects.filter(codename=codename, name=name).delete() perm = Permission.objects.create(codename=codename, name=name, content_type=ctype) group.permissions.add(perm) sys.stdout.write("Adding encounter permission '%s'" % perm) for perm in Permission.objects.filter(codename__endswith='_groupcontact'): group.permissions.add(perm) sys.stdout.write("Adding group encounter permission '%s'" % perm) for perm in Permission.objects.filter(codename__endswith='_encounter'): group.permissions.add(perm) sys.stdout.write("Adding service permission '%s'" % perm)
def create_realtime_rest_group(apps, schema_editor): """Populate Groups for volcano ash realtime group. :param apps: App registry. :type apps: django.apps.apps :param schema_editor: Django db abstraction for turning model into db. :type schema_editor: django.db.backends.schema """ # import apps registry, somehow it was only loaded fully from import realtime_app_config = apps_registry.get_app_config('realtime') # update content types update_contenttypes(realtime_app_config, interactive=False) # update permissions create_permissions(realtime_app_config, interactive=False) Group = apps.get_model('auth', 'Group') group_list = [ (REST_GROUP, [ 'ash', 'floodreport', 'earthquakereport', 'impacteventboundary', 'flood', 'userpush', 'boundary', 'boundaryalias', 'floodeventboundary', 'earthquake', 'volcano', 'ashreport' ]), (VOLCANO_GROUP, [ 'volcano', ]), (ASH_GROUP, [ 'ash', 'ashreport', ]), ] for g in group_list: try: realtime_group = Group.objects.get(name=g[0]) except Group.DoesNotExist: realtime_group = Group.objects.create(name=g[0]) Permission = apps.get_model('auth', 'Permission') for m in g[1]: realtime_permissions = Permission.objects.filter( content_type__app_label='realtime', content_type__model=m) realtime_group.permissions.add(*realtime_permissions) realtime_group.save()
def forwards(self, orm): contenttypes = orm['contenttypes.ContentType'].objects removed = set() for ct in contenttypes.filter(model__endswith='_hist')\ .exclude(name__endswith=' history'): removed.add(ct.app_label) Permission.objects.filter(content_type=ct).delete() ct.delete() for app_label in removed: app = get_app(app_label) update_contenttypes(app, None) create_permissions(app, None, 2)
def forwards(self, orm): contenttypes = orm['contenttypes.ContentType'].objects removed = set() for ct in contenttypes.filter(model__endswith='_hist')\ .exclude(name__endswith=' history'): removed.add(ct.app_label) Permission.objects.filter(content_type=ct).delete() ct.delete() for app_label in removed: app = get_app(app_label) update_contenttypes(app, None) create_permissions(app, None, 2)
def test_interactive_true_with_dependent_objects(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes and warn of dependent objects """ Post.objects.create(title='post', content_type=self.content_type) contenttypes_management.input = lambda x: force_str("yes") with captured_stdout() as stdout: contenttypes_management.update_contenttypes(self.app_config) self.assertEqual(Post.objects.count(), 0) self.assertIn("1 object of type contenttypes_tests.post:", stdout.getvalue()) self.assertIn("Deleting stale content type", stdout.getvalue()) self.assertEqual(ContentType.objects.count(), self.before_count)
def handle(self, *args, **options): if not args: apps = [] for model in get_models(): apps.append(get_app(model._meta.app_label)) else: apps = [] for arg in args: apps.append(get_app(arg)) for app in apps: update_contenttypes(app, None, options.get('verbosity', 2), interactive=True) create_permissions(app, get_models(), options.get('verbosity', 0))
def remove_planned_disbursements(apps, schema_editor): """ add budget status 1 as its used as default in iati migration 0036 """ update_contenttypes(apps.get_app_config('iati'), interactive=False) # make sure all content types exist try: # don't run on first migration PlannedDisbursement = apps.get_model('iati', 'PlannedDisbursement') except: return PlannedDisbursement.objects.all().delete()
def forwards(self, orm): "Write your forwards methods here." # We are forcing contenttypes to update themselves instead of waiting on # the django signal post_syncdb because we need them now. Otherwise this # fails and the migration fails update_contenttypes(hwdoc.models, None) ct = orm['contenttypes.ContentType'].objects.get( name='Equipment', model='equipment', app_label='hwdoc') # model must be lowercase! try: perm = orm['auth.permission'].objects.get( content_type=ct, codename='can_change_comment') except Exception: orm['auth.permission'].objects.create( content_type=ct, codename='can_change_comment', name=u'Can change comments')
def create_proxy_permissions(app, created_models, verbosity, **kwargs): """ Creates permissions for proxy models which are not created automatically by `django.contrib.auth.management.create_permissions`. see https://code.djangoproject.com/ticket/11154 This method is inspired by `django.contrib.auth.managment.create_permissions`. Since we can't rely on `get_for_model' we must fallback to `get_by_natural_key`. However, this method doesn't automatically create missing `ContentType` so we must ensure all the model's `ContentType` are created before running this method. We do so by unregistering the `update_contenttypes` `post_syncdb` signal and calling it in here just before doing everything. """ update_contenttypes(app, created_models, verbosity, **kwargs) app_models = models.get_models(app) # This will hold the permissions we're looking for as # (content_type, (codename, name)) searched_perms = list() # The codenames and ctypes that should exist. ctypes = set() for model in app_models: opts = model._meta if opts.proxy: # We can't use `get_for_model` here since it doesn't return # the correct `ContentType` for proxy models. # see https://code.djangoproject.com/ticket/17648 app_label, model = opts.app_label, opts.object_name.lower() ctype = ContentType.objects.get_by_natural_key(app_label, model) ctypes.add(ctype) for perm in _get_all_permissions(opts): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. all_perms = set(Permission.objects.filter( content_type__in=ctypes, ).values_list( "content_type", "codename" )) objs = [ Permission(codename=codename, name=name, content_type=ctype) for ctype, (codename, name) in searched_perms if (ctype.pk, codename) not in all_perms ] Permission.objects.bulk_create(objs) if verbosity >= 2: for obj in objs: sys.stdout.write("Adding permission '%s'" % obj)
def ensure_view_permission(app, created_models, **kwargs): update_contenttypes(app, created_models, **kwargs) # This is normally called by post_syncdb, but we cannot guarantee ordering so we call it here for m in created_models: content_type = ContentType.objects.get_for_model(m) meta = m._meta obj_name = meta.object_name.lower() perm, created = Permission.objects.get_or_create( name="Can view %s" % obj_name, content_type=content_type, codename="view_%s" % obj_name) if created: print "Added view_%s permission" % obj_name
def setUp(self): # Create the schema for our test model self._style = no_style() sql, _ = connection.creation.sql_create_model(self.model, self._style) with connection.cursor() as c: for statement in sql: c.execute(statement) content_model = self.content_model if hasattr(self, 'content_model') else self.model app_config = apps.get_app_config(content_model._meta.app_label) update_contenttypes(app_config, verbosity=1, interactive=False) create_permissions(app_config, verbosity=1, interactive=False) super(RuntimeModel, self).setUp()
def create_proxy_permissions(app_config, **kwargs): update_contenttypes(app_config, kwargs) app_models = app_config.get_models() for model in app_models: opts = model._meta if opts.proxy: proxy_model = opts.proxy_for_model proxy_opts = proxy_model._meta proxy_app_label, proxy_model_name = proxy_opts.app_label, proxy_opts.object_name.lower() proxy_ctype = ContentType.objects.get_by_natural_key(proxy_app_label, proxy_model_name) app_label, model_name = opts.app_label, opts.object_name.lower() ctype = ContentType.objects.get_by_natural_key(app_label, model_name) for name, codename in proxy_ctype.permission_set.all().values_list('name', 'codename'): if not ctype.permission_set.filter(content_type=ctype, codename=codename): Permission(name=name, content_type=ctype, codename=codename).save()
def add_budget_status(apps, schema_editor): """ add budget status 1 as its used as default in iati migration 0036 """ update_contenttypes(apps.get_app_config('iati'), interactive=False) # make sure all content types exist try: # don't run on first migration BudgetStatus = apps.get_model('iati_codelists', 'BudgetStatus') except: return if not BudgetStatus.objects.filter(code='1').exists(): BudgetStatus( code='1', name='Indicative', description='A non-binding estimate for the described budget.').save()
def handle(self, *args, **options): if not args: apps = [] for model in get_models(): apps.append(get_app(model._meta.app_label)) else: apps = [] for arg in args: apps.append(get_app(arg)) for app in apps: update_contenttypes(app, None, options.get('verbosity', 2), interactive=True) create_permissions(app, get_models(), options.get('verbosity', 0))
def forwards(self, orm): "Write your forwards methods here." # We are forcing contenttypes to update themselves instead of waiting on # the django signal post_syncdb because we need them now. Otherwise this # fails and the migration fails update_contenttypes(hwdoc.models, None) ct = orm['contenttypes.ContentType'].objects.get( name='Equipment', model='equipment', app_label='hwdoc') # model must be lowercase! try: perm = orm['auth.permission'].objects.get( content_type=ct, codename='can_change_comment') except Exception: orm['auth.permission'].objects.create( content_type=ct, codename='can_change_comment', name=u'Can change comments')
def ensure_view_permission(app, created_models, **kwargs): update_contenttypes( app, created_models, **kwargs ) # This is normally called by post_syncdb, but we cannot guarantee ordering so we call it here for m in created_models: content_type = ContentType.objects.get_for_model(m) meta = m._meta obj_name = meta.object_name.lower() perm, created = Permission.objects.get_or_create( name="Can view %s" % obj_name, content_type=content_type, codename="view_%s" % obj_name) if created: print "Added view_%s permission" % obj_name
def create_proxy_permissions(app, created_models, verbosity, **kwargs): """ Creates permissions for proxy models which are not created automatically by `django.contrib.auth.management.create_permissions`. see https://code.djangoproject.com/ticket/11154 This method is inspired by `django.contrib.auth.managment.create_permissions`. Since we can't rely on `get_for_model' we must fallback to `get_by_natural_key`. However, this method doesn't automatically create missing `ContentType` so we must ensure all the model's `ContentType` are created before running this method. We do so by unregistering the `update_contenttypes` `post_syncdb` signal and calling it in here just before doing everything. """ update_contenttypes(app, created_models, verbosity, **kwargs) app_models = models.get_models(app) # This will hold the permissions we're looking for as # (content_type, (codename, name)) searched_perms = list() # The codenames and ctypes that should exist. ctypes = set() for model in app_models: opts = model._meta if opts.proxy: # We can't use `get_for_model` here since it doesn't return # the correct `ContentType` for proxy models. # see https://code.djangoproject.com/ticket/17648 app_label, model = opts.app_label, opts.object_name.lower() ctype = ContentType.objects.get_by_natural_key(app_label, model) ctypes.add(ctype) for perm in _get_all_permissions(opts): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. all_perms = set(Permission.objects.filter( content_type__in=ctypes, ).values_list( "content_type", "codename" )) for ctype, (codename, name) in searched_perms: if (ctype.pk, codename) not in all_perms: Permission.objects.filter(codename=codename, name=name).delete() perm = Permission.objects.create(codename=codename, name=name, content_type=ctype) if verbosity >= 2: sys.stdout.write("Adding permission '%s'" % perm)
def set_attachment_sort_order(apps, schema_editor): Review = apps.get_model('demotime', 'Review') Attachment = apps.get_model('demotime', 'Attachment') ContentType = apps.get_model('contenttypes', 'ContentType') app = apps.get_app_config('demotime') app.models_module = app.models_module or True update_contenttypes(app) content_type = ContentType.objects.get(model='reviewrevision', app_label='demotime') for review in Review.objects.all(): for revision in review.reviewrevision_set.all(): attachments = Attachment.objects.filter( content_type=content_type, object_id=revision.pk).order_by('pk') for count, attachment in enumerate(attachments, start=1): attachment.sort_order = count attachment.save(update_fields=['sort_order'])
def forwards(self, orm): "Write your forwards methods here." # Note: Don't use "from appname.models import ModelName". # Use orm.ModelName to refer to models in this application, # and orm['appname.ModelName'] for models in other applications. update_contenttypes(get_app('notes'), get_models()) create_permissions(get_app('notes'), get_models(), 0) students = orm['auth.Group'].objects.get(name="students") students.permissions.add(orm['auth.Permission'].objects.get(content_type__app_label="notes", codename="add_note")) students.permissions.add(orm['auth.Permission'].objects.get(content_type__app_label="notes", codename="change_note")) students.permissions.add(orm['auth.Permission'].objects.get(content_type__app_label="notes", codename="delete_note")) students.save() professors = orm['auth.Group'].objects.get(name="professors") professors.permissions.add(orm['auth.Permission'].objects.get(content_type__app_label="core", codename="add_course")) professors.save()
def remove_organisations(apps, schema_editor): """ convert all transaction's xdr values takes ~20 mins """ update_contenttypes( apps.get_app_config('iati'), interactive=False) # make sure all content types exist try: # don't run on first migration ActivityParticipatingOrganisation = apps.get_model( 'iati', 'ActivityParticipatingOrganisation') ActivityParticipatingOrganisation.objects.filter( organisation__isnull=False).update(organisation=None) except: pass try: ActivityReportingOrganisation = apps.get_model( 'iati', 'ActivityReportingOrganisation') ActivityReportingOrganisation.objects.filter( organisation__isnull=False).update(organisation=None) except: pass try: TransactionReceiver = apps.get_model('iati', 'TransactionReceiver') TransactionReceiver.objects.filter( organisation__isnull=False).update(organisation=None) except: pass try: TransactionProvider = apps.get_model('iati', 'TransactionProvider') TransactionProvider.objects.filter( organisation__isnull=False).update(organisation=None) except: pass try: # don't run on first migration Organisation = apps.get_model('iati_organisation', 'Organisation') Organisation.objects.all().delete() except: pass return
def forwards(self, orm): db.start_transaction() cursor = connection.cursor() cursor.execute('select * from zorna_forms_form') qs = cursor.fetchall() # Adding model 'FormsFormActionUrl' db.create_table('zorna_forms_form_action_urls', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['forms.FormsForm'], null=True)), ('url', self.gf('django.db.models.fields.CharField')(max_length=255)), )) db.send_create_signal('forms', ['FormsFormActionUrl']) # Adding model 'FormsFormAction' db.create_table('zorna_forms_form_actions', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['forms.FormsForm'], null=True)), ('content_type', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['contenttypes.ContentType'])), ('object_id', self.gf('django.db.models.fields.IntegerField')()), )) db.send_create_signal('forms', ['FormsFormAction']) # Adding model 'FormsFormActionMessage' db.create_table('zorna_forms_form_action_messages', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['forms.FormsForm'], null=True)), ('message', self.gf('django.db.models.fields.TextField')()), )) db.send_create_signal('forms', ['FormsFormActionMessage']) # Deleting field 'FormsForm.response' db.delete_column('zorna_forms_form', 'response') from django.contrib.contenttypes.management import update_contenttypes from django.db.models import get_app, get_models update_contenttypes(get_app('forms'), get_models()) if not db.dry_run: db.commit_transaction() db.start_transaction() ct = orm['contenttypes.ContentType'].objects.get(app_label="forms", model="formsformactionmessage") for form in qs: rep = orm.FormsFormActionMessage(message=form[13], form_id=form[0]) rep.save() orm.FormsFormAction.objects.create(form_id=form[0], object_id=rep.pk, content_type=ct) db.commit_transaction()
def permissions(apps, schema_editor): try: # Django <= 1.10 from django.contrib.contenttypes.management import update_contenttypes except ImportError: # Django 1.11 and over from django.contrib.contenttypes.management import \ create_contenttypes as update_contenttypes from django.apps import apps as configured_apps for app in configured_apps.get_app_configs(): update_contenttypes(app, interactive=True, verbosity=0) from django.contrib.auth.management import create_permissions for app in configured_apps.get_app_configs(): create_permissions(app, verbosity=0) create_perms(apps)
def get_name_from_narrative(apps, schema_editor): update_contenttypes(apps.get_app_config('iati'), interactive=False) # make sure all content types exist try: # don't run on first migration APOContentType = ContentType.objects.get(model='activityparticipatingorganisation') APO = apps.get_model('iati', 'ActivityParticipatingOrganisation') except: return Narrative = apps.get_model('iati', 'Narrative') for item in APO.objects.all(): narrative = Narrative.objects.filter(related_content_type_id=APOContentType.id, related_object_id=item.id) if narrative and narrative[0] and narrative[0].content: item.primary_name = narrative[0].content item.save() else: item.primary_name = item.normalized_ref item.save()
def create_rest_group(self): """Helper file for unittests to generate REST Group.""" # update content types update_contenttypes(self, interactive=False) # update permissions create_permissions(self, interactive=False) Group = apps.get_model('auth', 'Group') group_list = [ (REST_GROUP, [ 'ash', 'floodreport', 'earthquakereport', 'impacteventboundary', 'flood', 'userpush', 'boundary', 'boundaryalias', 'floodeventboundary', 'earthquake', 'volcano', 'ashreport' ]), (VOLCANO_GROUP, [ 'volcano', ]), (ASH_GROUP, [ 'ash', 'ashreport', ]), ] for g in group_list: try: realtime_group = Group.objects.get(name=g[0]) except Group.DoesNotExist: realtime_group = Group.objects.create(name=g[0]) Permission = apps.get_model('auth', 'Permission') for m in g[1]: realtime_permissions = Permission.objects.filter( content_type__app_label='realtime', content_type__model=m) realtime_group.permissions.add(*realtime_permissions) realtime_group.save()
def test_interactive_true_with_dependent_objects(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes and warn of dependent objects. """ post = Post.objects.create(title='post', content_type=self.content_type) # A related object is needed to show that a custom collector with # can_fast_delete=False is needed. ModelWithNullFKToSite.objects.create(post=post) contenttypes_management.input = lambda x: force_str("yes") with captured_stdout() as stdout: contenttypes_management.update_contenttypes(self.app_config) self.assertEqual(Post.objects.count(), 0) output = stdout.getvalue() self.assertIn('- Content type for contenttypes_tests.Fake', output) self.assertIn('- 1 contenttypes_tests.Post object(s)', output) self.assertIn('- 1 contenttypes_tests.ModelWithNullFKToSite', output) self.assertIn('Deleting stale content type', output) self.assertEqual(ContentType.objects.count(), self.before_count)
def test_interactive_true_with_dependent_objects(self): """ interactive mode of update_contenttypes() (the default) should delete stale contenttypes and warn of dependent objects. """ post = Post.objects.create(title="post", content_type=self.content_type) # A related object is needed to show that a custom collector with # can_fast_delete=False is needed. ModelWithNullFKToSite.objects.create(post=post) contenttypes_management.input = lambda x: force_str("yes") with captured_stdout() as stdout: contenttypes_management.update_contenttypes(self.app_config) self.assertEqual(Post.objects.count(), 0) output = stdout.getvalue() self.assertIn("- Content type for contenttypes_tests.Fake", output) self.assertIn("- 1 contenttypes_tests.Post object(s)", output) self.assertIn("- 1 contenttypes_tests.ModelWithNullFKToSite", output) self.assertIn("Deleting stale content type", output) self.assertEqual(ContentType.objects.count(), self.before_count)
def create_realtime_rest_group(apps, schema_editor): """Populate Groups for volcano ash realtime group. :param apps: App registry. :type apps: django.apps.apps :param schema_editor: Django db abstraction for turning model into db. :type schema_editor: django.db.backends.schema """ # import apps registry, somehow it was only loaded fully from import realtime_app_config = apps_registry.get_app_config('realtime') # update content types update_contenttypes(realtime_app_config, interactive=False) # update permissions create_permissions(realtime_app_config, interactive=False) Group = apps.get_model('auth', 'Group') group_list = [ (REST_GROUP, [ 'ash', 'floodreport', 'earthquakereport', 'impacteventboundary', 'flood', 'userpush', 'boundary', 'boundaryalias', 'floodeventboundary', 'earthquake', 'volcano', 'ashreport' ]), (VOLCANO_GROUP, [ 'volcano', ]), (ASH_GROUP, [ 'ash', 'ashreport', ]), ] for g in group_list: try: realtime_group = Group.objects.get(name=g[0]) except Group.DoesNotExist: realtime_group = Group.objects.create(name=g[0]) Permission = apps.get_model('auth', 'Permission') for m in g[1]: realtime_permissions = Permission.objects.filter( content_type__app_label='realtime', content_type__model=m) realtime_group.permissions.add(*realtime_permissions) realtime_group.save()
def convert_xdr_values(apps, schema_editor): """ convert all transaction's xdr values takes ~20 mins """ update_contenttypes(apps.get_app_config('iati'), interactive=False) # make sure all content types exist try: # don't run on first migration Budget = apps.get_model('iati', 'Budget') Transaction = apps.get_model('iati', 'Transaction') Activity = apps.get_model('iati', 'Activity') TranasctionSector = apps.get_model('iati', 'TranasctionSector') TransactionRecipientCountry = apps.get_model( 'iati', 'TransactionRecipientCountry') TransactionRecipientSector = apps.get_model( 'iati', 'TransactionRecipientSector') except: return for budget in Budget.objects.all().iterator(): budget.xdr_value = convert.to_xdr(budget.currency_id, budget.value_date, budget.value) budget.save() for transaction in Transaction.objects.all().iterator(): transaction.xdr_value = convert.to_xdr(transaction.currency_id, transaction.value_date, transaction.value) transaction.save() for activity in Activity.objects.all().iterator(): TransactionSector.objects.all().filter( transaction__activity=activity).delete() TransactionRecipientCountry.objects.all().filter( transaction__activity=activity).delete() TransactionRecipientSector.objects.all().filter( transaction__activity=activity).delete() post_save.set_sector_transaction(activity) post_save.set_country_region_transaction(activity)
def update_esp_contenttypes(app, created_models, content_type_class=ContentType, verbosity=2, **kwargs): """ Removes any content type model entries in the given app that no longer have a matching model class, then creates content types. django.contrib.contenttypes.management.update_contenttypes() does this, except it requires interactive raw input from the command line in order to remove stale content types. So this function copies the deletion functionality without the interactivity, and then calls the function. See <https://github.com/django/django/blob/30eb916bdb9b6b9fc881dfda919b49d036953a3b/django/contrib/contenttypes/management.py>. The content_type_class defaults to ContentType, but allows a frozen ORM to be passed in for use during a migration. """ app_models = get_models(app) if not app_models: return # They all have the same app_label, get the first one. app_label = app_models[0]._meta.app_label app_models = dict( (model._meta.object_name.lower(), model) for model in app_models) # Get all the content types content_types = dict( (ct.model, ct) for ct in content_type_class.objects.filter(app_label=app_label)) to_remove = [ ct for (model_name, ct) in content_types.iteritems() if model_name not in app_models ] if to_remove: for ct in to_remove: if verbosity >= 2: print "Deleting stale content type '%s | %s'" % (ct.app_label, ct.model) ct.delete() update_contenttypes(app, created_models, verbosity, **kwargs)
def forwards(self, orm): from django.contrib.contenttypes.management import update_contenttypes from django.db.models import get_app, get_models update_contenttypes(get_app('remozilla'), get_models()) name = 'Pending open questions' bug_type = orm['contenttypes.ContentType'].objects.get( app_label='remozilla', model='Bug') needinfo_user_ids = orm['remozilla.Bug'].objects.filter( budget_needinfo__isnull=False).values_list('budget_needinfo', flat=True) action_items = (orm['dashboard.ActionItem'].objects .filter(content_type=bug_type, resolved=False, name=name) .exclude(user__id__in=needinfo_user_ids)) for action_item in action_items: action_item.resolved = True action_item.completed = True action_item.save()
def forwards(self, orm): # Adding model 'VenueTicket' db.create_table(u'attendees_venueticket', ( (u'ticket_ptr', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['attendees.Ticket'], unique=True, primary_key=True)), ('first_name_tmp', self.gf('django.db.models.fields.CharField')(max_length=250, blank=True)), ('last_name_tmp', self.gf('django.db.models.fields.CharField')(max_length=250, blank=True)), ('organisation', self.gf('django.db.models.fields.CharField')(max_length=100, blank=True)), ('shirtsize_tmp', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['attendees.TShirtSize'], null=True, blank=True)), ('voucher_tmp', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['attendees.Voucher'], null=True, blank=True)), )) db.send_create_signal(u'attendees', ['VenueTicket']) # Adding model 'SIMCardTicket' db.create_table(u'attendees_simcardticket', ( (u'ticket_ptr', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['attendees.Ticket'], unique=True, primary_key=True)), ('first_name_tmp', self.gf('django.db.models.fields.CharField')(max_length=250)), ('last_name_tmp', self.gf('django.db.models.fields.CharField')(max_length=250)), ('date_of_birth', self.gf('django.db.models.fields.DateField')()), ('gender', self.gf('django.db.models.fields.CharField')(max_length=6)), ('hotel_name', self.gf('django.db.models.fields.CharField')(max_length=100, blank=True)), ('email', self.gf('django.db.models.fields.EmailField')(max_length=75)), ('street', self.gf('django.db.models.fields.CharField')(max_length=100)), ('zip_code', self.gf('django.db.models.fields.CharField')(max_length=20)), ('city', self.gf('django.db.models.fields.CharField')(max_length=100)), ('country', self.gf('django.db.models.fields.CharField')(max_length=100)), ('phone', self.gf('django.db.models.fields.CharField')(max_length=100)), ('sim_id', self.gf('django.db.models.fields.CharField')(max_length=20, blank=True)), )) db.send_create_signal(u'attendees', ['SIMCardTicket']) # Adding model 'SupportTicket' db.create_table(u'attendees_supportticket', ( (u'ticket_ptr', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['attendees.Ticket'], unique=True, primary_key=True)), )) db.send_create_signal(u'attendees', ['SupportTicket']) update_contenttypes(get_app('attendees'), get_models(), interactive=False) db.add_column(u'attendees_tickettype', 'content_type', self.gf('django.db.models.fields.related.ForeignKey')(default=orm['contenttypes.ContentType'].objects.get(app_label='attendees', model='venueticket').id, blank=False, to=orm['contenttypes.ContentType']), keep_default=False)
def create_proxy_permissions(app, created_models, verbosity, **kwargs): import pdb; pdb.set_trace() kwargs.pop("interactive",None) update_contenttypes(app, created_models, verbosity, **kwargs) app_models = django.db.models.get_models(app) # This will hold the permissions we're looking for as # (content_type, (codename, name)) searched_perms = list() # The codenames and ctypes that should exist. ctypes = set() for model in app_models: opts = model._meta if opts.proxy: # We can't use `get_for_model` here since it doesn't return # the correct `ContentType` for proxy models. # see https://code.djangoproject.com/ticket/17648 app_label, model = opts.app_label, opts.object_name.lower() ctype = ContentType.objects.get_by_natural_key(app_label, model) ctypes.add(ctype) for perm in _get_all_permissions(opts, ctypes): searched_perms.append((ctype, perm)) # Find all the Permissions that have a content_type for a model we're # looking for. We don't need to check for codenames since we already have # a list of the ones we're going to create. all_perms = set(Permission.objects.filter( content_type__in=ctypes, ).values_list( "content_type", "codename" )) objs = [ Permission(codename=codename, name=name, content_type=ctype) for ctype, (codename, name) in searched_perms if (ctype.pk, codename) not in all_perms ] Permission.objects.bulk_create(objs) if verbosity >= 2: for obj in objs: sys.stdout.write("Adding permission '%s'" % obj)
def forwards(self, orm): from django.utils.timezone import now from django.contrib.contenttypes.management import update_contenttypes from django.db.models import get_app, get_models update_contenttypes(get_app('voting'), get_models()) poll_type = orm['contenttypes.ContentType'].objects.get( app_label='voting', model='Poll') # Close old polls polls_ids = (orm['voting.Poll'].objects.filter(end__lt=now()) .values_list('id', flat=True)) action_items = orm['dashboard.ActionItem'].objects.filter( content_type=poll_type, object_id__in=polls_ids, resolved=False) for action_item in action_items: user = action_item.user poll = orm['voting.Poll'].objects.get(pk=action_item.object_id) if orm['voting.Vote'].objects.filter(user=user, poll=poll).exists(): action_item.completed = True action_item.resolved = True action_item.save()
def forwards(self, orm): # Adding model 'SiteCategory' db.create_table(u'public_project_sitecategory', ( (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('category', self.gf('django.db.models.fields.CharField')(unique=True, max_length=50)), ('intro_text', self.gf('django.db.models.fields.TextField')(null=True, blank=True)), ('comments', self.gf('django.db.models.fields.TextField')(blank=True)), ('date_added', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)), )) db.send_create_signal(u'public_project', ['SiteCategory']) # Adding M2M table for field documents on 'SiteCategory' m2m_table_name = db.shorten_name(u'public_project_sitecategory_documents') db.create_table(m2m_table_name, ( ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)), ('sitecategory', models.ForeignKey(orm[u'public_project.sitecategory'], null=False)), ('document', models.ForeignKey(orm[u'public_project.document'], null=False)) )) db.create_unique(m2m_table_name, ['sitecategory_id', 'document_id']) #Update content types (necessary for migration 0006) update_contenttypes(get_app('public_project'), get_models()) create_permissions(get_app('public_project'), get_models(), 0)
def fake_permissions(self): ''' Add fake app missing content types and permissions''' app = get_app('fake') update_contenttypes(app, None, 0) create_permissions(app, None, 0)