| 1 |
import datetime |
| 2 |
import tempfile |
| 3 |
import uuid |
| 4 |
|
| 5 |
from django.contrib import admin |
| 6 |
from django.contrib.auth.models import User |
| 7 |
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation |
| 8 |
from django.contrib.contenttypes.models import ContentType |
| 9 |
from django.core.exceptions import ValidationError |
| 10 |
from django.core.files.storage import FileSystemStorage |
| 11 |
from django.db import models |
| 12 |
from django.utils import timezone |
| 13 |
|
| 14 |
|
| 15 |
class Section(models.Model): |
| 16 |
""" |
| 17 |
A simple section that links to articles, to test linking to related items |
| 18 |
in admin views. |
| 19 |
""" |
| 20 |
|
| 21 |
name = models.CharField(max_length=100) |
| 22 |
|
| 23 |
def __str__(self): |
| 24 |
return self.name |
| 25 |
|
| 26 |
@property |
| 27 |
def name_property(self): |
| 28 |
""" |
| 29 |
A property that simply returns the name. Used to test #24461 |
| 30 |
""" |
| 31 |
return self.name |
| 32 |
|
| 33 |
|
| 34 |
class Article(models.Model): |
| 35 |
""" |
| 36 |
A simple article to test admin views. Test backwards compatibility. |
| 37 |
""" |
| 38 |
|
| 39 |
title = models.CharField(max_length=100) |
| 40 |
content = models.TextField() |
| 41 |
date = models.DateTimeField() |
| 42 |
section = models.ForeignKey(Section, models.CASCADE, null=True, blank=True) |
| 43 |
another_section = models.ForeignKey( |
| 44 |
Section, models.CASCADE, null=True, blank=True, related_name="+" |
| 45 |
) |
| 46 |
sub_section = models.ForeignKey( |
| 47 |
Section, models.SET_NULL, null=True, blank=True, related_name="+" |
| 48 |
) |
| 49 |
|
| 50 |
def __str__(self): |
| 51 |
return self.title |
| 52 |
|
| 53 |
@admin.display(ordering="date", description="") |
| 54 |
def model_year(self): |
| 55 |
return self.date.year |
| 56 |
|
| 57 |
@admin.display(ordering="-date", description="") |
| 58 |
def model_year_reversed(self): |
| 59 |
return self.date.year |
| 60 |
|
| 61 |
@property |
| 62 |
@admin.display(ordering="date") |
| 63 |
def model_property_year(self): |
| 64 |
return self.date.year |
| 65 |
|
| 66 |
@property |
| 67 |
def model_month(self): |
| 68 |
return self.date.month |
| 69 |
|
| 70 |
@property |
| 71 |
@admin.display(description="Is from past?", boolean=True) |
| 72 |
def model_property_is_from_past(self): |
| 73 |
return self.date < timezone.now() |
| 74 |
|
| 75 |
|
| 76 |
class Book(models.Model): |
| 77 |
""" |
| 78 |
A simple book that has chapters. |
| 79 |
""" |
| 80 |
|
| 81 |
name = models.CharField(max_length=100, verbose_name="¿Name?") |
| 82 |
|
| 83 |
def __str__(self): |
| 84 |
return self.name |
| 85 |
|
| 86 |
def get_absolute_url(self): |
| 87 |
return f"/books/{self.id}/" |
| 88 |
|
| 89 |
|
| 90 |
class Promo(models.Model): |
| 91 |
name = models.CharField(max_length=100, verbose_name="¿Name?") |
| 92 |
book = models.ForeignKey(Book, models.CASCADE) |
| 93 |
author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True) |
| 94 |
|
| 95 |
def __str__(self): |
| 96 |
return self.name |
| 97 |
|
| 98 |
|
| 99 |
class Chapter(models.Model): |
| 100 |
title = models.CharField(max_length=100, verbose_name="¿Title?") |
| 101 |
content = models.TextField() |
| 102 |
book = models.ForeignKey(Book, models.CASCADE) |
| 103 |
|
| 104 |
class Meta: |
| 105 |
# Use a utf-8 bytestring to ensure it works (see #11710) |
| 106 |
verbose_name = "¿Chapter?" |
| 107 |
|
| 108 |
def __str__(self): |
| 109 |
return self.title |
| 110 |
|
| 111 |
|
| 112 |
class ChapterXtra1(models.Model): |
| 113 |
chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?") |
| 114 |
xtra = models.CharField(max_length=100, verbose_name="¿Xtra?") |
| 115 |
guest_author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True) |
| 116 |
|
| 117 |
def __str__(self): |
| 118 |
return "¿Xtra1: %s" % self.xtra |
| 119 |
|
| 120 |
|
| 121 |
class ChapterXtra2(models.Model): |
| 122 |
chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?") |
| 123 |
xtra = models.CharField(max_length=100, verbose_name="¿Xtra?") |
| 124 |
|
| 125 |
def __str__(self): |
| 126 |
return "¿Xtra2: %s" % self.xtra |
| 127 |
|
| 128 |
|
| 129 |
class RowLevelChangePermissionModel(models.Model): |
| 130 |
name = models.CharField(max_length=100, blank=True) |
| 131 |
|
| 132 |
|
| 133 |
class CustomArticle(models.Model): |
| 134 |
content = models.TextField() |
| 135 |
date = models.DateTimeField() |
| 136 |
|
| 137 |
|
| 138 |
class ModelWithStringPrimaryKey(models.Model): |
| 139 |
string_pk = models.CharField(max_length=255, primary_key=True) |
| 140 |
|
| 141 |
def __str__(self): |
| 142 |
return self.string_pk |
| 143 |
|
| 144 |
def get_absolute_url(self): |
| 145 |
return "/dummy/%s/" % self.string_pk |
| 146 |
|
| 147 |
|
| 148 |
class Color(models.Model): |
| 149 |
value = models.CharField(max_length=10) |
| 150 |
warm = models.BooleanField(default=False) |
| 151 |
|
| 152 |
def __str__(self): |
| 153 |
return self.value |
| 154 |
|
| 155 |
|
| 156 |
# we replicate Color to register with another ModelAdmin |
| 157 |
class Color2(Color): |
| 158 |
class Meta: |
| 159 |
proxy = True |
| 160 |
|
| 161 |
|
| 162 |
class Thing(models.Model): |
| 163 |
title = models.CharField(max_length=20) |
| 164 |
color = models.ForeignKey(Color, models.CASCADE, limit_choices_to={"warm": True}) |
| 165 |
pub_date = models.DateField(blank=True, null=True) |
| 166 |
|
| 167 |
def __str__(self): |
| 168 |
return self.title |
| 169 |
|
| 170 |
|
| 171 |
class Actor(models.Model): |
| 172 |
name = models.CharField(max_length=50) |
| 173 |
age = models.IntegerField() |
| 174 |
title = models.CharField(max_length=50, null=True, blank=True) |
| 175 |
|
| 176 |
def __str__(self): |
| 177 |
return self.name |
| 178 |
|
| 179 |
|
| 180 |
class Inquisition(models.Model): |
| 181 |
expected = models.BooleanField(default=False) |
| 182 |
leader = models.ForeignKey(Actor, models.CASCADE) |
| 183 |
country = models.CharField(max_length=20) |
| 184 |
|
| 185 |
def __str__(self): |
| 186 |
return "by %s from %s" % (self.leader, self.country) |
| 187 |
|
| 188 |
|
| 189 |
class Sketch(models.Model): |
| 190 |
title = models.CharField(max_length=100) |
| 191 |
inquisition = models.ForeignKey( |
| 192 |
Inquisition, |
| 193 |
models.CASCADE, |
| 194 |
limit_choices_to={ |
| 195 |
"leader__name": "Palin", |
| 196 |
"leader__age": 27, |
| 197 |
"expected": False, |
| 198 |
}, |
| 199 |
) |
| 200 |
defendant0 = models.ForeignKey( |
| 201 |
Actor, |
| 202 |
models.CASCADE, |
| 203 |
limit_choices_to={"title__isnull": False}, |
| 204 |
related_name="as_defendant0", |
| 205 |
) |
| 206 |
defendant1 = models.ForeignKey( |
| 207 |
Actor, |
| 208 |
models.CASCADE, |
| 209 |
limit_choices_to={"title__isnull": True}, |
| 210 |
related_name="as_defendant1", |
| 211 |
) |
| 212 |
|
| 213 |
def __str__(self): |
| 214 |
return self.title |
| 215 |
|
| 216 |
|
| 217 |
def today_callable_dict(): |
| 218 |
return {"last_action__gte": datetime.datetime.today()} |
| 219 |
|
| 220 |
|
| 221 |
def today_callable_q(): |
| 222 |
return models.Q(last_action__gte=datetime.datetime.today()) |
| 223 |
|
| 224 |
|
| 225 |
class Character(models.Model): |
| 226 |
username = models.CharField(max_length=100) |
| 227 |
last_action = models.DateTimeField() |
| 228 |
|
| 229 |
def __str__(self): |
| 230 |
return self.username |
| 231 |
|
| 232 |
|
| 233 |
class StumpJoke(models.Model): |
| 234 |
variation = models.CharField(max_length=100) |
| 235 |
most_recently_fooled = models.ForeignKey( |
| 236 |
Character, |
| 237 |
models.CASCADE, |
| 238 |
limit_choices_to=today_callable_dict, |
| 239 |
related_name="+", |
| 240 |
) |
| 241 |
has_fooled_today = models.ManyToManyField( |
| 242 |
Character, limit_choices_to=today_callable_q, related_name="+" |
| 243 |
) |
| 244 |
|
| 245 |
def __str__(self): |
| 246 |
return self.variation |
| 247 |
|
| 248 |
|
| 249 |
class Fabric(models.Model): |
| 250 |
NG_CHOICES = ( |
| 251 |
( |
| 252 |
"Textured", |
| 253 |
( |
| 254 |
("x", "Horizontal"), |
| 255 |
("y", "Vertical"), |
| 256 |
), |
| 257 |
), |
| 258 |
("plain", "Smooth"), |
| 259 |
) |
| 260 |
surface = models.CharField(max_length=20, choices=NG_CHOICES) |
| 261 |
|
| 262 |
|
| 263 |
class Person(models.Model): |
| 264 |
GENDER_CHOICES = ( |
| 265 |
(1, "Male"), |
| 266 |
(2, "Female"), |
| 267 |
) |
| 268 |
name = models.CharField(max_length=100) |
| 269 |
gender = models.IntegerField(choices=GENDER_CHOICES) |
| 270 |
age = models.IntegerField(default=21) |
| 271 |
alive = models.BooleanField(default=True) |
| 272 |
|
| 273 |
def __str__(self): |
| 274 |
return self.name |
| 275 |
|
| 276 |
|
| 277 |
class Persona(models.Model): |
| 278 |
""" |
| 279 |
A simple persona associated with accounts, to test inlining of related |
| 280 |
accounts which inherit from a common accounts class. |
| 281 |
""" |
| 282 |
|
| 283 |
name = models.CharField(blank=False, max_length=80) |
| 284 |
|
| 285 |
def __str__(self): |
| 286 |
return self.name |
| 287 |
|
| 288 |
|
| 289 |
class Account(models.Model): |
| 290 |
""" |
| 291 |
A simple, generic account encapsulating the information shared by all |
| 292 |
types of accounts. |
| 293 |
""" |
| 294 |
|
| 295 |
username = models.CharField(blank=False, max_length=80) |
| 296 |
persona = models.ForeignKey(Persona, models.CASCADE, related_name="accounts") |
| 297 |
servicename = "generic service" |
| 298 |
|
| 299 |
def __str__(self): |
| 300 |
return "%s: %s" % (self.servicename, self.username) |
| 301 |
|
| 302 |
|
| 303 |
class FooAccount(Account): |
| 304 |
"""A service-specific account of type Foo.""" |
| 305 |
|
| 306 |
servicename = "foo" |
| 307 |
|
| 308 |
|
| 309 |
class BarAccount(Account): |
| 310 |
"""A service-specific account of type Bar.""" |
| 311 |
|
| 312 |
servicename = "bar" |
| 313 |
|
| 314 |
|
| 315 |
class Subscriber(models.Model): |
| 316 |
name = models.CharField(blank=False, max_length=80) |
| 317 |
email = models.EmailField(blank=False, max_length=175) |
| 318 |
|
| 319 |
def __str__(self): |
| 320 |
return "%s (%s)" % (self.name, self.email) |
| 321 |
|
| 322 |
|
| 323 |
class ExternalSubscriber(Subscriber): |
| 324 |
pass |
| 325 |
|
| 326 |
|
| 327 |
class OldSubscriber(Subscriber): |
| 328 |
pass |
| 329 |
|
| 330 |
|
| 331 |
class Media(models.Model): |
| 332 |
name = models.CharField(max_length=60) |
| 333 |
|
| 334 |
|
| 335 |
class Podcast(Media): |
| 336 |
release_date = models.DateField() |
| 337 |
|
| 338 |
class Meta: |
| 339 |
ordering = ("release_date",) # overridden in PodcastAdmin |
| 340 |
|
| 341 |
|
| 342 |
class Vodcast(Media): |
| 343 |
media = models.OneToOneField( |
| 344 |
Media, models.CASCADE, primary_key=True, parent_link=True |
| 345 |
) |
| 346 |
released = models.BooleanField(default=False) |
| 347 |
|
| 348 |
|
| 349 |
class Parent(models.Model): |
| 350 |
name = models.CharField(max_length=128) |
| 351 |
|
| 352 |
def clean(self): |
| 353 |
if self.name == "_invalid": |
| 354 |
raise ValidationError("invalid") |
| 355 |
|
| 356 |
|
| 357 |
class Child(models.Model): |
| 358 |
parent = models.ForeignKey(Parent, models.CASCADE, editable=False) |
| 359 |
name = models.CharField(max_length=30, blank=True) |
| 360 |
|
| 361 |
def clean(self): |
| 362 |
if self.name == "_invalid": |
| 363 |
raise ValidationError("invalid") |
| 364 |
|
| 365 |
|
| 366 |
class PKChild(models.Model): |
| 367 |
""" |
| 368 |
Used to check autocomplete to_field resolution when ForeignKey is PK. |
| 369 |
""" |
| 370 |
|
| 371 |
parent = models.ForeignKey(Parent, models.CASCADE, primary_key=True) |
| 372 |
name = models.CharField(max_length=128) |
| 373 |
|
| 374 |
class Meta: |
| 375 |
ordering = ["parent"] |
| 376 |
|
| 377 |
def __str__(self): |
| 378 |
return self.name |
| 379 |
|
| 380 |
|
| 381 |
class Toy(models.Model): |
| 382 |
child = models.ForeignKey(PKChild, models.CASCADE) |
| 383 |
|
| 384 |
|
| 385 |
class EmptyModel(models.Model): |
| 386 |
def __str__(self): |
| 387 |
return "Primary key = %s" % self.id |
| 388 |
|
| 389 |
|
| 390 |
temp_storage = FileSystemStorage(tempfile.mkdtemp()) |
| 391 |
|
| 392 |
|
| 393 |
class Gallery(models.Model): |
| 394 |
name = models.CharField(max_length=100) |
| 395 |
|
| 396 |
|
| 397 |
class Picture(models.Model): |
| 398 |
name = models.CharField(max_length=100) |
| 399 |
image = models.FileField(storage=temp_storage, upload_to="test_upload") |
| 400 |
gallery = models.ForeignKey(Gallery, models.CASCADE, related_name="pictures") |
| 401 |
|
| 402 |
|
| 403 |
class Language(models.Model): |
| 404 |
iso = models.CharField(max_length=5, primary_key=True) |
| 405 |
name = models.CharField(max_length=50) |
| 406 |
english_name = models.CharField(max_length=50) |
| 407 |
shortlist = models.BooleanField(default=False) |
| 408 |
|
| 409 |
def __str__(self): |
| 410 |
return self.iso |
| 411 |
|
| 412 |
class Meta: |
| 413 |
ordering = ("iso",) |
| 414 |
|
| 415 |
|
| 416 |
# a base class for Recommender and Recommendation |
| 417 |
class Title(models.Model): |
| 418 |
pass |
| 419 |
|
| 420 |
|
| 421 |
class TitleTranslation(models.Model): |
| 422 |
title = models.ForeignKey(Title, models.CASCADE) |
| 423 |
text = models.CharField(max_length=100) |
| 424 |
|
| 425 |
|
| 426 |
class Recommender(Title): |
| 427 |
pass |
| 428 |
|
| 429 |
|
| 430 |
class Recommendation(Title): |
| 431 |
the_recommender = models.ForeignKey(Recommender, models.CASCADE) |
| 432 |
|
| 433 |
|
| 434 |
class Collector(models.Model): |
| 435 |
name = models.CharField(max_length=100) |
| 436 |
|
| 437 |
|
| 438 |
class Widget(models.Model): |
| 439 |
owner = models.ForeignKey(Collector, models.CASCADE) |
| 440 |
name = models.CharField(max_length=100) |
| 441 |
|
| 442 |
|
| 443 |
class DooHickey(models.Model): |
| 444 |
code = models.CharField(max_length=10, primary_key=True) |
| 445 |
owner = models.ForeignKey(Collector, models.CASCADE) |
| 446 |
name = models.CharField(max_length=100) |
| 447 |
|
| 448 |
|
| 449 |
class Grommet(models.Model): |
| 450 |
code = models.AutoField(primary_key=True) |
| 451 |
owner = models.ForeignKey(Collector, models.CASCADE) |
| 452 |
name = models.CharField(max_length=100) |
| 453 |
|
| 454 |
|
| 455 |
class Whatsit(models.Model): |
| 456 |
index = models.IntegerField(primary_key=True) |
| 457 |
owner = models.ForeignKey(Collector, models.CASCADE) |
| 458 |
name = models.CharField(max_length=100) |
| 459 |
|
| 460 |
|
| 461 |
class Doodad(models.Model): |
| 462 |
name = models.CharField(max_length=100) |
| 463 |
|
| 464 |
|
| 465 |
class FancyDoodad(Doodad): |
| 466 |
owner = models.ForeignKey(Collector, models.CASCADE) |
| 467 |
expensive = models.BooleanField(default=True) |
| 468 |
|
| 469 |
|
| 470 |
class Category(models.Model): |
| 471 |
collector = models.ForeignKey(Collector, models.CASCADE) |
| 472 |
order = models.PositiveIntegerField() |
| 473 |
|
| 474 |
class Meta: |
| 475 |
ordering = ("order",) |
| 476 |
|
| 477 |
def __str__(self): |
| 478 |
return "%s:o%s" % (self.id, self.order) |
| 479 |
|
| 480 |
|
| 481 |
def link_posted_default(): |
| 482 |
return datetime.date.today() - datetime.timedelta(days=7) |
| 483 |
|
| 484 |
|
| 485 |
class Link(models.Model): |
| 486 |
posted = models.DateField(default=link_posted_default) |
| 487 |
url = models.URLField() |
| 488 |
post = models.ForeignKey("Post", models.CASCADE) |
| 489 |
readonly_link_content = models.TextField() |
| 490 |
|
| 491 |
|
| 492 |
class PrePopulatedPost(models.Model): |
| 493 |
title = models.CharField(max_length=100) |
| 494 |
published = models.BooleanField(default=False) |
| 495 |
slug = models.SlugField() |
| 496 |
|
| 497 |
|
| 498 |
class PrePopulatedSubPost(models.Model): |
| 499 |
post = models.ForeignKey(PrePopulatedPost, models.CASCADE) |
| 500 |
subtitle = models.CharField(max_length=100) |
| 501 |
subslug = models.SlugField() |
| 502 |
|
| 503 |
|
| 504 |
class Post(models.Model): |
| 505 |
title = models.CharField( |
| 506 |
max_length=100, help_text="Some help text for the title (with Unicode ŠĐĆŽćžšđ)" |
| 507 |
) |
| 508 |
content = models.TextField( |
| 509 |
help_text="Some help text for the content (with Unicode ŠĐĆŽćžšđ)" |
| 510 |
) |
| 511 |
readonly_content = models.TextField() |
| 512 |
posted = models.DateField( |
| 513 |
default=datetime.date.today, |
| 514 |
help_text="Some help text for the date (with Unicode ŠĐĆŽćžšđ)", |
| 515 |
) |
| 516 |
public = models.BooleanField(null=True, blank=True) |
| 517 |
|
| 518 |
def awesomeness_level(self): |
| 519 |
return "Very awesome." |
| 520 |
|
| 521 |
|
| 522 |
# Proxy model to test overridden fields attrs on Post model so as not to |
| 523 |
# interfere with other tests. |
| 524 |
class FieldOverridePost(Post): |
| 525 |
class Meta: |
| 526 |
proxy = True |
| 527 |
|
| 528 |
|
| 529 |
class Gadget(models.Model): |
| 530 |
name = models.CharField(max_length=100) |
| 531 |
|
| 532 |
def __str__(self): |
| 533 |
return self.name |
| 534 |
|
| 535 |
|
| 536 |
class Villain(models.Model): |
| 537 |
name = models.CharField(max_length=100) |
| 538 |
|
| 539 |
def __str__(self): |
| 540 |
return self.name |
| 541 |
|
| 542 |
|
| 543 |
class SuperVillain(Villain): |
| 544 |
pass |
| 545 |
|
| 546 |
|
| 547 |
class FunkyTag(models.Model): |
| 548 |
"Because we all know there's only one real use case for GFKs." |
| 549 |
|
| 550 |
name = models.CharField(max_length=25) |
| 551 |
content_type = models.ForeignKey(ContentType, models.CASCADE) |
| 552 |
object_id = models.PositiveIntegerField() |
| 553 |
content_object = GenericForeignKey("content_type", "object_id") |
| 554 |
|
| 555 |
def __str__(self): |
| 556 |
return self.name |
| 557 |
|
| 558 |
|
| 559 |
class Plot(models.Model): |
| 560 |
name = models.CharField(max_length=100) |
| 561 |
team_leader = models.ForeignKey(Villain, models.CASCADE, related_name="lead_plots") |
| 562 |
contact = models.ForeignKey(Villain, models.CASCADE, related_name="contact_plots") |
| 563 |
tags = GenericRelation(FunkyTag) |
| 564 |
|
| 565 |
def __str__(self): |
| 566 |
return self.name |
| 567 |
|
| 568 |
|
| 569 |
class PlotDetails(models.Model): |
| 570 |
details = models.CharField(max_length=100) |
| 571 |
plot = models.OneToOneField(Plot, models.CASCADE, null=True, blank=True) |
| 572 |
|
| 573 |
def __str__(self): |
| 574 |
return self.details |
| 575 |
|
| 576 |
|
| 577 |
class PlotProxy(Plot): |
| 578 |
class Meta: |
| 579 |
proxy = True |
| 580 |
|
| 581 |
|
| 582 |
class SecretHideout(models.Model): |
| 583 |
"""Secret! Not registered with the admin!""" |
| 584 |
|
| 585 |
location = models.CharField(max_length=100) |
| 586 |
villain = models.ForeignKey(Villain, models.CASCADE) |
| 587 |
|
| 588 |
def __str__(self): |
| 589 |
return self.location |
| 590 |
|
| 591 |
|
| 592 |
class SuperSecretHideout(models.Model): |
| 593 |
"""Secret! Not registered with the admin!""" |
| 594 |
|
| 595 |
location = models.CharField(max_length=100) |
| 596 |
supervillain = models.ForeignKey(SuperVillain, models.CASCADE) |
| 597 |
|
| 598 |
def __str__(self): |
| 599 |
return self.location |
| 600 |
|
| 601 |
|
| 602 |
class Bookmark(models.Model): |
| 603 |
name = models.CharField(max_length=60) |
| 604 |
tag = GenericRelation(FunkyTag, related_query_name="bookmark") |
| 605 |
|
| 606 |
def __str__(self): |
| 607 |
return self.name |
| 608 |
|
| 609 |
|
| 610 |
class CyclicOne(models.Model): |
| 611 |
name = models.CharField(max_length=25) |
| 612 |
two = models.ForeignKey("CyclicTwo", models.CASCADE) |
| 613 |
|
| 614 |
def __str__(self): |
| 615 |
return self.name |
| 616 |
|
| 617 |
|
| 618 |
class CyclicTwo(models.Model): |
| 619 |
name = models.CharField(max_length=25) |
| 620 |
one = models.ForeignKey(CyclicOne, models.CASCADE) |
| 621 |
|
| 622 |
def __str__(self): |
| 623 |
return self.name |
| 624 |
|
| 625 |
|
| 626 |
class Topping(models.Model): |
| 627 |
name = models.CharField(max_length=20) |
| 628 |
|
| 629 |
def __str__(self): |
| 630 |
return self.name |
| 631 |
|
| 632 |
|
| 633 |
class Pizza(models.Model): |
| 634 |
name = models.CharField(max_length=20) |
| 635 |
toppings = models.ManyToManyField("Topping", related_name="pizzas") |
| 636 |
|
| 637 |
|
| 638 |
# Pizza's ModelAdmin has readonly_fields = ['toppings']. |
| 639 |
# toppings is editable for this model's admin. |
| 640 |
class ReadablePizza(Pizza): |
| 641 |
class Meta: |
| 642 |
proxy = True |
| 643 |
|
| 644 |
|
| 645 |
# No default permissions are created for this model and both name and toppings |
| 646 |
# are readonly for this model's admin. |
| 647 |
class ReadOnlyPizza(Pizza): |
| 648 |
class Meta: |
| 649 |
proxy = True |
| 650 |
default_permissions = () |
| 651 |
|
| 652 |
|
| 653 |
class Album(models.Model): |
| 654 |
owner = models.ForeignKey(User, models.SET_NULL, null=True, blank=True) |
| 655 |
title = models.CharField(max_length=30) |
| 656 |
|
| 657 |
|
| 658 |
class Song(models.Model): |
| 659 |
name = models.CharField(max_length=20) |
| 660 |
album = models.ForeignKey(Album, on_delete=models.RESTRICT) |
| 661 |
|
| 662 |
def __str__(self): |
| 663 |
return self.name |
| 664 |
|
| 665 |
|
| 666 |
class Employee(Person): |
| 667 |
code = models.CharField(max_length=20) |
| 668 |
|
| 669 |
class Meta: |
| 670 |
ordering = ["name"] |
| 671 |
|
| 672 |
|
| 673 |
class WorkHour(models.Model): |
| 674 |
datum = models.DateField() |
| 675 |
employee = models.ForeignKey(Employee, models.CASCADE) |
| 676 |
|
| 677 |
|
| 678 |
class Manager(Employee): |
| 679 |
""" |
| 680 |
A multi-layer MTI child. |
| 681 |
""" |
| 682 |
|
| 683 |
pass |
| 684 |
|
| 685 |
|
| 686 |
class Bonus(models.Model): |
| 687 |
recipient = models.ForeignKey(Manager, on_delete=models.CASCADE) |
| 688 |
|
| 689 |
|
| 690 |
class Question(models.Model): |
| 691 |
big_id = models.BigAutoField(primary_key=True) |
| 692 |
question = models.CharField(max_length=20) |
| 693 |
posted = models.DateField(default=datetime.date.today) |
| 694 |
expires = models.DateTimeField(null=True, blank=True) |
| 695 |
related_questions = models.ManyToManyField("self") |
| 696 |
uuid = models.UUIDField(default=uuid.uuid4, unique=True) |
| 697 |
|
| 698 |
def __str__(self): |
| 699 |
return self.question |
| 700 |
|
| 701 |
|
| 702 |
class Answer(models.Model): |
| 703 |
question = models.ForeignKey(Question, models.PROTECT) |
| 704 |
question_with_to_field = models.ForeignKey( |
| 705 |
Question, |
| 706 |
models.SET_NULL, |
| 707 |
blank=True, |
| 708 |
null=True, |
| 709 |
to_field="uuid", |
| 710 |
related_name="uuid_answers", |
| 711 |
limit_choices_to=~models.Q(question__istartswith="not"), |
| 712 |
) |
| 713 |
related_answers = models.ManyToManyField("self") |
| 714 |
answer = models.CharField(max_length=20) |
| 715 |
|
| 716 |
def __str__(self): |
| 717 |
return self.answer |
| 718 |
|
| 719 |
|
| 720 |
class Answer2(Answer): |
| 721 |
class Meta: |
| 722 |
proxy = True |
| 723 |
|
| 724 |
|
| 725 |
class Reservation(models.Model): |
| 726 |
start_date = models.DateTimeField() |
| 727 |
price = models.IntegerField() |
| 728 |
|
| 729 |
|
| 730 |
class FoodDelivery(models.Model): |
| 731 |
DRIVER_CHOICES = ( |
| 732 |
("bill", "Bill G"), |
| 733 |
("steve", "Steve J"), |
| 734 |
) |
| 735 |
RESTAURANT_CHOICES = ( |
| 736 |
("indian", "A Taste of India"), |
| 737 |
("thai", "Thai Pography"), |
| 738 |
("pizza", "Pizza Mama"), |
| 739 |
) |
| 740 |
reference = models.CharField(max_length=100) |
| 741 |
driver = models.CharField(max_length=100, choices=DRIVER_CHOICES, blank=True) |
| 742 |
restaurant = models.CharField( |
| 743 |
max_length=100, choices=RESTAURANT_CHOICES, blank=True |
| 744 |
) |
| 745 |
|
| 746 |
class Meta: |
| 747 |
unique_together = (("driver", "restaurant"),) |
| 748 |
|
| 749 |
|
| 750 |
class CoverLetter(models.Model): |
| 751 |
author = models.CharField(max_length=30) |
| 752 |
date_written = models.DateField(null=True, blank=True) |
| 753 |
|
| 754 |
def __str__(self): |
| 755 |
return self.author |
| 756 |
|
| 757 |
|
| 758 |
class Paper(models.Model): |
| 759 |
title = models.CharField(max_length=30) |
| 760 |
author = models.CharField(max_length=30, blank=True, null=True) |
| 761 |
|
| 762 |
|
| 763 |
class ShortMessage(models.Model): |
| 764 |
content = models.CharField(max_length=140) |
| 765 |
timestamp = models.DateTimeField(null=True, blank=True) |
| 766 |
|
| 767 |
|
| 768 |
class Telegram(models.Model): |
| 769 |
title = models.CharField(max_length=30) |
| 770 |
date_sent = models.DateField(null=True, blank=True) |
| 771 |
|
| 772 |
def __str__(self): |
| 773 |
return self.title |
| 774 |
|
| 775 |
|
| 776 |
class Story(models.Model): |
| 777 |
title = models.CharField(max_length=100) |
| 778 |
content = models.TextField() |
| 779 |
|
| 780 |
|
| 781 |
class OtherStory(models.Model): |
| 782 |
title = models.CharField(max_length=100) |
| 783 |
content = models.TextField() |
| 784 |
|
| 785 |
|
| 786 |
class ComplexSortedPerson(models.Model): |
| 787 |
name = models.CharField(max_length=100) |
| 788 |
age = models.PositiveIntegerField() |
| 789 |
is_employee = models.BooleanField(null=True) |
| 790 |
|
| 791 |
|
| 792 |
class PluggableSearchPerson(models.Model): |
| 793 |
name = models.CharField(max_length=100) |
| 794 |
age = models.PositiveIntegerField() |
| 795 |
|
| 796 |
|
| 797 |
class PrePopulatedPostLargeSlug(models.Model): |
| 798 |
""" |
| 799 |
Regression test for #15938: a large max_length for the slugfield must not |
| 800 |
be localized in prepopulated_fields_js.html or it might end up breaking |
| 801 |
the JavaScript (ie, using THOUSAND_SEPARATOR ends up with maxLength=1,000) |
| 802 |
""" |
| 803 |
|
| 804 |
title = models.CharField(max_length=100) |
| 805 |
published = models.BooleanField(default=False) |
| 806 |
# `db_index=False` because MySQL cannot index large CharField (#21196). |
| 807 |
slug = models.SlugField(max_length=1000, db_index=False) |
| 808 |
|
| 809 |
|
| 810 |
class AdminOrderedField(models.Model): |
| 811 |
order = models.IntegerField() |
| 812 |
stuff = models.CharField(max_length=200) |
| 813 |
|
| 814 |
|
| 815 |
class AdminOrderedModelMethod(models.Model): |
| 816 |
order = models.IntegerField() |
| 817 |
stuff = models.CharField(max_length=200) |
| 818 |
|
| 819 |
@admin.display(ordering="order") |
| 820 |
def some_order(self): |
| 821 |
return self.order |
| 822 |
|
| 823 |
|
| 824 |
class AdminOrderedAdminMethod(models.Model): |
| 825 |
order = models.IntegerField() |
| 826 |
stuff = models.CharField(max_length=200) |
| 827 |
|
| 828 |
|
| 829 |
class AdminOrderedCallable(models.Model): |
| 830 |
order = models.IntegerField() |
| 831 |
stuff = models.CharField(max_length=200) |
| 832 |
|
| 833 |
|
| 834 |
class Report(models.Model): |
| 835 |
title = models.CharField(max_length=100) |
| 836 |
|
| 837 |
def __str__(self): |
| 838 |
return self.title |
| 839 |
|
| 840 |
|
| 841 |
class MainPrepopulated(models.Model): |
| 842 |
name = models.CharField(max_length=100) |
| 843 |
pubdate = models.DateField() |
| 844 |
status = models.CharField( |
| 845 |
max_length=20, |
| 846 |
choices=(("option one", "Option One"), ("option two", "Option Two")), |
| 847 |
) |
| 848 |
slug1 = models.SlugField(blank=True) |
| 849 |
slug2 = models.SlugField(blank=True) |
| 850 |
slug3 = models.SlugField(blank=True, allow_unicode=True) |
| 851 |
|
| 852 |
|
| 853 |
class RelatedPrepopulated(models.Model): |
| 854 |
parent = models.ForeignKey(MainPrepopulated, models.CASCADE) |
| 855 |
name = models.CharField(max_length=75) |
| 856 |
fk = models.ForeignKey("self", models.CASCADE, blank=True, null=True) |
| 857 |
m2m = models.ManyToManyField("self", blank=True) |
| 858 |
pubdate = models.DateField() |
| 859 |
status = models.CharField( |
| 860 |
max_length=20, |
| 861 |
choices=(("option one", "Option One"), ("option two", "Option Two")), |
| 862 |
) |
| 863 |
slug1 = models.SlugField(max_length=50) |
| 864 |
slug2 = models.SlugField(max_length=60) |
| 865 |
|
| 866 |
|
| 867 |
class UnorderedObject(models.Model): |
| 868 |
""" |
| 869 |
Model without any defined `Meta.ordering`. |
| 870 |
Refs #16819. |
| 871 |
""" |
| 872 |
|
| 873 |
name = models.CharField(max_length=255) |
| 874 |
bool = models.BooleanField(default=True) |
| 875 |
|
| 876 |
|
| 877 |
class UndeletableObject(models.Model): |
| 878 |
""" |
| 879 |
Model whose show_delete in admin change_view has been disabled |
| 880 |
Refs #10057. |
| 881 |
""" |
| 882 |
|
| 883 |
name = models.CharField(max_length=255) |
| 884 |
|
| 885 |
|
| 886 |
class UnchangeableObject(models.Model): |
| 887 |
""" |
| 888 |
Model whose change_view is disabled in admin |
| 889 |
Refs #20640. |
| 890 |
""" |
| 891 |
|
| 892 |
|
| 893 |
class UserMessenger(models.Model): |
| 894 |
""" |
| 895 |
Dummy class for testing message_user functions on ModelAdmin |
| 896 |
""" |
| 897 |
|
| 898 |
|
| 899 |
class Simple(models.Model): |
| 900 |
""" |
| 901 |
Simple model with nothing on it for use in testing |
| 902 |
""" |
| 903 |
|
| 904 |
|
| 905 |
class Choice(models.Model): |
| 906 |
choice = models.IntegerField( |
| 907 |
blank=True, |
| 908 |
null=True, |
| 909 |
choices=((1, "Yes"), (0, "No"), (None, "No opinion")), |
| 910 |
) |
| 911 |
|
| 912 |
|
| 913 |
class ParentWithDependentChildren(models.Model): |
| 914 |
""" |
| 915 |
Issue #20522 |
| 916 |
Model where the validation of child foreign-key relationships depends |
| 917 |
on validation of the parent |
| 918 |
""" |
| 919 |
|
| 920 |
some_required_info = models.PositiveIntegerField() |
| 921 |
family_name = models.CharField(max_length=255, blank=False) |
| 922 |
|
| 923 |
|
| 924 |
class DependentChild(models.Model): |
| 925 |
""" |
| 926 |
Issue #20522 |
| 927 |
Model that depends on validation of the parent class for one of its |
| 928 |
fields to validate during clean |
| 929 |
""" |
| 930 |
|
| 931 |
parent = models.ForeignKey(ParentWithDependentChildren, models.CASCADE) |
| 932 |
family_name = models.CharField(max_length=255) |
| 933 |
|
| 934 |
|
| 935 |
class _Manager(models.Manager): |
| 936 |
def get_queryset(self): |
| 937 |
return super().get_queryset().filter(pk__gt=1) |
| 938 |
|
| 939 |
|
| 940 |
class FilteredManager(models.Model): |
| 941 |
def __str__(self): |
| 942 |
return "PK=%d" % self.pk |
| 943 |
|
| 944 |
pk_gt_1 = _Manager() |
| 945 |
objects = models.Manager() |
| 946 |
|
| 947 |
|
| 948 |
class EmptyModelVisible(models.Model): |
| 949 |
"""See ticket #11277.""" |
| 950 |
|
| 951 |
|
| 952 |
class EmptyModelHidden(models.Model): |
| 953 |
"""See ticket #11277.""" |
| 954 |
|
| 955 |
|
| 956 |
class EmptyModelMixin(models.Model): |
| 957 |
"""See ticket #11277.""" |
| 958 |
|
| 959 |
|
| 960 |
class State(models.Model): |
| 961 |
name = models.CharField(max_length=100, verbose_name="State verbose_name") |
| 962 |
|
| 963 |
|
| 964 |
class City(models.Model): |
| 965 |
state = models.ForeignKey(State, models.CASCADE) |
| 966 |
name = models.CharField(max_length=100, verbose_name="City verbose_name") |
| 967 |
|
| 968 |
def get_absolute_url(self): |
| 969 |
return "/dummy/%s/" % self.pk |
| 970 |
|
| 971 |
|
| 972 |
class Restaurant(models.Model): |
| 973 |
city = models.ForeignKey(City, models.CASCADE) |
| 974 |
name = models.CharField(max_length=100) |
| 975 |
|
| 976 |
def get_absolute_url(self): |
| 977 |
return "/dummy/%s/" % self.pk |
| 978 |
|
| 979 |
|
| 980 |
class Worker(models.Model): |
| 981 |
work_at = models.ForeignKey(Restaurant, models.CASCADE) |
| 982 |
name = models.CharField(max_length=50) |
| 983 |
surname = models.CharField(max_length=50) |
| 984 |
|
| 985 |
|
| 986 |
# Models for #23329 |
| 987 |
class ReferencedByParent(models.Model): |
| 988 |
name = models.CharField(max_length=20, unique=True) |
| 989 |
|
| 990 |
|
| 991 |
class ParentWithFK(models.Model): |
| 992 |
fk = models.ForeignKey( |
| 993 |
ReferencedByParent, |
| 994 |
models.CASCADE, |
| 995 |
to_field="name", |
| 996 |
related_name="hidden+", |
| 997 |
) |
| 998 |
|
| 999 |
|
| 1000 |
class ChildOfReferer(ParentWithFK): |
| 1001 |
pass |
| 1002 |
|
| 1003 |
|
| 1004 |
# Models for #23431 |
| 1005 |
class InlineReferer(models.Model): |
| 1006 |
pass |
| 1007 |
|
| 1008 |
|
| 1009 |
class ReferencedByInline(models.Model): |
| 1010 |
name = models.CharField(max_length=20, unique=True) |
| 1011 |
|
| 1012 |
|
| 1013 |
class InlineReference(models.Model): |
| 1014 |
referer = models.ForeignKey(InlineReferer, models.CASCADE) |
| 1015 |
fk = models.ForeignKey( |
| 1016 |
ReferencedByInline, |
| 1017 |
models.CASCADE, |
| 1018 |
to_field="name", |
| 1019 |
related_name="hidden+", |
| 1020 |
) |
| 1021 |
|
| 1022 |
|
| 1023 |
class Recipe(models.Model): |
| 1024 |
rname = models.CharField(max_length=20, unique=True) |
| 1025 |
|
| 1026 |
|
| 1027 |
class Ingredient(models.Model): |
| 1028 |
iname = models.CharField(max_length=20, unique=True) |
| 1029 |
recipes = models.ManyToManyField(Recipe, through="RecipeIngredient") |
| 1030 |
|
| 1031 |
|
| 1032 |
class RecipeIngredient(models.Model): |
| 1033 |
ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field="iname") |
| 1034 |
recipe = models.ForeignKey(Recipe, models.CASCADE, to_field="rname") |
| 1035 |
|
| 1036 |
|
| 1037 |
# Model for #23839 |
| 1038 |
class NotReferenced(models.Model): |
| 1039 |
# Don't point any FK at this model. |
| 1040 |
pass |
| 1041 |
|
| 1042 |
|
| 1043 |
# Models for #23934 |
| 1044 |
class ExplicitlyProvidedPK(models.Model): |
| 1045 |
name = models.IntegerField(primary_key=True) |
| 1046 |
|
| 1047 |
|
| 1048 |
class ImplicitlyGeneratedPK(models.Model): |
| 1049 |
name = models.IntegerField(unique=True) |
| 1050 |
|
| 1051 |
|
| 1052 |
# Models for #25622 |
| 1053 |
class ReferencedByGenRel(models.Model): |
| 1054 |
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE) |
| 1055 |
object_id = models.PositiveIntegerField() |
| 1056 |
content_object = GenericForeignKey("content_type", "object_id") |
| 1057 |
|
| 1058 |
|
| 1059 |
class GenRelReference(models.Model): |
| 1060 |
references = GenericRelation(ReferencedByGenRel) |
| 1061 |
|
| 1062 |
|
| 1063 |
class ParentWithUUIDPK(models.Model): |
| 1064 |
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) |
| 1065 |
title = models.CharField(max_length=100) |
| 1066 |
|
| 1067 |
def __str__(self): |
| 1068 |
return str(self.id) |
| 1069 |
|
| 1070 |
|
| 1071 |
class RelatedWithUUIDPKModel(models.Model): |
| 1072 |
parent = models.ForeignKey( |
| 1073 |
ParentWithUUIDPK, on_delete=models.SET_NULL, null=True, blank=True |
| 1074 |
) |
| 1075 |
|
| 1076 |
|
| 1077 |
class Author(models.Model): |
| 1078 |
pass |
| 1079 |
|
| 1080 |
|
| 1081 |
class Authorship(models.Model): |
| 1082 |
book = models.ForeignKey(Book, models.CASCADE) |
| 1083 |
author = models.ForeignKey(Author, models.CASCADE) |
| 1084 |
|
| 1085 |
|
| 1086 |
class UserProxy(User): |
| 1087 |
"""Proxy a model with a different app_label.""" |
| 1088 |
|
| 1089 |
class Meta: |
| 1090 |
proxy = True |
| 1091 |
|
| 1092 |
|
| 1093 |
class ReadOnlyRelatedField(models.Model): |
| 1094 |
chapter = models.ForeignKey(Chapter, models.CASCADE) |
| 1095 |
language = models.ForeignKey(Language, models.CASCADE) |
| 1096 |
user = models.ForeignKey(User, models.CASCADE) |
| 1097 |
|
| 1098 |
|
| 1099 |
class Héllo(models.Model): |
| 1100 |
pass |
| 1101 |
|
| 1102 |
|
| 1103 |
class Box(models.Model): |
| 1104 |
title = models.CharField(max_length=100) |
| 1105 |
next_box = models.ForeignKey( |
| 1106 |
"self", null=True, on_delete=models.SET_NULL, blank=True |
| 1107 |
) |
| 1108 |
next_box = models.ForeignKey( |
| 1109 |
"self", null=True, on_delete=models.SET_NULL, blank=True |
| 1110 |
) |
| 1111 |
|
| 1112 |
|
| 1113 |
class Country(models.Model): |
| 1114 |
NORTH_AMERICA = "North America" |
| 1115 |
SOUTH_AMERICA = "South America" |
| 1116 |
EUROPE = "Europe" |
| 1117 |
ASIA = "Asia" |
| 1118 |
OCEANIA = "Oceania" |
| 1119 |
ANTARCTICA = "Antarctica" |
| 1120 |
|
| 1121 |
CONTINENT_CHOICES = [ |
| 1122 |
(NORTH_AMERICA, NORTH_AMERICA), |
| 1123 |
(SOUTH_AMERICA, SOUTH_AMERICA), |
| 1124 |
(EUROPE, EUROPE), |
| 1125 |
(ASIA, ASIA), |
| 1126 |
(OCEANIA, OCEANIA), |
| 1127 |
(ANTARCTICA, ANTARCTICA), |
| 1128 |
] |
| 1129 |
name = models.CharField(max_length=80) |
| 1130 |
continent = models.CharField(max_length=13, choices=CONTINENT_CHOICES) |
| 1131 |
|
| 1132 |
def __str__(self): |
| 1133 |
return self.name |
| 1134 |
|
| 1135 |
|
| 1136 |
class Traveler(models.Model): |
| 1137 |
born_country = models.ForeignKey(Country, models.CASCADE) |
| 1138 |
living_country = models.ForeignKey( |
| 1139 |
Country, models.CASCADE, related_name="living_country_set" |
| 1140 |
) |
| 1141 |
favorite_country_to_vacation = models.ForeignKey( |
| 1142 |
Country, |
| 1143 |
models.CASCADE, |
| 1144 |
related_name="favorite_country_to_vacation_set", |
| 1145 |
limit_choices_to={"continent": Country.ASIA}, |
| 1146 |
) |
| 1147 |
|
| 1148 |
|
| 1149 |
class Square(models.Model): |
| 1150 |
side = models.IntegerField() |
| 1151 |
area = models.GeneratedField( |
| 1152 |
db_persist=True, |
| 1153 |
expression=models.F("side") * models.F("side"), |
| 1154 |
output_field=models.BigIntegerField(), |
| 1155 |
) |
| 1156 |
|
| 1157 |
class Meta: |
| 1158 |
required_db_features = {"supports_stored_generated_columns"} |
| 1159 |
|
| 1160 |
|
| 1161 |
class CamelCaseModel(models.Model): |
| 1162 |
interesting_name = models.CharField(max_length=100) |
| 1163 |
|
| 1164 |
def __str__(self): |
| 1165 |
return self.interesting_name |
| 1166 |
|
| 1167 |
|
| 1168 |
class CamelCaseRelatedModel(models.Model): |
| 1169 |
m2m = models.ManyToManyField(CamelCaseModel, related_name="m2m") |
| 1170 |
fk = models.ForeignKey(CamelCaseModel, on_delete=models.CASCADE, related_name="fk") |