Debian Codegraph @

tests/fixtures/models.py

raw
1 """
2 Fixtures.
3
4 Fixtures are a way of loading data into the database in bulk. Fixure data
5 can be stored in any serializable format (including JSON and XML). Fixtures
6 are identified by name, and are stored in either a directory named 'fixtures'
7 in the application directory, or in one of the directories named in the
8 ``FIXTURE_DIRS`` setting.
9 """
10
11 import uuid
12
13 from django.contrib.auth.models import Permission
14 from django.contrib.contenttypes.fields import GenericForeignKey
15 from django.contrib.contenttypes.models import ContentType
16 from django.db import models
17
18
19 class Category(models.Model):
20 title = models.CharField(max_length=100)
21 description = models.TextField()
22
23 class Meta:
24 ordering = ("title",)
25
26 def __str__(self):
27 return self.title
28
29
30 class Article(models.Model):
31 headline = models.CharField(max_length=100, default="Default headline")
32 pub_date = models.DateTimeField()
33
34 class Meta:
35 ordering = ("-pub_date", "headline")
36
37 def __str__(self):
38 return self.headline
39
40
41 class Blog(models.Model):
42 name = models.CharField(max_length=100)
43 featured = models.ForeignKey(
44 Article, models.CASCADE, related_name="fixtures_featured_set"
45 )
46 articles = models.ManyToManyField(
47 Article, blank=True, related_name="fixtures_articles_set"
48 )
49
50 def __str__(self):
51 return self.name
52
53
54 class Tag(models.Model):
55 name = models.CharField(max_length=100)
56 tagged_type = models.ForeignKey(
57 ContentType, models.CASCADE, related_name="fixtures_tag_set"
58 )
59 tagged_id = models.PositiveIntegerField(default=0)
60 tagged = GenericForeignKey(ct_field="tagged_type", fk_field="tagged_id")
61
62 def __str__(self):
63 return '<%s: %s> tagged "%s"' % (
64 self.tagged.__class__.__name__,
65 self.tagged,
66 self.name,
67 )
68
69
70 class PersonManager(models.Manager):
71 def get_by_natural_key(self, name):
72 return self.get(name=name)
73
74
75 class Person(models.Model):
76 objects = PersonManager()
77 name = models.CharField(max_length=100, unique=True)
78
79 class Meta:
80 ordering = ("name",)
81
82 def __str__(self):
83 return self.name
84
85 def natural_key(self):
86 return (self.name,)
87
88
89 class SpyManager(PersonManager):
90 def get_queryset(self):
91 return super().get_queryset().filter(cover_blown=False)
92
93
94 class Spy(Person):
95 objects = SpyManager()
96 cover_blown = models.BooleanField(default=False)
97
98
99 class ProxySpy(Spy):
100 class Meta:
101 proxy = True
102
103
104 class VisaManager(models.Manager):
105 def get_queryset(self):
106 return super().get_queryset().prefetch_related("permissions")
107
108
109 class Visa(models.Model):
110 person = models.ForeignKey(Person, models.CASCADE)
111 permissions = models.ManyToManyField(Permission, blank=True)
112 objects = VisaManager()
113
114 def __str__(self):
115 return "%s %s" % (
116 self.person.name,
117 ", ".join(p.name for p in self.permissions.all()),
118 )
119
120
121 class Book(models.Model):
122 name = models.CharField(max_length=100)
123 authors = models.ManyToManyField(Person)
124
125 class Meta:
126 ordering = ("name",)
127
128 def __str__(self):
129 authors = " and ".join(a.name for a in self.authors.all())
130 return "%s by %s" % (self.name, authors) if authors else self.name
131
132
133 class PrimaryKeyUUIDModel(models.Model):
134 id = models.UUIDField(primary_key=True, default=uuid.uuid4)
135
136
137 class NaturalKeyManager(models.Manager):
138 def get_by_natural_key(self, key):
139 return self.get(key=key)
140
141
142 class NaturalKeyThing(models.Model):
143 key = models.CharField(max_length=100, unique=True)
144 other_thing = models.ForeignKey(
145 "NaturalKeyThing", on_delete=models.CASCADE, null=True
146 )
147 other_things = models.ManyToManyField(
148 "NaturalKeyThing", related_name="thing_m2m_set"
149 )
150
151 objects = NaturalKeyManager()
152
153 def natural_key(self):
154 return (self.key,)
155
156 def __str__(self):
157 return self.key
158
159
160 class CircularA(models.Model):
161 key = models.CharField(max_length=3, unique=True)
162 obj = models.ForeignKey("CircularB", models.SET_NULL, null=True)
163
164 objects = NaturalKeyManager()
165
166 def natural_key(self):
167 return (self.key,)
168
169
170 class CircularB(models.Model):
171 key = models.CharField(max_length=3, unique=True)
172 obj = models.ForeignKey("CircularA", models.SET_NULL, null=True)
173
174 objects = NaturalKeyManager()
175
176 def natural_key(self):
177 return (self.key,)