django models - Avoid possible circular reference in database design - django

Question

I have a database design and relationships problem and I am concerned with possible circular references.
To give an example, Jack has on his stock Medicines A, B and C. Medicines A and B have an active_ingredient AI1 and medicine C has an active_ingredient AI2.
Jack goes to the doctor, who prescribes him AI1. For the Prescription object, it is indifferent if he takes Medicine A or B.
Here is an example code:
class ActiveIngredient(models.Model):
...
class Medicine(models.Model):
quantity = models.IntegerField()
active_ingredient = models.ForeignKey("ActiveIngredient", on_delete=models.CASCADE)
class Person(models.Model):
...
class PersonStock(models.Model):
customer = models.ForeignKey("Person", on_delete=models.CASCADE)
medicine = models.ForeignKey("Medicine", on_delete=models.CASCADE)
expiration_date = models.DateField()
class Prescription(models.Model):
...
quantity = models.IntegerField()
What is the best solution to model this relationship?
Changing Prescription to this:
class Prescription(models.Model):
...
customer = models.ForeignKey("Person", on_delete=models.CASCADE)
active_ingredient = models.ForeignKey("ActiveIngredient", on_delete=models.CASCADE)
quantity = models.IntegerField()
Seems wrong to me given that there is the PersonStock class already connecting Person and Medicine.

Answer 1

You're right to be concerned about duplicated information; a major concern of database design (specifically database normalization) is avoiding that so as to eliminate the possibility of inconsistent data.
In this case, however, I think it makes more sense to keep prescriptions and their filling separate. These are two separate things, and in the real world it's very possible for mistakes to be made and the wrong medicine to be delivered. While one should endeavor to prevent such mistakes, that's very different from making it impossible to represent a mistake in your data model.
So my recommendation would be to validate the data at the application layer rather than building constraints into the data model itself. Something like:
class ActiveIngredient(models.Model):
...
class Medicine(models.Model):
quantity = models.IntegerField()
active_ingredient = models.ForeignKey("ActiveIngredient", on_delete=models.CASCADE)
class Person(models.Model):
...
class Prescription(models.Model):
...
customer = models.ForeignKey("Person", on_delete=models.CASCADE)
active_ingredient = models.ForeignKey("ActiveIngredient", on_delete=models.CASCADE)
quantity = models.IntegerField()
class PersonStock(models.Model):
prescription = models.ForeignKey("Prescription", on_delete=models.CASCADE)
medicine = models.ForeignKey("Medicine", on_delete=models.CASCADE)
expiration_date = models.DateField()
# Make sure the supplied medicine is correct.
def clean(self):
if self.medicine.active_ingredient != self.prescription.active_ingredient:
raise ValidationError("Wrong medicine!")
Alternatively you could do the check only when a PersonStock is being created.