10

I am trying to add a dynamic Meta attribute to all of my Django models using model inheritance, but I can't get it to work. I have a permission that I want to add to all my models like this:

class ModelA(models.Model):
    class Meta:
        permisssions =(('view_modela','Can view Model A'),)   

class ModelB(models.Model):
    class Meta:
        permisssions =(('view_modelb','Can view Model B'),)

I tried creating an abstract base class like this:

class CustomModel(models.Model):
    def __init__(self, *args, **kwargs):
        self._meta.permissions.append(('view_'+self._meta.module_name, u'Can view %s' % self._meta.verbose_name))
        super(CustomModel,self).__init__(*args, **kwargs)

class ModelA(CustomModel):
    ....

class ModelB(CustomModel):
    ...

but it's not working. Is this the right approach? Because Django uses introspection to construct the Model classes, I'm not sure if adding permissions during the __init__() of the class will even work. With my current implementation every time I access a model instance it appends another tuple of the permissions.

gerdemb
  • 11,275
  • 17
  • 65
  • 73

2 Answers2

26

Your instinct is right that this won't work. In Django, permissions are stored in the database, which means that:

  • they need to be available at the class level when syncdb is run in order to populate the auth_permission table (and your approach requires an instance, which won't be made during syncdb)
  • even if you did add it to _meta.permissions in __init__, the User object wouldn't pick it up in any permission check calls because those consult the permissions table in the DB (and a cache of that table, at that).

Your goal can't be accomplished using inheritance. What you actually need here is a Python metaclass.

This metaclass re-writes your ModelA and ModelB class definitions dynamically before they are defined, thus it doesn't require a ModelA instance, and is available to syncdb. Since Django's models also use metaclasses to build the Meta object in the first place, the only requirement is that your metaclass must inherit from the same metaclass as Django's models.

Here's some sample code (Python 2):

from django.db.models.base import ModelBase

class CustomModelMetaClass(ModelBase):

    def __new__(cls, name, bases, attrs):
        klas = super(CustomModelMetaClass, cls).__new__(cls, name, bases, attrs)
        klas._meta.permissions.append(
            (
                'view_{0.module_name}'.format(klas._meta),
                u'Can view {0.verbose_name}'.format(klas._meta))
        )

        return klas

class ModelA(models.Model):

    __metaclass__ = CustomModelMetaClass

    test = models.CharField(max_length=5)

Python 3:

from django.db.models.base import ModelBase

class CustomModelMetaClass(ModelBase):

    def __new__(cls, name, bases, attrs):
        klas = super().__new__(cls, name, bases, attrs)
        klas._meta.permissions.append(
            (
                'view_{0.module_name}'.format(klas._meta),
                'Can view {0.verbose_name}'.format(klas._meta))
        )

        return klas

class ModelA(models.Model, metaclass=CustomModelMetaClass):

    test = models.CharField(max_length=5)

Note that permissions in this case will be written only on migrate. If you need to change permissions dynamically at run time base on the user, you'll want to provide your own authentication backend.

bignose
  • 30,281
  • 14
  • 77
  • 110
Jarret Hardie
  • 95,172
  • 10
  • 132
  • 126
  • 3
    +1 for an example of writing a custom metaclass in a django-related question. this stuff is hard to find! – airstrike Mar 16 '11 at 18:12
  • I know this is what upvotes are for, and this is an old thread, but... damn, Jarret. The encyclopedic level of knowledge of Django and Python needed to come up with this answer and then explain simply and clearly is mind-boggling. Thank you for making the Internet a more useful place. – jfmatt Nov 24 '12 at 22:03
  • I don't know who you are, @General_Mayhem, but you just made my year. Thanks for making nice comments on such an old post! – Jarret Hardie Nov 25 '12 at 18:59
  • I'm a beginning Django dev who was trying (and has now succeeded) to solve the same problem as OP, but who didn't even know that Python had metaclasses, let alone exactly how to apply them in this situation, and was getting very frustrated with how many of his problems with Django wind up being absolutely impossible to Google because every single page about Django uses all of its keywords. – jfmatt Nov 25 '12 at 19:09
  • 1
    Note that for Python 3 you need `class ModelA(models.Model, metaclass=CustomModelMetaClass)` (instead of `__metaclass__`). – blueyed Jun 21 '18 at 16:14
1

Try to use a custom manager:

#create a custom manager
class DynTableNameManager(models.Manager):
    #overwrite all() (example)
    #provide table_name
    def all(self, table_name):
        from django.db import connection
        cursor = connection.cursor()
        cursor.execute("""
            SELECT id, name
            FROM %s
            """ % table_name)
        result_list = []
        for row in cursor.fetchall():
            p = self.model(id=row[0], name=row[1])
            result_list.append(p)
        return result_list

#cerate a dummy table
class DummyTable(models.Model):
    name = models.CharField ( max_length = 200 )
    objects = DynTableNameManager()

use like this:

f = DummyTable.objects.all('my_table_name')
rexus
  • 11
  • 1