I am creating an abstract model for my django app, SrdObject. One of the characteristics of my model is that it has a pair of fields that, taken together, must be unique: 'name' and the foreign key 'module'.
Here is an example of what I had
class SrdObject(models.Model):
name = models.CharField(max_length=50)
slug_name = models.SlugField(max_length=75, unique=True)
active = models.BooleanField(default=True)
module = models.ForeignKey(Module, on_delete=models.CASCADE, related_name='%(class)s', blank=False, null=False, default='default')
class Meta:
unique_together = ['name', 'module']
ordering = ['name']
abstract = True
This seemed to be working ok, but the unique_together attribute has been marked as deprecated by django (See here), so I changed it to this
class Meta:
constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
ordering = ['name']
abstract = True
This doesn't work because the name field must be unique, and since this is an abstract class, the constraint is repeated over several models.
I also tried
models.UniqueConstraint(fields=['name', 'module'], name='{}-unique-in-module'.format(model_name))
But obviously this falls into scoping problems, so I tried a decorator method
def add_unique_in_module_constraint(cls):
cls._meta.constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
return cls
#add_unique_in_module_constraint
class SrdObject(models.Model):
class Meta:
ordering = ['name']
abstract = True
But this didn't seem to do anything.
So how do I create a models.UniqueConstraint in abstract model if every constraint needs a unique name attribute?
LATEST UPDATE
Since 3rd version you finally can do that by specifying interpolation:
Changed in Django 3.0:
Interpolation of '%(app_label)s' and '%(class)s' was added.
Example:
UniqueConstraint(fields=['room', 'date'], name='%(app_label)s_unique_booking')
OLD (Django < 3.0)
You can't do that, same problem for me, so sad...
Source: django docs
Constraints in abstract base classes
You must always specify a unique name for the constraint. As such, you cannot normally specify a constraint on an abstract base class, since the Meta.constraints option is inherited by subclasses, with exactly the same values for the attributes (including name) each time. Instead, specify the constraints option on subclasses directly, providing a unique name for each constraint.
I took this model setup:
class Module(models.Model):
pass
class SrdObject(models.Model):
name = models.CharField(max_length=50)
slug_name = models.SlugField(max_length=75, unique=True)
active = models.BooleanField(default=True)
module = models.ForeignKey(Module, on_delete=models.CASCADE, related_name='%(class)s', blank=False, null=False, default='default')
class Meta:
constraints = [
models.UniqueConstraint(fields=['name', 'module'], name='unique-in-module')
]
ordering = ['name']
abstract = True
class SrdObjectA(SrdObject):
pass
class SrdObjectB(SrdObject):
pass
And then ran these tests:
class TestSrdObject(TestCase):
#classmethod
def setUpTestData(cls):
cls.module = Module.objects.create()
SrdObjectA.objects.create(name='A', module=cls.module)
def test_unique_applies_to_same_model(self):
with self.assertRaises(IntegrityError):
SrdObjectA.objects.create(name='A', module=self.module)
def test_unique_does_not_apply_to_different_model(self):
self.assertTrue(SrdObjectB.objects.create(name='A', module=self.module))
And they pass. Perhaps I'm still missing the problem you're running into?
Related
I'm trying to create a new object of my model, but keep on getting a value of none for one field.
My models look like this:
class KeyCategory(models.Model):
program = models.ForeignKey('Program', verbose_name='Programm', on_delete=models.CASCADE)
name = models.CharField('Name', max_length=100)
events = models.ManyToManyField('Event', through='EventQuota')
class Meta:
verbose_name = 'Category'
verbose_name_plural = 'Categories'
ordering = ['name']
unique_together = ("program", "name")
permissions = (
('view_key_category', 'Have access to categories'),
)
class EventQuota(models.Model):
key_category = models.ForeignKey(KeyCategory, on_delete=models.CASCADE, related_name='key_quota')
event = models.ForeignKey('Event', on_delete=models.CASCADE, related_name='key_quota')
quota = models.PositiveIntegerField('Quota', default=0)
class Meta:
verbose_name = 'Quota'
verbose_name_plural = 'Quotas'
unique_together = ('key_category', 'event')
When I try now to create a KeyCategory and my EventQuota, the field "events" for KeyCategory always returns core.Event.None
if program.pk == 1:
for _ in range(0, 2):
key_category = KeyCategory(
program=program,
name=random.choice(self.eventList)
)
key_category.save()
event_quota = EventQuota(
key_category=key_category,
event = random.choice(eventList),
quota = random.randint(0,100)
)
event_quota.save()
Note: the eventList in the random.choice is a queryset list of objects.
I tried to follow Djangos Extra fields on Many-to-Many relationships example, but somehow it seems that I'm missing something here or doing something not the right way? Would appreciate any help! Thanks in regard.
Logging:
import logging
logger = logging.getLogger(__name__)
logger.debug(key_category.events)
When you access key_category.events you are asking for the value of a field (or a single object for foreign key fields). However with a ManyToMany relationship you are asking for multiple objects (a queryset).
Using key_category.events.all() returns the objects related to the key_category, not just a single value.
core.events.all()
I have inheritance between Employee and Manager classes. Employee - superclass, Manager - subclass.
class Employee(models.Model):
name = models.CharField(max_length=50, null=False)
address = models.CharField(max_length=50, null=False)
class Manager(Employee):
department = models.CharField(max_length=50)
"""
Here I don't want the 'name' and 'address' fields of Employee class.
(I want other fields of Employee and 'department' field of this
class to be stored in Manager table in database)
"""
How can achieve this. Thanks in advance.
You can make private variables in python class using 2 underscores (__), check this example for more.
However they will store that values in child object as there is no such thing as private or protected in Python.
But another approach can work for Django. In Django model fields are stored depending on their value (CharField, DateField and etc.) but if you will make item value None or any other static value (ex. "string"), that should solve your problem:
class Manager(Employee):
name = None
address = None
# other_stuffs.
In that example, Manager should not have name and address columns in database and when you will try to access them, you will get None. And if you want to get AttributeError (Django raises that when object hasn't requested key) then you can also add property:
class Manager(Employee):
name = None
#property
def name(self):
raise AttributeError("'Manager' object has no attribute 'name'")
I'd use 3 classes:
class BaseEmployee(models.Model):
# All your common fields
class Employee(BaseEmployee):
name = models.CharField(max_length=50, null=False)
address = models.CharField(max_length=50, null=False)
class Manager(BaseEmployee):
department = models.CharField(max_length=50)
I think that achieves what you wanted.
You need to use 3 classes "AbstractEmployee" with "abstract = True", "Employee" and "Manager" as shown below. "abstract = True" makes "AbstractEmployee" class an abstract class so a table is not created from "AbstractEmployee" class while each table is created from "Employee" and "Manager" classes and to remove the inherited fields "name" and "address" from "Manager" class, set "None" to them:
class AbstractEmployee(models.Model):
name = models.CharField(max_length=50, null=False)
address = models.CharField(max_length=50, null=False)
class Meta:
abstract = True # Here
class Employee(AbstractEmployee):
pass
class Manager(AbstractEmployee):
name = None # Here
address = None # Here
department = models.CharField(max_length=50)
I need two type of profile:
1) the first linked to Users by onetoone relationship to expand it with some new fields.
2) the seconds indipendent from Users (and accessible only to superuser/admin): they are just objects.
The problem is that I want a easy way to change a profile from 1°type to second type and viceversa.
In "Django Designer Patterns " I find an example like this:
class BaseProfile(models.Model):
User_Types = (
(0, 'active'),
(1, 'inactive'),
)
user_type = models.IntegerField(null=True, choices=User_Types, default=0)
name = models.CharField(max_length=32, unique=True)
#many other common field
class Meta:
abstract = True
def __str__(self):
return self.name
class Profile_Active(models.Model):
user = models.OneToOneField(User, blank=True, on_delete=models.PROTECT,
related_name='profile_active', primary_key=True) #this was in BaseProfile
#some more field reserved for this type of profile
class Meta:
abstract = True
class Profile_Inactive(models.Model):
#some field reserved for this type of profile
class Meta:
abstract = True
class Profile(Profile_Inactive, Profile_Active, BaseProfile):
pass
but I don't understand how I should combine the abstract models in Profile (what I should write instead of "pass"?) and what I should achieve? Profile
will have all the fields of the three models? Which the gain respect to use a single model?
Maybe I can forget Profile and use Profile_Inactive(BaseProfile) and Profile_Active(BaseProfile)? but then how to change from one to the other?
I'm confused, help please
I have run into a problem developing my Django site.
from django.db import models
class TitlePost(models.Model):
title_name = models.CharField(max_length=100, unique=True)
title_body = models.TextField(max_length=30000)
title_why = models.TextField(max_length=250, null=True)
title_publication_date = models.DateTimeField('date')
likes = models.IntegerField(default=0)
dislikes = models.IntegerField(default=0)
def __unicode__(self):
return self.title_name
class TopTitlesPostPage(models.Model):
title_post = models.OneToOneField(TitlePost)
hello = models.CharField(max_length=100, unique=True)
def __unicode__(self):
return self.hello
class NewTitlesPostPage(models.Model):
title_post = models.OneToOneField(TitlePost)
hello = models.CharField(max_length=100, unique=True)
def __unicode__(self):
return self.hello
Why don't TopTitlesPostPage and NewTitlesPostPage inherit all the attributes from TitlePost? For instance, if I try to call the likes in my template using TopTitlesPostPage, it will not execute because the likes attribute is not inherited. Does OneToOneField have something to do with the problem? I did read that making TitlePost a meta class will help but I need it to have a table in my database. I actually want all of them to have a table in my data base. Then again, maybe I am approaching this the wrong way and I should use just TitlePost as a model to generate everything?
The behaviour you would like to see is called multi table inheritance. Every child class internally ends up with the same thing that you wrote, so with a one to one field to the base class TitlePost, but it's internally managed by django.
If you do multiple inheritance like the code below you will be able to write:
k=TopTitlesPostPage.objects.create(hello="Hello",title_name="Heh")
That means the fields will be directly accessible.
from django.db import models
class TitlePost(models.Model):
title_name = models.CharField(max_length=100, unique=True)
title_body = models.TextField(max_length=30000)
title_why = models.TextField(max_length=250, null=True)
title_publication_date = models.DateTimeField('date')
likes = models.IntegerField(default=0)
dislikes = models.IntegerField(default=0)
def __unicode__(self):
return self.title_name
class TopTitlesPostPage(TitlePost):
hello = models.CharField(max_length=100, unique=True)
def __unicode__(self):
return self.hello
class NewTitlesPostPage(TitlePost):
hello = models.CharField(max_length=100, unique=True)
def __unicode__(self):
return self.hello
In case you are never actually going to reference the base class TitlePost, but only its children it might be more appropriate to make `TitlePost abstract:
class TitlePost(models.Model):
title_name = models.CharField(max_length=100, unique=True)
title_body = models.TextField(max_length=30000)
title_why = models.TextField(max_length=250, null=True)
title_publication_date = models.DateTimeField('date')
likes = models.IntegerField(default=0)
dislikes = models.IntegerField(default=0)
class Meta:
abstract = True
def __unicode__(self):
return self.title_name
Making TitlePostabstract will omit the creation of the table TitlePostin the database, and the child models will end up with the fields of the base class inserted into their own tables seperately. If the base class is just for factoring out common functionality this is the preferred way to go.
For huge queries this will also make a difference in performance because the ORM will need to do less JOINoperations.
It's not possible to install Foreign Keys to abstract models in Django.
You can however install Foreign Keys to a non abstract base class. The only limitation is that the reverse Foreign Key relation will return the base class instances.
You can circumvent this limitation by using django-polymorphic.
Django Polymorphic allows you to query the base class objects but retrieves the child class instances:
>>> Project.objects.create(topic="Department Party")
>>> ArtProject.objects.create(topic="Painting with Tim", artist="T. Turner")
>>> ResearchProject.objects.create(topic="Swallow Aerodynamics", supervisor="Dr. Winter")
>>> Project.objects.all()
[ <Project: id 1, topic "Department Party">,
<ArtProject: id 2, topic "Painting with Tim", artist "T. Turner">,
<ResearchProject: id 3, topic "Swallow Aerodynamics", supervisor "Dr. Winter"> ]
To use django polymorphic you only need to declare your models with Polymorphic Model as base class:
from django.db import models
from polymorphic import PolymorphicModel
class ModelA(PolymorphicModel):
field1 = models.CharField(max_length=10)
class ModelB(ModelA):
field2 = models.CharField(max_length=10)
class ModelC(ModelB):
field3 = models.CharField(max_length=10)
Foreign keys will also return the child class instances, which is really cool if you're trying to be polymorphic.
# The model holding the relation may be any kind of model, polymorphic or not
class RelatingModel(models.Model):
many2many = models.ManyToManyField('ModelA') # ManyToMany relation to a polymorphic model
>>> o=RelatingModel.objects.create()
>>> o.many2many.add(ModelA.objects.get(id=1))
>>> o.many2many.add(ModelB.objects.get(id=2))
>>> o.many2many.add(ModelC.objects.get(id=3))
>>> o.many2many.all()
[ <ModelA: id 1, field1 (CharField)>,
<ModelB: id 2, field1 (CharField), field2 (CharField)>,
<ModelC: id 3, field1 (CharField), field2 (CharField), field3 (CharField)> ]
Take into account that these queries will be slightly less performant.
U need to extend the classes like follows:
class TopTitlesPostPage(TitlePost):
U can add more and inherit from multiple models just by mentionin g all the models comma separated! This all the fields from the models will be created in the child class as well
EDIT:
The way i would do it is to create an Abstract class which contains all your common fields and extend it into your TitlePost, TopTitlesPostPagea and NewTitlesPostPage
You need to have TopTitlesPostPage and NewTitlesPostPage extend the base class of TitlePost like so ...
class TopTitlesPostPage(models.Model)
You don't need a OneToOneField if you are inheriting from the base class, since the attributes of TitlePost will be available to you in the subclass. If you want to make TitlePost abstract (you can not declare an instance of that class, only inherit from it) you have to add it to the meta class
class TitlePost(models.Model):
class Meta:
abstract = True
Here is a link to the documentation.
I know that django will helpfully generate a through table for simple many-to-many tables. However if you want to add information about the relationship, you need a 'linker' or through table. This example from the docs gives an example:
from django.db import models
class Person(models.Model):
name = models.CharField(max_length=128)
def __str__(self): # __unicode__ on Python 2
return self.name
class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(Person, through='Membership')
def __str__(self): # __unicode__ on Python 2
return self.name
class Membership(models.Model):
person = models.ForeignKey(Person)
group = models.ForeignKey(Group)
date_joined = models.DateField()
invite_reason = models.CharField(max_length=64)
I have in my design several tables/models like group, that vary mostly just by their choices attribute. And I'll be adding more later.
Is it possible to customize what sort of through table is generated by Django's magic? If so is this sensible?
The sort of thing I'm talking about is this:
class CharacterSkillLink(models.Model):
character = models.ForeignKey('NWODCharacter', related_name='%(class)s_by_skill')
skill = models.ForeignKey('Skill', choices = SKILL_CHOICES)
value = models.IntegerRangeField(min_value=1, max_value=5)
speciality = models.CharField(max_length=200)
class CharacterAttributeLink(models.Model):
character = models.ForeignKey('NWODCharacter', related_name='%(class)s_by_skill')
attribute = models.ForeignKey('Attribute', choices = ATTRIBUTE_CHOICES)
value = model.IntegerRangeField(min_value=1, max_value=5
class CharacterArcanaLink(models.Model):
character = models.ForeignKey('Mage', related_name='%(class)s_by_skill')
arcana = models.ForeignKey('Arcana', choices = ARCANA_CHOICES)
value = model.IntegerRangeField(min_value=1, max_value=5
In the future there'll be more like these. It's be handy if there was some way to django, much like with the through_field attribute, which defines keys on the through table to use, that there should be extra values to add to it (e.g. extra_field=value).
Is this possible/sensible?
IMO, adding fields to a "through" table is a great pattern for many possible uses. I'm not sure that Django needs new syntax to handle this case, but if you think you're creating lots of these tables and mixing/matching different tables, perhaps some abstract mixins will simplify things. For Example:
class CharacterLink(models.Model):
character = models.ForeignKey('NWODCharacter')
class Meta:
abstract = True
class SkillLink(models.Model):
skill = models.ForeignKey('Skill', choices = SKILL_CHOICES)
class Meta:
abstract = True
class AttributeLink(models.Model):
attribute = models.ForeignKey('Attribute', choices = ATTRIBUTE_CHOICES)
class Meta:
abstract = True
class CharacterSkillLink(CharacterLink, SkillLink):
value = models.IntegerRangeField(min_value=1, max_value=5)
speciality = models.CharField(max_length=200)
class CharacterAttributeLink(CharacterLink, AttributeLink):
value = model.IntegerRangeField(min_value=1, max_value=5)