1137 lines
28 KiB
Python
1137 lines
28 KiB
Python
import datetime
|
|
import tempfile
|
|
import uuid
|
|
|
|
from django.contrib import admin
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.exceptions import ValidationError
|
|
from django.core.files.storage import FileSystemStorage
|
|
from django.db import models
|
|
|
|
|
|
class Section(models.Model):
|
|
"""
|
|
A simple section that links to articles, to test linking to related items
|
|
in admin views.
|
|
"""
|
|
|
|
name = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
@property
|
|
def name_property(self):
|
|
"""
|
|
A property that simply returns the name. Used to test #24461
|
|
"""
|
|
return self.name
|
|
|
|
|
|
class Article(models.Model):
|
|
"""
|
|
A simple article to test admin views. Test backwards compatibility.
|
|
"""
|
|
|
|
title = models.CharField(max_length=100)
|
|
content = models.TextField()
|
|
date = models.DateTimeField()
|
|
section = models.ForeignKey(Section, models.CASCADE, null=True, blank=True)
|
|
another_section = models.ForeignKey(
|
|
Section, models.CASCADE, null=True, blank=True, related_name="+"
|
|
)
|
|
sub_section = models.ForeignKey(
|
|
Section, models.SET_NULL, null=True, blank=True, related_name="+"
|
|
)
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
@admin.display(ordering="date", description="")
|
|
def model_year(self):
|
|
return self.date.year
|
|
|
|
@admin.display(ordering="-date", description="")
|
|
def model_year_reversed(self):
|
|
return self.date.year
|
|
|
|
@property
|
|
@admin.display(ordering="date")
|
|
def model_property_year(self):
|
|
return self.date.year
|
|
|
|
@property
|
|
def model_month(self):
|
|
return self.date.month
|
|
|
|
|
|
class Book(models.Model):
|
|
"""
|
|
A simple book that has chapters.
|
|
"""
|
|
|
|
name = models.CharField(max_length=100, verbose_name="¿Name?")
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Promo(models.Model):
|
|
name = models.CharField(max_length=100, verbose_name="¿Name?")
|
|
book = models.ForeignKey(Book, models.CASCADE)
|
|
author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Chapter(models.Model):
|
|
title = models.CharField(max_length=100, verbose_name="¿Title?")
|
|
content = models.TextField()
|
|
book = models.ForeignKey(Book, models.CASCADE)
|
|
|
|
class Meta:
|
|
# Use a utf-8 bytestring to ensure it works (see #11710)
|
|
verbose_name = "¿Chapter?"
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
|
|
class ChapterXtra1(models.Model):
|
|
chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?")
|
|
xtra = models.CharField(max_length=100, verbose_name="¿Xtra?")
|
|
guest_author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True)
|
|
|
|
def __str__(self):
|
|
return "¿Xtra1: %s" % self.xtra
|
|
|
|
|
|
class ChapterXtra2(models.Model):
|
|
chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?")
|
|
xtra = models.CharField(max_length=100, verbose_name="¿Xtra?")
|
|
|
|
def __str__(self):
|
|
return "¿Xtra2: %s" % self.xtra
|
|
|
|
|
|
class RowLevelChangePermissionModel(models.Model):
|
|
name = models.CharField(max_length=100, blank=True)
|
|
|
|
|
|
class CustomArticle(models.Model):
|
|
content = models.TextField()
|
|
date = models.DateTimeField()
|
|
|
|
|
|
class ModelWithStringPrimaryKey(models.Model):
|
|
string_pk = models.CharField(max_length=255, primary_key=True)
|
|
|
|
def __str__(self):
|
|
return self.string_pk
|
|
|
|
def get_absolute_url(self):
|
|
return "/dummy/%s/" % self.string_pk
|
|
|
|
|
|
class Color(models.Model):
|
|
value = models.CharField(max_length=10)
|
|
warm = models.BooleanField(default=False)
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
|
|
# we replicate Color to register with another ModelAdmin
|
|
class Color2(Color):
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
class Thing(models.Model):
|
|
title = models.CharField(max_length=20)
|
|
color = models.ForeignKey(Color, models.CASCADE, limit_choices_to={"warm": True})
|
|
pub_date = models.DateField(blank=True, null=True)
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
|
|
class Actor(models.Model):
|
|
name = models.CharField(max_length=50)
|
|
age = models.IntegerField()
|
|
title = models.CharField(max_length=50, null=True, blank=True)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Inquisition(models.Model):
|
|
expected = models.BooleanField(default=False)
|
|
leader = models.ForeignKey(Actor, models.CASCADE)
|
|
country = models.CharField(max_length=20)
|
|
|
|
def __str__(self):
|
|
return "by %s from %s" % (self.leader, self.country)
|
|
|
|
|
|
class Sketch(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
inquisition = models.ForeignKey(
|
|
Inquisition,
|
|
models.CASCADE,
|
|
limit_choices_to={
|
|
"leader__name": "Palin",
|
|
"leader__age": 27,
|
|
"expected": False,
|
|
},
|
|
)
|
|
defendant0 = models.ForeignKey(
|
|
Actor,
|
|
models.CASCADE,
|
|
limit_choices_to={"title__isnull": False},
|
|
related_name="as_defendant0",
|
|
)
|
|
defendant1 = models.ForeignKey(
|
|
Actor,
|
|
models.CASCADE,
|
|
limit_choices_to={"title__isnull": True},
|
|
related_name="as_defendant1",
|
|
)
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
|
|
def today_callable_dict():
|
|
return {"last_action__gte": datetime.datetime.today()}
|
|
|
|
|
|
def today_callable_q():
|
|
return models.Q(last_action__gte=datetime.datetime.today())
|
|
|
|
|
|
class Character(models.Model):
|
|
username = models.CharField(max_length=100)
|
|
last_action = models.DateTimeField()
|
|
|
|
def __str__(self):
|
|
return self.username
|
|
|
|
|
|
class StumpJoke(models.Model):
|
|
variation = models.CharField(max_length=100)
|
|
most_recently_fooled = models.ForeignKey(
|
|
Character,
|
|
models.CASCADE,
|
|
limit_choices_to=today_callable_dict,
|
|
related_name="+",
|
|
)
|
|
has_fooled_today = models.ManyToManyField(
|
|
Character, limit_choices_to=today_callable_q, related_name="+"
|
|
)
|
|
|
|
def __str__(self):
|
|
return self.variation
|
|
|
|
|
|
class Fabric(models.Model):
|
|
NG_CHOICES = (
|
|
(
|
|
"Textured",
|
|
(
|
|
("x", "Horizontal"),
|
|
("y", "Vertical"),
|
|
),
|
|
),
|
|
("plain", "Smooth"),
|
|
)
|
|
surface = models.CharField(max_length=20, choices=NG_CHOICES)
|
|
|
|
|
|
class Person(models.Model):
|
|
GENDER_CHOICES = (
|
|
(1, "Male"),
|
|
(2, "Female"),
|
|
)
|
|
name = models.CharField(max_length=100)
|
|
gender = models.IntegerField(choices=GENDER_CHOICES)
|
|
age = models.IntegerField(default=21)
|
|
alive = models.BooleanField(default=True)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Persona(models.Model):
|
|
"""
|
|
A simple persona associated with accounts, to test inlining of related
|
|
accounts which inherit from a common accounts class.
|
|
"""
|
|
|
|
name = models.CharField(blank=False, max_length=80)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Account(models.Model):
|
|
"""
|
|
A simple, generic account encapsulating the information shared by all
|
|
types of accounts.
|
|
"""
|
|
|
|
username = models.CharField(blank=False, max_length=80)
|
|
persona = models.ForeignKey(Persona, models.CASCADE, related_name="accounts")
|
|
servicename = "generic service"
|
|
|
|
def __str__(self):
|
|
return "%s: %s" % (self.servicename, self.username)
|
|
|
|
|
|
class FooAccount(Account):
|
|
"""A service-specific account of type Foo."""
|
|
|
|
servicename = "foo"
|
|
|
|
|
|
class BarAccount(Account):
|
|
"""A service-specific account of type Bar."""
|
|
|
|
servicename = "bar"
|
|
|
|
|
|
class Subscriber(models.Model):
|
|
name = models.CharField(blank=False, max_length=80)
|
|
email = models.EmailField(blank=False, max_length=175)
|
|
|
|
def __str__(self):
|
|
return "%s (%s)" % (self.name, self.email)
|
|
|
|
|
|
class ExternalSubscriber(Subscriber):
|
|
pass
|
|
|
|
|
|
class OldSubscriber(Subscriber):
|
|
pass
|
|
|
|
|
|
class Media(models.Model):
|
|
name = models.CharField(max_length=60)
|
|
|
|
|
|
class Podcast(Media):
|
|
release_date = models.DateField()
|
|
|
|
class Meta:
|
|
ordering = ("release_date",) # overridden in PodcastAdmin
|
|
|
|
|
|
class Vodcast(Media):
|
|
media = models.OneToOneField(
|
|
Media, models.CASCADE, primary_key=True, parent_link=True
|
|
)
|
|
released = models.BooleanField(default=False)
|
|
|
|
|
|
class Parent(models.Model):
|
|
name = models.CharField(max_length=128)
|
|
|
|
def clean(self):
|
|
if self.name == "_invalid":
|
|
raise ValidationError("invalid")
|
|
|
|
|
|
class Child(models.Model):
|
|
parent = models.ForeignKey(Parent, models.CASCADE, editable=False)
|
|
name = models.CharField(max_length=30, blank=True)
|
|
|
|
def clean(self):
|
|
if self.name == "_invalid":
|
|
raise ValidationError("invalid")
|
|
|
|
|
|
class PKChild(models.Model):
|
|
"""
|
|
Used to check autocomplete to_field resolution when ForeignKey is PK.
|
|
"""
|
|
|
|
parent = models.ForeignKey(Parent, models.CASCADE, primary_key=True)
|
|
name = models.CharField(max_length=128)
|
|
|
|
class Meta:
|
|
ordering = ["parent"]
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Toy(models.Model):
|
|
child = models.ForeignKey(PKChild, models.CASCADE)
|
|
|
|
|
|
class EmptyModel(models.Model):
|
|
def __str__(self):
|
|
return "Primary key = %s" % self.id
|
|
|
|
|
|
temp_storage = FileSystemStorage(tempfile.mkdtemp())
|
|
|
|
|
|
class Gallery(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class Picture(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
image = models.FileField(storage=temp_storage, upload_to="test_upload")
|
|
gallery = models.ForeignKey(Gallery, models.CASCADE, related_name="pictures")
|
|
|
|
|
|
class Language(models.Model):
|
|
iso = models.CharField(max_length=5, primary_key=True)
|
|
name = models.CharField(max_length=50)
|
|
english_name = models.CharField(max_length=50)
|
|
shortlist = models.BooleanField(default=False)
|
|
|
|
def __str__(self):
|
|
return self.iso
|
|
|
|
class Meta:
|
|
ordering = ("iso",)
|
|
|
|
|
|
# a base class for Recommender and Recommendation
|
|
class Title(models.Model):
|
|
pass
|
|
|
|
|
|
class TitleTranslation(models.Model):
|
|
title = models.ForeignKey(Title, models.CASCADE)
|
|
text = models.CharField(max_length=100)
|
|
|
|
|
|
class Recommender(Title):
|
|
pass
|
|
|
|
|
|
class Recommendation(Title):
|
|
the_recommender = models.ForeignKey(Recommender, models.CASCADE)
|
|
|
|
|
|
class Collector(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class Widget(models.Model):
|
|
owner = models.ForeignKey(Collector, models.CASCADE)
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class DooHickey(models.Model):
|
|
code = models.CharField(max_length=10, primary_key=True)
|
|
owner = models.ForeignKey(Collector, models.CASCADE)
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class Grommet(models.Model):
|
|
code = models.AutoField(primary_key=True)
|
|
owner = models.ForeignKey(Collector, models.CASCADE)
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class Whatsit(models.Model):
|
|
index = models.IntegerField(primary_key=True)
|
|
owner = models.ForeignKey(Collector, models.CASCADE)
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class Doodad(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
|
|
|
|
class FancyDoodad(Doodad):
|
|
owner = models.ForeignKey(Collector, models.CASCADE)
|
|
expensive = models.BooleanField(default=True)
|
|
|
|
|
|
class Category(models.Model):
|
|
collector = models.ForeignKey(Collector, models.CASCADE)
|
|
order = models.PositiveIntegerField()
|
|
|
|
class Meta:
|
|
ordering = ("order",)
|
|
|
|
def __str__(self):
|
|
return "%s:o%s" % (self.id, self.order)
|
|
|
|
|
|
def link_posted_default():
|
|
return datetime.date.today() - datetime.timedelta(days=7)
|
|
|
|
|
|
class Link(models.Model):
|
|
posted = models.DateField(default=link_posted_default)
|
|
url = models.URLField()
|
|
post = models.ForeignKey("Post", models.CASCADE)
|
|
readonly_link_content = models.TextField()
|
|
|
|
|
|
class PrePopulatedPost(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
published = models.BooleanField(default=False)
|
|
slug = models.SlugField()
|
|
|
|
|
|
class PrePopulatedSubPost(models.Model):
|
|
post = models.ForeignKey(PrePopulatedPost, models.CASCADE)
|
|
subtitle = models.CharField(max_length=100)
|
|
subslug = models.SlugField()
|
|
|
|
|
|
class Post(models.Model):
|
|
title = models.CharField(
|
|
max_length=100, help_text="Some help text for the title (with Unicode ŠĐĆŽćžšđ)"
|
|
)
|
|
content = models.TextField(
|
|
help_text="Some help text for the content (with Unicode ŠĐĆŽćžšđ)"
|
|
)
|
|
readonly_content = models.TextField()
|
|
posted = models.DateField(
|
|
default=datetime.date.today,
|
|
help_text="Some help text for the date (with Unicode ŠĐĆŽćžšđ)",
|
|
)
|
|
public = models.BooleanField(null=True, blank=True)
|
|
|
|
def awesomeness_level(self):
|
|
return "Very awesome."
|
|
|
|
|
|
# Proxy model to test overridden fields attrs on Post model so as not to
|
|
# interfere with other tests.
|
|
class FieldOverridePost(Post):
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
class Gadget(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Villain(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class SuperVillain(Villain):
|
|
pass
|
|
|
|
|
|
class FunkyTag(models.Model):
|
|
"Because we all know there's only one real use case for GFKs."
|
|
name = models.CharField(max_length=25)
|
|
content_type = models.ForeignKey(ContentType, models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = GenericForeignKey("content_type", "object_id")
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Plot(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
team_leader = models.ForeignKey(Villain, models.CASCADE, related_name="lead_plots")
|
|
contact = models.ForeignKey(Villain, models.CASCADE, related_name="contact_plots")
|
|
tags = GenericRelation(FunkyTag)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class PlotDetails(models.Model):
|
|
details = models.CharField(max_length=100)
|
|
plot = models.OneToOneField(Plot, models.CASCADE, null=True, blank=True)
|
|
|
|
def __str__(self):
|
|
return self.details
|
|
|
|
|
|
class PlotProxy(Plot):
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
class SecretHideout(models.Model):
|
|
"""Secret! Not registered with the admin!"""
|
|
|
|
location = models.CharField(max_length=100)
|
|
villain = models.ForeignKey(Villain, models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return self.location
|
|
|
|
|
|
class SuperSecretHideout(models.Model):
|
|
"""Secret! Not registered with the admin!"""
|
|
|
|
location = models.CharField(max_length=100)
|
|
supervillain = models.ForeignKey(SuperVillain, models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return self.location
|
|
|
|
|
|
class Bookmark(models.Model):
|
|
name = models.CharField(max_length=60)
|
|
tag = GenericRelation(FunkyTag, related_query_name="bookmark")
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class CyclicOne(models.Model):
|
|
name = models.CharField(max_length=25)
|
|
two = models.ForeignKey("CyclicTwo", models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class CyclicTwo(models.Model):
|
|
name = models.CharField(max_length=25)
|
|
one = models.ForeignKey(CyclicOne, models.CASCADE)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Topping(models.Model):
|
|
name = models.CharField(max_length=20)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Pizza(models.Model):
|
|
name = models.CharField(max_length=20)
|
|
toppings = models.ManyToManyField("Topping", related_name="pizzas")
|
|
|
|
|
|
# Pizza's ModelAdmin has readonly_fields = ['toppings'].
|
|
# toppings is editable for this model's admin.
|
|
class ReadablePizza(Pizza):
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
# No default permissions are created for this model and both name and toppings
|
|
# are readonly for this model's admin.
|
|
class ReadOnlyPizza(Pizza):
|
|
class Meta:
|
|
proxy = True
|
|
default_permissions = ()
|
|
|
|
|
|
class Album(models.Model):
|
|
owner = models.ForeignKey(User, models.SET_NULL, null=True, blank=True)
|
|
title = models.CharField(max_length=30)
|
|
|
|
|
|
class Song(models.Model):
|
|
name = models.CharField(max_length=20)
|
|
album = models.ForeignKey(Album, on_delete=models.RESTRICT)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Employee(Person):
|
|
code = models.CharField(max_length=20)
|
|
|
|
class Meta:
|
|
ordering = ["name"]
|
|
|
|
|
|
class WorkHour(models.Model):
|
|
datum = models.DateField()
|
|
employee = models.ForeignKey(Employee, models.CASCADE)
|
|
|
|
|
|
class Manager(Employee):
|
|
"""
|
|
A multi-layer MTI child.
|
|
"""
|
|
|
|
pass
|
|
|
|
|
|
class Bonus(models.Model):
|
|
recipient = models.ForeignKey(Manager, on_delete=models.CASCADE)
|
|
|
|
|
|
class Question(models.Model):
|
|
big_id = models.BigAutoField(primary_key=True)
|
|
question = models.CharField(max_length=20)
|
|
posted = models.DateField(default=datetime.date.today)
|
|
expires = models.DateTimeField(null=True, blank=True)
|
|
related_questions = models.ManyToManyField("self")
|
|
uuid = models.UUIDField(default=uuid.uuid4, unique=True)
|
|
|
|
def __str__(self):
|
|
return self.question
|
|
|
|
|
|
class Answer(models.Model):
|
|
question = models.ForeignKey(Question, models.PROTECT)
|
|
question_with_to_field = models.ForeignKey(
|
|
Question,
|
|
models.SET_NULL,
|
|
blank=True,
|
|
null=True,
|
|
to_field="uuid",
|
|
related_name="uuid_answers",
|
|
limit_choices_to=~models.Q(question__istartswith="not"),
|
|
)
|
|
related_answers = models.ManyToManyField("self")
|
|
answer = models.CharField(max_length=20)
|
|
|
|
def __str__(self):
|
|
return self.answer
|
|
|
|
|
|
class Answer2(Answer):
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
class Reservation(models.Model):
|
|
start_date = models.DateTimeField()
|
|
price = models.IntegerField()
|
|
|
|
|
|
class FoodDelivery(models.Model):
|
|
DRIVER_CHOICES = (
|
|
("bill", "Bill G"),
|
|
("steve", "Steve J"),
|
|
)
|
|
RESTAURANT_CHOICES = (
|
|
("indian", "A Taste of India"),
|
|
("thai", "Thai Pography"),
|
|
("pizza", "Pizza Mama"),
|
|
)
|
|
reference = models.CharField(max_length=100)
|
|
driver = models.CharField(max_length=100, choices=DRIVER_CHOICES, blank=True)
|
|
restaurant = models.CharField(
|
|
max_length=100, choices=RESTAURANT_CHOICES, blank=True
|
|
)
|
|
|
|
class Meta:
|
|
unique_together = (("driver", "restaurant"),)
|
|
|
|
|
|
class CoverLetter(models.Model):
|
|
author = models.CharField(max_length=30)
|
|
date_written = models.DateField(null=True, blank=True)
|
|
|
|
def __str__(self):
|
|
return self.author
|
|
|
|
|
|
class Paper(models.Model):
|
|
title = models.CharField(max_length=30)
|
|
author = models.CharField(max_length=30, blank=True, null=True)
|
|
|
|
|
|
class ShortMessage(models.Model):
|
|
content = models.CharField(max_length=140)
|
|
timestamp = models.DateTimeField(null=True, blank=True)
|
|
|
|
|
|
class Telegram(models.Model):
|
|
title = models.CharField(max_length=30)
|
|
date_sent = models.DateField(null=True, blank=True)
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
|
|
class Story(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
content = models.TextField()
|
|
|
|
|
|
class OtherStory(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
content = models.TextField()
|
|
|
|
|
|
class ComplexSortedPerson(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
age = models.PositiveIntegerField()
|
|
is_employee = models.BooleanField(null=True)
|
|
|
|
|
|
class PluggableSearchPerson(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
age = models.PositiveIntegerField()
|
|
|
|
|
|
class PrePopulatedPostLargeSlug(models.Model):
|
|
"""
|
|
Regression test for #15938: a large max_length for the slugfield must not
|
|
be localized in prepopulated_fields_js.html or it might end up breaking
|
|
the JavaScript (ie, using THOUSAND_SEPARATOR ends up with maxLength=1,000)
|
|
"""
|
|
|
|
title = models.CharField(max_length=100)
|
|
published = models.BooleanField(default=False)
|
|
# `db_index=False` because MySQL cannot index large CharField (#21196).
|
|
slug = models.SlugField(max_length=1000, db_index=False)
|
|
|
|
|
|
class AdminOrderedField(models.Model):
|
|
order = models.IntegerField()
|
|
stuff = models.CharField(max_length=200)
|
|
|
|
|
|
class AdminOrderedModelMethod(models.Model):
|
|
order = models.IntegerField()
|
|
stuff = models.CharField(max_length=200)
|
|
|
|
@admin.display(ordering="order")
|
|
def some_order(self):
|
|
return self.order
|
|
|
|
|
|
class AdminOrderedAdminMethod(models.Model):
|
|
order = models.IntegerField()
|
|
stuff = models.CharField(max_length=200)
|
|
|
|
|
|
class AdminOrderedCallable(models.Model):
|
|
order = models.IntegerField()
|
|
stuff = models.CharField(max_length=200)
|
|
|
|
|
|
class Report(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
|
|
class MainPrepopulated(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
pubdate = models.DateField()
|
|
status = models.CharField(
|
|
max_length=20,
|
|
choices=(("option one", "Option One"), ("option two", "Option Two")),
|
|
)
|
|
slug1 = models.SlugField(blank=True)
|
|
slug2 = models.SlugField(blank=True)
|
|
slug3 = models.SlugField(blank=True, allow_unicode=True)
|
|
|
|
|
|
class RelatedPrepopulated(models.Model):
|
|
parent = models.ForeignKey(MainPrepopulated, models.CASCADE)
|
|
name = models.CharField(max_length=75)
|
|
fk = models.ForeignKey("self", models.CASCADE, blank=True, null=True)
|
|
m2m = models.ManyToManyField("self", blank=True)
|
|
pubdate = models.DateField()
|
|
status = models.CharField(
|
|
max_length=20,
|
|
choices=(("option one", "Option One"), ("option two", "Option Two")),
|
|
)
|
|
slug1 = models.SlugField(max_length=50)
|
|
slug2 = models.SlugField(max_length=60)
|
|
|
|
|
|
class UnorderedObject(models.Model):
|
|
"""
|
|
Model without any defined `Meta.ordering`.
|
|
Refs #16819.
|
|
"""
|
|
|
|
name = models.CharField(max_length=255)
|
|
bool = models.BooleanField(default=True)
|
|
|
|
|
|
class UndeletableObject(models.Model):
|
|
"""
|
|
Model whose show_delete in admin change_view has been disabled
|
|
Refs #10057.
|
|
"""
|
|
|
|
name = models.CharField(max_length=255)
|
|
|
|
|
|
class UnchangeableObject(models.Model):
|
|
"""
|
|
Model whose change_view is disabled in admin
|
|
Refs #20640.
|
|
"""
|
|
|
|
|
|
class UserMessenger(models.Model):
|
|
"""
|
|
Dummy class for testing message_user functions on ModelAdmin
|
|
"""
|
|
|
|
|
|
class Simple(models.Model):
|
|
"""
|
|
Simple model with nothing on it for use in testing
|
|
"""
|
|
|
|
|
|
class Choice(models.Model):
|
|
choice = models.IntegerField(
|
|
blank=True,
|
|
null=True,
|
|
choices=((1, "Yes"), (0, "No"), (None, "No opinion")),
|
|
)
|
|
|
|
|
|
class ParentWithDependentChildren(models.Model):
|
|
"""
|
|
Issue #20522
|
|
Model where the validation of child foreign-key relationships depends
|
|
on validation of the parent
|
|
"""
|
|
|
|
some_required_info = models.PositiveIntegerField()
|
|
family_name = models.CharField(max_length=255, blank=False)
|
|
|
|
|
|
class DependentChild(models.Model):
|
|
"""
|
|
Issue #20522
|
|
Model that depends on validation of the parent class for one of its
|
|
fields to validate during clean
|
|
"""
|
|
|
|
parent = models.ForeignKey(ParentWithDependentChildren, models.CASCADE)
|
|
family_name = models.CharField(max_length=255)
|
|
|
|
|
|
class _Manager(models.Manager):
|
|
def get_queryset(self):
|
|
return super().get_queryset().filter(pk__gt=1)
|
|
|
|
|
|
class FilteredManager(models.Model):
|
|
def __str__(self):
|
|
return "PK=%d" % self.pk
|
|
|
|
pk_gt_1 = _Manager()
|
|
objects = models.Manager()
|
|
|
|
|
|
class EmptyModelVisible(models.Model):
|
|
"""See ticket #11277."""
|
|
|
|
|
|
class EmptyModelHidden(models.Model):
|
|
"""See ticket #11277."""
|
|
|
|
|
|
class EmptyModelMixin(models.Model):
|
|
"""See ticket #11277."""
|
|
|
|
|
|
class State(models.Model):
|
|
name = models.CharField(max_length=100, verbose_name="State verbose_name")
|
|
|
|
|
|
class City(models.Model):
|
|
state = models.ForeignKey(State, models.CASCADE)
|
|
name = models.CharField(max_length=100, verbose_name="City verbose_name")
|
|
|
|
def get_absolute_url(self):
|
|
return "/dummy/%s/" % self.pk
|
|
|
|
|
|
class Restaurant(models.Model):
|
|
city = models.ForeignKey(City, models.CASCADE)
|
|
name = models.CharField(max_length=100)
|
|
|
|
def get_absolute_url(self):
|
|
return "/dummy/%s/" % self.pk
|
|
|
|
|
|
class Worker(models.Model):
|
|
work_at = models.ForeignKey(Restaurant, models.CASCADE)
|
|
name = models.CharField(max_length=50)
|
|
surname = models.CharField(max_length=50)
|
|
|
|
|
|
# Models for #23329
|
|
class ReferencedByParent(models.Model):
|
|
name = models.CharField(max_length=20, unique=True)
|
|
|
|
|
|
class ParentWithFK(models.Model):
|
|
fk = models.ForeignKey(
|
|
ReferencedByParent,
|
|
models.CASCADE,
|
|
to_field="name",
|
|
related_name="hidden+",
|
|
)
|
|
|
|
|
|
class ChildOfReferer(ParentWithFK):
|
|
pass
|
|
|
|
|
|
# Models for #23431
|
|
class InlineReferer(models.Model):
|
|
pass
|
|
|
|
|
|
class ReferencedByInline(models.Model):
|
|
name = models.CharField(max_length=20, unique=True)
|
|
|
|
|
|
class InlineReference(models.Model):
|
|
referer = models.ForeignKey(InlineReferer, models.CASCADE)
|
|
fk = models.ForeignKey(
|
|
ReferencedByInline,
|
|
models.CASCADE,
|
|
to_field="name",
|
|
related_name="hidden+",
|
|
)
|
|
|
|
|
|
class Recipe(models.Model):
|
|
rname = models.CharField(max_length=20, unique=True)
|
|
|
|
|
|
class Ingredient(models.Model):
|
|
iname = models.CharField(max_length=20, unique=True)
|
|
recipes = models.ManyToManyField(Recipe, through="RecipeIngredient")
|
|
|
|
|
|
class RecipeIngredient(models.Model):
|
|
ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field="iname")
|
|
recipe = models.ForeignKey(Recipe, models.CASCADE, to_field="rname")
|
|
|
|
|
|
# Model for #23839
|
|
class NotReferenced(models.Model):
|
|
# Don't point any FK at this model.
|
|
pass
|
|
|
|
|
|
# Models for #23934
|
|
class ExplicitlyProvidedPK(models.Model):
|
|
name = models.IntegerField(primary_key=True)
|
|
|
|
|
|
class ImplicitlyGeneratedPK(models.Model):
|
|
name = models.IntegerField(unique=True)
|
|
|
|
|
|
# Models for #25622
|
|
class ReferencedByGenRel(models.Model):
|
|
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = GenericForeignKey("content_type", "object_id")
|
|
|
|
|
|
class GenRelReference(models.Model):
|
|
references = GenericRelation(ReferencedByGenRel)
|
|
|
|
|
|
class ParentWithUUIDPK(models.Model):
|
|
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
|
|
title = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
return str(self.id)
|
|
|
|
|
|
class RelatedWithUUIDPKModel(models.Model):
|
|
parent = models.ForeignKey(
|
|
ParentWithUUIDPK, on_delete=models.SET_NULL, null=True, blank=True
|
|
)
|
|
|
|
|
|
class Author(models.Model):
|
|
pass
|
|
|
|
|
|
class Authorship(models.Model):
|
|
book = models.ForeignKey(Book, models.CASCADE)
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
|
|
|
|
class UserProxy(User):
|
|
"""Proxy a model with a different app_label."""
|
|
|
|
class Meta:
|
|
proxy = True
|
|
|
|
|
|
class ReadOnlyRelatedField(models.Model):
|
|
chapter = models.ForeignKey(Chapter, models.CASCADE)
|
|
language = models.ForeignKey(Language, models.CASCADE)
|
|
user = models.ForeignKey(User, models.CASCADE)
|
|
|
|
|
|
class Héllo(models.Model):
|
|
pass
|
|
|
|
|
|
class Box(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
next_box = models.ForeignKey(
|
|
"self", null=True, on_delete=models.SET_NULL, blank=True
|
|
)
|
|
next_box = models.ForeignKey(
|
|
"self", null=True, on_delete=models.SET_NULL, blank=True
|
|
)
|
|
|
|
|
|
class Country(models.Model):
|
|
NORTH_AMERICA = "North America"
|
|
SOUTH_AMERICA = "South America"
|
|
EUROPE = "Europe"
|
|
ASIA = "Asia"
|
|
OCEANIA = "Oceania"
|
|
ANTARCTICA = "Antarctica"
|
|
|
|
CONTINENT_CHOICES = [
|
|
(NORTH_AMERICA, NORTH_AMERICA),
|
|
(SOUTH_AMERICA, SOUTH_AMERICA),
|
|
(EUROPE, EUROPE),
|
|
(ASIA, ASIA),
|
|
(OCEANIA, OCEANIA),
|
|
(ANTARCTICA, ANTARCTICA),
|
|
]
|
|
name = models.CharField(max_length=80)
|
|
continent = models.CharField(max_length=13, choices=CONTINENT_CHOICES)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Traveler(models.Model):
|
|
born_country = models.ForeignKey(Country, models.CASCADE)
|
|
living_country = models.ForeignKey(
|
|
Country, models.CASCADE, related_name="living_country_set"
|
|
)
|
|
favorite_country_to_vacation = models.ForeignKey(
|
|
Country,
|
|
models.CASCADE,
|
|
related_name="favorite_country_to_vacation_set",
|
|
limit_choices_to={"continent": Country.ASIA},
|
|
)
|