1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
from django.db import models
from ordered_model.models import OrderedModel, OrderedModelBase
# test simple automatic ordering
class Item(OrderedModel):
name = models.CharField(max_length=100)
# test Answer.order_with_respect_to being a tuple
class Question(models.Model):
pass
class TestUser(models.Model):
pass
class Answer(OrderedModel):
question = models.ForeignKey(
Question, on_delete=models.CASCADE, related_name="answers"
)
user = models.ForeignKey(TestUser, on_delete=models.CASCADE, related_name="answers")
order_with_respect_to = ("question", "user")
class Meta:
ordering = ("question", "user", "order")
def __unicode__(self):
return "Answer #{0:d} of question #{1:d} for user #{2:d}".format(
self.order, self.question_id, self.user_id
)
# test ordering whilst overriding the automatic primary key (ie. not models.Model.id)
class CustomItem(OrderedModel):
pkid = models.CharField(max_length=100, primary_key=True)
name = models.CharField(max_length=100)
modified = models.DateTimeField(null=True, blank=True)
# test ordering over custom ordering field (ie. not OrderedModel.order)
class CustomOrderFieldModel(OrderedModelBase):
sort_order = models.PositiveIntegerField(editable=False, db_index=True)
name = models.CharField(max_length=100)
order_field_name = "sort_order"
class Meta:
ordering = ("sort_order",)
# test ThroughModel ordering with Pizzas/Topping
class Topping(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
class Pizza(models.Model):
name = models.CharField(max_length=100)
toppings = models.ManyToManyField(Topping, through="PizzaToppingsThroughModel")
def __str__(self):
return self.name
class PizzaToppingsThroughModel(OrderedModel):
pizza = models.ForeignKey(Pizza, on_delete=models.CASCADE)
topping = models.ForeignKey(Topping, on_delete=models.CASCADE)
order_with_respect_to = "pizza"
class Meta:
ordering = ("pizza", "order")
# Admin only allows each model class to be registered once. However you can register a proxy class,
# and (for presentation purposes only) rename it to match the existing in Admin
class PizzaProxy(Pizza):
class Meta:
proxy = True
verbose_name = "Pizza"
verbose_name_plural = "Pizzas"
# test many-one where the item has custom PK
class CustomPKGroup(models.Model):
name = models.CharField(max_length=100)
class CustomPKGroupItem(OrderedModel):
group = models.ForeignKey(CustomPKGroup, on_delete=models.CASCADE)
name = models.CharField(max_length=100, primary_key=True)
order_with_respect_to = "group"
# test ordering on a base class (with order_class_path)
# ie. OpenQuestion and GroupedItem can be ordered wrt each other
class BaseQuestion(OrderedModel):
order_class_path = __module__ + ".BaseQuestion"
question = models.TextField(max_length=100)
class Meta:
ordering = ("order",)
class MultipleChoiceQuestion(BaseQuestion):
good_answer = models.TextField(max_length=100)
wrong_answer1 = models.TextField(max_length=100)
wrong_answer2 = models.TextField(max_length=100)
wrong_answer3 = models.TextField(max_length=100)
class OpenQuestion(BaseQuestion):
answer = models.TextField(max_length=100)
# test grouping by a foreign model field (group__user)
class ItemGroup(models.Model):
user = models.ForeignKey(
TestUser, on_delete=models.CASCADE, related_name="item_groups"
)
class GroupedItem(OrderedModel):
group = models.ForeignKey(ItemGroup, on_delete=models.CASCADE, related_name="items")
order_with_respect_to = "group__user"
class CascadedParentModel(models.Model):
pass
class CascadedOrderedModel(OrderedModel):
parent = models.ForeignKey(to=CascadedParentModel, on_delete=models.CASCADE)
|
