django/tests/delete/models.py

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models


class P(models.Model):
    pass


class R(models.Model):
    is_default = models.BooleanField(default=False)
    p = models.ForeignKey(P, models.CASCADE, null=True)


def get_default_r():
    return R.objects.get_or_create(is_default=True)[0].pk


class S(models.Model):
    r = models.ForeignKey(R, models.CASCADE)


class T(models.Model):
    s = models.ForeignKey(S, models.CASCADE)


class U(models.Model):
    t = models.ForeignKey(T, models.CASCADE)


class RChild(R):
    pass


class RProxy(R):
    class Meta:
        proxy = True


class RChildChild(RChild):
    pass


class A(models.Model):
    name = models.CharField(max_length=30)

    auto = models.ForeignKey(R, models.CASCADE, related_name="auto_set")
    auto_nullable = models.ForeignKey(
        R, models.CASCADE, null=True, related_name="auto_nullable_set"
    )
    setvalue = models.ForeignKey(R, models.SET(get_default_r), related_name="setvalue")
    setnull = models.ForeignKey(
        R, models.SET_NULL, null=True, related_name="setnull_set"
    )
    setdefault = models.ForeignKey(
        R, models.SET_DEFAULT, default=get_default_r, related_name="setdefault_set"
    )
    setdefault_none = models.ForeignKey(
        R,
        models.SET_DEFAULT,
        default=None,
        null=True,
        related_name="setnull_nullable_set",
    )
    cascade = models.ForeignKey(R, models.CASCADE, related_name="cascade_set")
    cascade_nullable = models.ForeignKey(
        R, models.CASCADE, null=True, related_name="cascade_nullable_set"
    )
    protect = models.ForeignKey(
        R, models.PROTECT, null=True, related_name="protect_set"
    )
    restrict = models.ForeignKey(
        R, models.RESTRICT, null=True, related_name="restrict_set"
    )
    donothing = models.ForeignKey(
        R, models.DO_NOTHING, null=True, related_name="donothing_set"
    )
    child = models.ForeignKey(RChild, models.CASCADE, related_name="child")
    child_setnull = models.ForeignKey(
        RChild, models.SET_NULL, null=True, related_name="child_setnull"
    )
    cascade_p = models.ForeignKey(
        P, models.CASCADE, related_name="cascade_p_set", null=True
    )

    # A OneToOneField is just a ForeignKey unique=True, so we don't duplicate
    # all the tests; just one smoke test to ensure on_delete works for it as
    # well.
    o2o_setnull = models.ForeignKey(
        R, models.SET_NULL, null=True, related_name="o2o_nullable_set"
    )


class B(models.Model):
    protect = models.ForeignKey(R, models.PROTECT)


def create_a(name):
    a = A(name=name)
    for name in (
        "auto",
        "auto_nullable",
        "setvalue",
        "setnull",
        "setdefault",
        "setdefault_none",
        "cascade",
        "cascade_nullable",
        "protect",
        "restrict",
        "donothing",
        "o2o_setnull",
    ):
        r = R.objects.create()
        setattr(a, name, r)
    a.child = RChild.objects.create()
    a.child_setnull = RChild.objects.create()
    a.save()
    return a


class M(models.Model):
    m2m = models.ManyToManyField(R, related_name="m_set")
    m2m_through = models.ManyToManyField(R, through="MR", related_name="m_through_set")
    m2m_through_null = models.ManyToManyField(
        R, through="MRNull", related_name="m_through_null_set"
    )


class MR(models.Model):
    m = models.ForeignKey(M, models.CASCADE)
    r = models.ForeignKey(R, models.CASCADE)


class MRNull(models.Model):
    m = models.ForeignKey(M, models.CASCADE)
    r = models.ForeignKey(R, models.SET_NULL, null=True)


class Avatar(models.Model):
    desc = models.TextField(null=True)


# This model is used to test a duplicate query regression (#25685)
class AvatarProxy(Avatar):
    class Meta:
        proxy = True


class User(models.Model):
    avatar = models.ForeignKey(Avatar, models.CASCADE, null=True)


class HiddenUser(models.Model):
    r = models.ForeignKey(R, models.CASCADE, related_name="+")


class HiddenUserProfile(models.Model):
    user = models.ForeignKey(HiddenUser, models.CASCADE)


class M2MTo(models.Model):
    pass


class M2MFrom(models.Model):
    m2m = models.ManyToManyField(M2MTo)


class Parent(models.Model):
    pass


class Child(Parent):
    pass


class Base(models.Model):
    pass


class RelToBase(models.Model):
    base = models.ForeignKey(Base, models.DO_NOTHING, related_name="rels")


class Origin(models.Model):
    r_proxy = models.ForeignKey("RProxy", models.CASCADE, null=True)


class Referrer(models.Model):
    origin = models.ForeignKey(Origin, models.CASCADE)
    unique_field = models.IntegerField(unique=True)
    large_field = models.TextField()


class SecondReferrer(models.Model):
    referrer = models.ForeignKey(Referrer, models.CASCADE)
    other_referrer = models.ForeignKey(
        Referrer, models.CASCADE, to_field="unique_field", related_name="+"
    )


class DeleteTop(models.Model):
    b1 = GenericRelation("GenericB1")
    b2 = GenericRelation("GenericB2")


class B1(models.Model):
    delete_top = models.ForeignKey(DeleteTop, models.CASCADE)


class B2(models.Model):
    delete_top = models.ForeignKey(DeleteTop, models.CASCADE)


class B3(models.Model):
    restrict = models.ForeignKey(R, models.RESTRICT)


class DeleteBottom(models.Model):
    b1 = models.ForeignKey(B1, models.RESTRICT)
    b2 = models.ForeignKey(B2, models.CASCADE)


class GenericB1(models.Model):
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    generic_delete_top = GenericForeignKey("content_type", "object_id")


class GenericB2(models.Model):
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    generic_delete_top = GenericForeignKey("content_type", "object_id")
    generic_delete_bottom = GenericRelation("GenericDeleteBottom")


class GenericDeleteBottom(models.Model):
    generic_b1 = models.ForeignKey(GenericB1, models.RESTRICT)
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    generic_b2 = GenericForeignKey()


class GenericDeleteBottomParent(models.Model):
    generic_delete_bottom = models.ForeignKey(
        GenericDeleteBottom, on_delete=models.CASCADE
    )