How to set up the Django model architecture for unknown properties?

Question

I have a Person model.

class Person(models.Model):
    name_first = models.CharField(max_length=100)
    name_middle = models.CharField(max_length=100, null=True, blank=True)
    name_last = models.CharField(max_length=100)
    date_birth = models.DateField(null=True, blank=True)
    date_death = models.DateField(null=True, blank=True)

I'm trying to extend it to different roles in the music world: a composer, a performer, and a patron.

A person can be one, two or all three roles. If a person is a performer, I also need to assign one or more instrument for that person. You may not know if a person is a performer at the time of instantiation. Or their roles can change over time.

I want to be able to search and display that a person is a composer, pianist and a patron, if he's all three. For example: Beethoven is a conductor, composer, and pianist.

My initial thought on implementation is to inherit the Person class.

class Composer(Person):
    pass

class Performer(Person):
    instrument = models.ManyToManyField(Instrument, verbose_name=_('instrument'), blank=True,)

class Patron(Person):
    pass

class Instrument(models.Model):
    name = models.CharField(max_length=100, null=True, blank=True)

Question 1: should I use some sort of abstract model instead? If so, how would I go about it?

Question 2: how can I search for a person and know whether they are a composer, patron and/or performer and the kind of performer they are.

Thanks.

Answer 1

My approach would be this: define a base Person class and make your other models have a foreign key to that model.

First, create your Person class.

class Person(models.Model):
    name_first = models.CharField(max_length=100)
    name_middle = models.CharField(max_length=100, null=True, blank=True)
    name_last = models.CharField(max_length=100)
    date_birth = models.DateField(null=True, blank=True)
    date_death = models.DateField(null=True, blank=True)

    @property
    def is_performer(self):
       return hasattr(self, 'performer_role')

    @property
    def is_patron(self):
        return hasattr(self, 'patron_role')

    @property
    def is_composer(self):
        return hasattr(self, 'composer_role')

    @property
    def roles(self):
        roles = []
        if self.is_performer:
            roles.append('performer')
        if self.is_patron:
            roles.append('patron')
        if self.is_composer:
            roles.append('composer')
        return roles

Second, make your specific models and set up a foreign key to the Person.

class ComposerRole(models.Model):
    person = models.OneToOneField(Person, on_delete=models.CASCADE, related_name='composer_role')
    # other fields as necessary

class PerformerRole(models.Model):
    person = models.OneToOneField(Person, on_delete=models.CASCADE, related_name='performer_role')
    instrument = models.CharField(max_length=100, blank=True)
    performer_type = models.CharField(max_length=100, blank=True) //conductor, performer
    # other fields as necessary

class PatronRole(models.Model):
    person = models.OneToOneField(Person, on_delete=models.CASCADE, related_name='patron_roll')
    # other fields as necessary

To instantiate a new person with their correct roles, you could add them like this:

p = Person.objects.create(...)
PerformerRole.objects.create(person=p, instrument='...')

To check whether someone has a role, just do person_instance.is_performer. To get the data for that role, do person_instance.performer_role.instrument.

An added benefit of this approach is that it allows you to query for composers, patrons, and performers, eg ComposerRole.objects.all() or ComposerRole.objects.filter(person__last_name='Beethoven').

Hope that helps.

EDIT: added roles to Person. This way you can get all of the roles a person has by doing person_instance.roles.

Answer 2

Create a single Person model with BooleanFields if they are that type of person then add related models as needed.

For me, it makes sense to have concrete fields on the Person model to be explicit if this person is a composer, performer or patron. Instead of an implicit assumption that someone is a Performer only because they might have a row in the PerformerRole, ComposerRole or PatronRole table.

class Person(models.Model):
    name_first = models.CharField(max_length=100)
    name_middle = models.CharField(max_length=100, null=True, blank=True)
    name_last = models.CharField(max_length=100)
    date_birth = models.DateField(null=True, blank=True)
    date_death = models.DateField(null=True, blank=True)

    is_composer = models.BooleanField(default=False)
    is_performer = models.BooleanField(default=False)
    is_patron = models.BooleanField(default=False)


class PerformerRole(models.Model):
    person = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
    )

    instrument = models.CharField(max_length=100)
    type = models.CharField(max_length=100)


class ComposerRole(models.Model):
    person = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
    )


class PatronRole(models.Model):
    person = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
    )

Answer 3

I would use two ManyToMany fields here:

class Role(models.Model):
    name = models.CharField(max_length=80)
    created = models.DateTimeField(auto_now_add=True)

class Instrument(models.Model):
    name = models.CharField(max_length=80)
    created = models.DateTimeField(auto_now_add=True)

class Person(models.Model):
    name_first = models.CharField(max_length=100)
    name_middle = models.CharField(max_length=100, null=True, blank=True)
    name_last = models.CharField(max_length=100)
    date_birth = models.DateField(null=True, blank=True)
    date_death = models.DateField(null=True, blank=True)
    role = models.ManyToManyField(Role)
    instrument = models.ManyToManyField(Instrument)

You can add as many roles and instruments to a Person as you would like.