\n"
13 | "Language: \n"
14 | "MIME-Version: 1.0\n"
15 | "Content-Type: text/plain; charset=UTF-8\n"
16 | "Content-Transfer-Encoding: 8bit\n"
17 | "Plural-Forms: nplurals=2; plural=(n != 1);\n"
18 | "X-Generator: Lokalize 1.1\n"
19 |
20 | #: admin/parentadmin.py:45
21 | msgid "Node type"
22 | msgstr "Nodetype"
23 |
24 | #: admin/parentadmin.py:56
25 | msgid "node type"
26 | msgstr "nodetype"
27 |
28 | #: admin/parentadmin.py:112
29 | msgid "Actions"
30 | msgstr "Acties"
31 |
32 | #: admin/parentadmin.py:123
33 | msgid "Add sub node"
34 | msgstr "Sub node toevoegen"
35 |
36 | #: admin/parentadmin.py:132
37 | msgid "View on site"
38 | msgstr ""
39 |
40 | #: admin/parentadmin.py:196
41 | msgid "You do not have permission to move this node."
42 | msgstr "Je hebt geen toegang om deze node te verplaatsen."
43 |
44 | #: models.py:46 models.py:193
45 | msgid "This node type should have a parent."
46 | msgstr "Deze node moet een subnode zijn."
47 |
48 | #: models.py:47
49 | msgid "The selected parent cannot have child nodes."
50 | msgstr "De gekozen node kan geen subnodes bevatten."
51 |
52 | #: models.py:48
53 | msgid "The selected parent cannot have this node type as a child!"
54 | msgstr "De gekozen node kan geen subnodes van dit type bevatten."
55 |
56 | #: models.py:197
57 | #, python-brace-format
58 | msgid "Cannot place ‘{0}’ below ‘{1}’; a {2} does not allow children!"
59 | msgstr ""
60 | "Kan ‘{0}’ niet onder ‘{1}’ plaatsen; een {2} staat geen "
61 | "onderliggende nodes toe!"
62 |
63 | #: models.py:203
64 | #, fuzzy, python-brace-format
65 | #| msgid "Cannot place ‘{0}’ below ‘{1}’; a {2} does not allow children!"
66 | msgid "Cannot place ‘{0}’ below ‘{1}’; a {2} does not allow {3} as a child!"
67 | msgstr ""
68 | "Kan ‘{0}’ niet onder ‘{1}’ plaatsen; een {2} node staat {3} niet toe als onderliggende node!"
69 |
70 | #: templates/admin/polymorphic_tree/change_form_breadcrumbs.html:5
71 | #: templates/admin/polymorphic_tree/delete_confirmation.html:7
72 | #: templates/admin/polymorphic_tree/object_history_breadcrumbs.html:5
73 | msgid "Home"
74 | msgstr ""
75 |
76 | #: templates/admin/polymorphic_tree/change_form_breadcrumbs.html:20
77 | #| msgid "Add %s"
78 | msgid "Add"
79 | msgstr ""
80 |
81 | #: templates/admin/polymorphic_tree/delete_confirmation.html:20
82 | msgid "Delete"
83 | msgstr ""
84 |
85 | #: templates/admin/polymorphic_tree/jstree_list_results.html:115
86 | msgid ""
87 | "Unable to move the node, the current display is out-of-date.\\nThe current "
88 | "page now reloaded."
89 | msgstr ""
90 |
91 | #: templates/admin/polymorphic_tree/jstree_list_results.html:123
92 | msgid ""
93 | "There was an error while moving the node, please reload the current page."
94 | msgstr ""
95 | "Er was een fout opgetreden bij het verplaatsen van de node, herlaad de "
96 | "huidige pagina a.u.b."
97 |
98 | #: templates/admin/polymorphic_tree/object_history_breadcrumbs.html:20
99 | msgid "History"
100 | msgstr ""
101 |
--------------------------------------------------------------------------------
/polymorphic_tree/managers.py:
--------------------------------------------------------------------------------
1 | """
2 | The manager class for the CMS models
3 | """
4 | from mptt.managers import TreeManager
5 | from mptt.querysets import TreeQuerySet
6 | from polymorphic.managers import PolymorphicManager
7 | from polymorphic.query import PolymorphicQuerySet
8 |
9 |
10 | class PolymorphicMPTTQuerySet(TreeQuerySet, PolymorphicQuerySet):
11 | """
12 | Base class for querysets
13 | """
14 |
15 | def toplevel(self):
16 | """
17 | Return all nodes which have no parent.
18 | """
19 | return self.filter(parent__isnull=True)
20 |
21 | def as_manager(cls):
22 | # Make sure this way of creating managers works.
23 | manager = PolymorphicMPTTModelManager.from_queryset(cls)()
24 | manager._built_with_as_manager = True
25 | return manager
26 |
27 | as_manager.queryset_only = True
28 | as_manager = classmethod(as_manager)
29 |
30 |
31 | class PolymorphicMPTTModelManager(TreeManager, PolymorphicManager):
32 | """
33 | Base class for a model manager.
34 | """
35 |
36 | #: The queryset class to use.
37 | queryset_class = PolymorphicMPTTQuerySet
38 |
39 | def toplevel(self):
40 | """
41 | Return all nodes which have no parent.
42 | """
43 | # Calling .all() is equivalent to .get_queryset()
44 | return self.all().toplevel()
45 |
46 | def _mptt_filter(self, qs=None, **filters):
47 | if self._base_manager and qs is not None:
48 | # This is a little hack to fix get_previous_sibling() / get_next_sibling().
49 | # When the queryset is defined (meaning: a call was made from model._tree_manager._mptt_filter(qs)),
50 | # there is a call to find related objects.# The current model might be a derived model however,
51 | # due to out polymorphic layout. Enforce seeking from the base model that holds the entire MPTT structure,
52 | # and the polymorphic queryset will upgrade the models again.
53 | if issubclass(qs.model, self.model):
54 | qs.model = self._base_manager.model
55 | qs.query.model = self._base_manager.model
56 |
57 | return super()._mptt_filter(qs, **filters)
58 |
59 | def move_node(self, node, target, position="last-child"):
60 | """
61 | Move a node to a new location.
62 | This also performs checks whether the target allows this node to reside there.
63 | """
64 | node.validate_move(target, position=position)
65 | return super().move_node(node, target, position=position)
66 |
--------------------------------------------------------------------------------
/polymorphic_tree/models.py:
--------------------------------------------------------------------------------
1 | """
2 | Model that inherits from both Polymorphic and MPTT.
3 | """
4 | import uuid
5 |
6 | from django.contrib.contenttypes.models import ContentType
7 | from django.core.exceptions import ValidationError
8 | from django.utils.encoding import force_str
9 | from django.utils.translation import gettext
10 | from django.utils.translation import gettext_lazy as _
11 | from mptt.exceptions import InvalidMove
12 | from mptt.models import MPTTModel, MPTTModelBase, TreeForeignKey, raise_if_unsaved
13 | from polymorphic.base import PolymorphicModelBase
14 | from polymorphic.models import PolymorphicModel
15 |
16 | from polymorphic_tree.managers import PolymorphicMPTTModelManager
17 |
18 |
19 | def _get_base_polymorphic_model(ChildModel):
20 | """
21 | First model in the inheritance chain that inherited from the PolymorphicMPTTModel
22 | """
23 | for Model in reversed(ChildModel.mro()):
24 | if (
25 | isinstance(Model, PolymorphicMPTTModelBase)
26 | and Model is not PolymorphicMPTTModel
27 | and not Model._meta.abstract
28 | ):
29 | return Model
30 | return None
31 |
32 |
33 | class PolymorphicMPTTModelBase(MPTTModelBase, PolymorphicModelBase):
34 | """
35 | Metaclass for all polymorphic models.
36 | Needed to support both MPTT and Polymorphic metaclasses.
37 | """
38 |
39 |
40 | class PolymorphicTreeForeignKey(TreeForeignKey):
41 | """
42 | A foreignkey that limits the node types the parent can be.
43 | """
44 |
45 | default_error_messages = {
46 | "required": _("This node type should have a parent."),
47 | "no_children_allowed": _("The selected parent cannot have child nodes."),
48 | "child_not_allowed": _("The selected parent cannot have this node type as a child!"),
49 | }
50 |
51 | def clean(self, value, model_instance):
52 | value = super().clean(value, model_instance)
53 | self._validate_parent(value, model_instance)
54 | return value
55 |
56 | def _validate_parent(self, parent, model_instance):
57 | if not parent:
58 | # This can't test for model_instance.can_be_root,
59 | # because clean() is not called for empty values.
60 | return
61 | elif isinstance(parent, int) or isinstance(parent, uuid.UUID):
62 | # TODO: Improve this code, it's a bit of a hack now because the base model is not known in the NodeTypePool.
63 | base_model = _get_base_polymorphic_model(model_instance.__class__)
64 | parent = base_model.objects.get(pk=parent)
65 | elif not isinstance(parent, PolymorphicMPTTModel):
66 | raise ValueError("Unknown parent value")
67 |
68 | if not parent.can_have_children:
69 | raise ValidationError(self.error_messages["no_children_allowed"])
70 |
71 | if not parent.is_child_allowed(model_instance):
72 | raise ValidationError(self.error_messages["child_not_allowed"])
73 |
74 |
75 | class PolymorphicMPTTModel(MPTTModel, PolymorphicModel, metaclass=PolymorphicMPTTModelBase):
76 | """
77 | The base class for all nodes; a mapping of an URL to content (e.g. a HTML page, text file, blog, etc..)
78 | """
79 |
80 | #: Whether the node type allows to have children.
81 | can_have_children = True
82 |
83 | #: Whether the node type can be a root node.
84 | can_be_root = True
85 |
86 | #: Allowed child types for this page.
87 | child_types = []
88 |
89 | # Cache child types using a class variable to ensure that get_child_types
90 | # is run once per page class, per django initiation.
91 | __child_types = {}
92 |
93 | # Django fields
94 | objects = PolymorphicMPTTModelManager()
95 |
96 | class Meta:
97 | abstract = True
98 | ordering = (
99 | "tree_id",
100 | "lft",
101 | )
102 | base_manager_name = "objects"
103 |
104 | @property
105 | def page_key(self):
106 | """
107 | A unique key for this page to ensure get_child_types is run once per
108 | page.
109 | """
110 | return repr(self)
111 |
112 | def get_child_types(self):
113 | """
114 | Get the allowed child types and convert them into content type ids.
115 | This allows for the lookup of allowed children in the admin tree.
116 | """
117 | key = self.page_key
118 | child_types = self._PolymorphicMPTTModel__child_types
119 | if not self.can_have_children:
120 | return []
121 |
122 | if child_types.get(key, None) is None:
123 | new_children = []
124 | iterator = iter(self.child_types)
125 | for child in iterator:
126 | if isinstance(child, str):
127 | child = str(child).lower()
128 | # write self to refer to self
129 | if child == "self":
130 | ct_id = self.polymorphic_ctype_id
131 | else:
132 | # either the name of a model in this app
133 | # or the full app.model dot string
134 | # just like a foreign key
135 | try:
136 | app_label, model = child.rsplit(".", 1)
137 | except ValueError:
138 | app_label = self._meta.app_label
139 | model = child
140 | ct_id = ContentType.objects.get_by_natural_key(app_label, model).id
141 | else:
142 | # pass in a model class
143 | ct_id = ContentType.objects.get_for_model(child).id
144 | new_children.append(ct_id)
145 | child_types[key] = new_children
146 |
147 | return child_types[key]
148 |
149 | # Define:
150 | # parent = PolymorphicTreeForeignKey('self', blank=True, null=True, related_name='children', verbose_name=_('parent'),
151 | # help_text=_('You can also change the parent by dragging the item in the list.'))
152 | # class MPTTMeta:
153 | # order_insertion_by = 'title'
154 |
155 | @raise_if_unsaved
156 | def get_closest_ancestor_of_type(self, model, include_self=False):
157 | """
158 | Find the first parent of a specific model type.
159 | """
160 | if include_self and isinstance(self, model):
161 | return self
162 | else:
163 | try:
164 | return self.get_ancestors_of_type(model, ascending=False)[0]
165 | except IndexError:
166 | return None
167 |
168 | @raise_if_unsaved
169 | def get_ancestors_of_type(self, model, ascending=False, include_self=False):
170 | """
171 | Find a parent of a specific type.
172 | """
173 | return self.get_ancestors(ascending=ascending, include_self=include_self).instance_of(model)
174 |
175 | def is_child_allowed(self, child):
176 | """
177 | Tell whether this node allows the given node as child.
178 | """
179 | if not self.can_have_children:
180 | return False
181 |
182 | child_types = self.get_child_types()
183 |
184 | # this allows tree validation to occur in the event the child model is not
185 | # yet created in db (ie. when django admin tries to validate)
186 | child.pre_save_polymorphic()
187 |
188 | return not child_types or child.polymorphic_ctype_id in child_types
189 |
190 | def validate_move(self, target, position="first-child"):
191 | """
192 | Validate whether the move to a new location is permitted.
193 |
194 | :param target: The node to move to
195 | :type target: PolymorphicMPTTModel
196 | :param position: The relative position to the target. This can be ``'first-child'``,
197 | ``'last-child'``, ``'left'`` or ``'right'``.
198 | """
199 | new_parent = _get_new_parent(self, target, position)
200 |
201 | if new_parent is None:
202 | if not self.can_be_root:
203 | raise InvalidMove(gettext("This node type should have a parent."))
204 | else:
205 | if not new_parent.can_have_children:
206 | raise InvalidMove(
207 | gettext(
208 | "Cannot place \u2018{0}\u2019 below \u2018{1}\u2019; a {2} does not allow children!"
209 | ).format(self, new_parent, new_parent._meta.verbose_name)
210 | )
211 |
212 | if not new_parent.is_child_allowed(self):
213 | raise InvalidMove(
214 | gettext(
215 | "Cannot place \u2018{0}\u2019 below \u2018{1}\u2019; a {2} does not allow {3} as a child!"
216 | ).format(self, target, target._meta.verbose_name, self._meta.verbose_name)
217 | )
218 |
219 | # Allow custom validation
220 | self.validate_move_to(new_parent)
221 |
222 | def validate_move_to(self, new_parent):
223 | """
224 | Can move be finished
225 |
226 | Method have to be redefined in inherited model to define cases when
227 | node can be moved. If method is not redefined moving is always allowed.
228 | The ``new_parent`` can be ``None`` when the node is moved to the root.
229 |
230 | To deny move, this method have to be raised ``ValidationError`` or
231 | ``InvalidMove`` from ``mptt.exceptions``
232 | """
233 |
234 | def clean(self):
235 | super().clean()
236 |
237 | try:
238 | # Make sure form validation also reports choosing a wrong parent.
239 | # This also updates what PolymorphicTreeForeignKey already does.
240 | parent_id = getattr(self, self._mptt_meta.parent_attr + "_id")
241 | parent = getattr(self, self._mptt_meta.parent_attr) if parent_id else None
242 | self.validate_move(parent)
243 | except InvalidMove as e:
244 | raise ValidationError({self._mptt_meta.parent_attr: force_str(e)})
245 |
246 |
247 | def _get_new_parent(moved, target, position="first-child"):
248 | """
249 | Find out which parent the node will reside under.
250 | """
251 | if position in ("first-child", "last-child"):
252 | return target
253 | elif position in ("left", "right"):
254 | # left/right of an other node
255 | parent_attr_id = f"{moved._mptt_meta.parent_attr}_id"
256 | if getattr(target, parent_attr_id) == getattr(moved, parent_attr_id):
257 | # kept inside the same parent, hopefully use the cache we already have.
258 | return getattr(moved, moved._mptt_meta.parent_attr)
259 |
260 | return getattr(target, target._mptt_meta.parent_attr)
261 | else:
262 | raise ValueError("invalid mptt position argument")
263 |
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/arrow-down.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/arrow-down.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/arrow-up.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/arrow-up.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/nav-bg.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/nav-bg.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/nodetree.css:
--------------------------------------------------------------------------------
1 | /*
2 | * jsTree django theme 1.0
3 | */
4 |
5 |
6 | /* column layout */
7 |
8 | .jqtree-django {
9 | clear: both;
10 | }
11 |
12 | .jqtree-django .col-primary {
13 | float: left;
14 | width: auto;
15 | z-index: 0;
16 | }
17 |
18 | .jqtree-django .col-metadata {
19 | float: right;
20 | width: auto; /* all 3 columns combined is 393px */
21 | z-index: 1;
22 | overflow: hidden;
23 | }
24 |
25 | .jqtree-django .js-tree-header .action-checkbox-column { display: none; }
26 | .jqtree-django .js-tree-header .first-column { border-left: 0; padding-left: 15px; }
27 |
28 |
29 | /* Base setup */
30 |
31 | .jqtree-django li {
32 | /* The "tr" */
33 | clear: both;
34 | margin: 0;
35 | padding: 0;
36 | list-style: none;
37 | }
38 |
39 | .jqtree-django li > div:after {
40 | /* needed for toggler icon */
41 | content: ".";
42 | font-size: 0;
43 | line-height: 0;
44 | display: block;
45 | height: 0;
46 | clear: both;
47 | visibility: hidden;
48 | }
49 |
50 | * html .jqtree-django li div { height: 1%; } /* 1% of nothing makes IE 6 do the right thing. */
51 | *+html .jqtree-django li > div { min-height: 0; } /* and IE7 has new tricks to trigger hasLayout. */
52 |
53 | .jqtree-django ul {
54 | clear: both;
55 | /* reset django admin styles */
56 | padding-left: 0;
57 | padding-right: 0;
58 | margin-top: 0;
59 | margin-bottom: 0;
60 | }
61 |
62 | .jqtree-django ul.tree {
63 | margin: 0;
64 | padding: 0 0 0 12px;
65 | }
66 |
67 |
68 | /* column layout */
69 |
70 | .jqtree-django ul.tree a.toggler {
71 | position: absolute;
72 | left: -6px;
73 | margin-top: -4px;
74 | top: 50%;
75 | }
76 |
77 | .jqtree-django div.col {
78 | /* the "td" cells */
79 | float: left;
80 |
81 | line-height: 16px; /* increase if a column is larger */
82 | font-size: 11px;
83 | }
84 |
85 | .jqtree-django div.first-column {
86 | border-left: 0;
87 | }
88 |
89 | .jqtree-django div.first-column a {
90 | font-size: 12px;
91 | font-weight: bold;
92 | }
93 |
94 | ul.tree li img { vertical-align: baseline; } /* keeps 3px space below, use 'bottom' to remove it */
95 |
96 |
97 | /* drag and drop */
98 |
99 | #js-result-list .tree-dragging {
100 | color: #333;
101 | border: 1px solid #ddd;
102 | background: #eee;
103 | opacity: 0.9;
104 | cursor: pointer;
105 | padding: 2px 8px;
106 | }
107 |
108 | #js-result-list .tree-dragging .first-column { min-width: 500px; }
109 | #js-result-list .tree-dragging .col-metadata { display: none; }
110 |
111 |
112 | /* resets */
113 |
114 | .jqtree-django ul.tree li.folder { margin-bottom: 0; }
115 |
116 |
117 | /* non-javascript buttons */
118 |
119 | ul.tree .no-js { display: none; }
120 | ul.tree li:first-child .move-up { visibility: hidden; } /* Hiding in CSS is easy, the server-side urlnode.is_first_sibling call is expensive. */
121 | ul.tree li:last-child .move-down { visibility: hidden; }
122 |
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/nodetree_classic.css:
--------------------------------------------------------------------------------
1 | #changelist table.js-tree-header thead th {
2 | padding: 2px 5px;
3 | }
4 |
5 | .jqtree-django ul.tree {
6 | background-image: url(zebra.png);
7 | }
8 |
9 | .jqtree-django div.col {
10 | padding: 5px;
11 | }
12 |
13 | .jqtree-django .col-primary,
14 | .jqtree-django .col-metadata {
15 | /* Fix height of columns, for zebra background.
16 | Also masks subtle differences within various cells if they are there */
17 | height: 27px;
18 | }
19 |
20 | .jqtree-django .col-metadata {
21 | border-right: 1px solid #ddd;
22 | }
23 |
24 | .jqtree-django .col-metadata .col {
25 | border-left: 1px solid #ddd;
26 | }
27 |
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/nodetree_flat.css:
--------------------------------------------------------------------------------
1 | #changelist table.js-tree-header thead th {
2 | padding: 8px; /* align with fake div columns */
3 | }
4 |
5 | .jqtree-django ul.tree {
6 | background-image: url(zebra-flat.png);
7 | }
8 |
9 | .jqtree-django div.col {
10 | padding: 8px;
11 | }
12 |
13 | .jqtree-django .col-primary,
14 | .jqtree-django .col-metadata {
15 | height: 35px;
16 | }
17 |
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/nodetree_grappelli.css:
--------------------------------------------------------------------------------
1 | /* grappelli styling and workarounds */
2 |
3 | #grp-container .results {
4 | margin: 0 0 5px 0;
5 | }
6 |
7 | #grp-container .jqtree-django table {
8 | width: 100%; /* for grappelli */
9 | }
10 |
11 | #grp-container #js-result-list {
12 | border-left: 1px solid #ccc;
13 | border-bottom: 1px solid #ccc;
14 | border-right: 1px solid #ccc;
15 | border-bottom-left-radius: 3px;
16 | border-bottom-right-radius: 3px;
17 | margin-left: -1px;
18 | margin-right: 1px;
19 | }
20 |
21 | #grp-container .jqtree-django ul.tree {
22 | margin: 0;
23 | padding: 0 0 0 12px;
24 | background-image: url(zebra-grappelli.png);
25 | }
26 |
27 | #grp-container .jqtree-django .col-primary,
28 | #grp-container .jqtree-django .col-metadata {
29 | height: 36px;
30 | }
31 |
32 | #grp-container table thead th.col-title {
33 | border-top-left-radius: 2px;
34 | border-left: 0 none;
35 | }
36 |
37 | #grp-container .jqtree-django .col-metadata {
38 | border-right: 0;
39 | }
40 |
41 | #grp-container .jqtree-django div.col {
42 | padding: 10px;
43 | }
44 |
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/zebra-flat.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/zebra-flat.png
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/zebra-grappelli.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/zebra-grappelli.png
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/adminlist/zebra.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/adminlist/zebra.png
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/icons/blank.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/icons/blank.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/icons/page_new.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/icons/page_new.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/icons/world.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/static/polymorphic_tree/icons/world.gif
--------------------------------------------------------------------------------
/polymorphic_tree/static/polymorphic_tree/jquery.cookie.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Cookie plugin
3 | *
4 | * Copyright (c) 2006 Klaus Hartl (stilbuero.de)
5 | * Dual licensed under the MIT and GPL licenses:
6 | * http://www.opensource.org/licenses/mit-license.php
7 | * http://www.gnu.org/licenses/gpl.html
8 | *
9 | */
10 |
11 | /**
12 | * Create a cookie with the given name and value and other optional parameters.
13 | *
14 | * @example $.cookie('the_cookie', 'the_value');
15 | * @desc Set the value of a cookie.
16 | * @example $.cookie('the_cookie', 'the_value', { expires: 7, path: '/', domain: 'jquery.com', secure: true });
17 | * @desc Create a cookie with all available options.
18 | * @example $.cookie('the_cookie', 'the_value');
19 | * @desc Create a session cookie.
20 | * @example $.cookie('the_cookie', null);
21 | * @desc Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain
22 | * used when the cookie was set.
23 | *
24 | * @param String name The name of the cookie.
25 | * @param String value The value of the cookie.
26 | * @param Object options An object literal containing key/value pairs to provide optional cookie attributes.
27 | * @option Number|Date expires Either an integer specifying the expiration date from now on in days or a Date object.
28 | * If a negative value is specified (e.g. a date in the past), the cookie will be deleted.
29 | * If set to null or omitted, the cookie will be a session cookie and will not be retained
30 | * when the the browser exits.
31 | * @option String path The value of the path atribute of the cookie (default: path of page that created the cookie).
32 | * @option String domain The value of the domain attribute of the cookie (default: domain of page that created the cookie).
33 | * @option Boolean secure If true, the secure attribute of the cookie will be set and the cookie transmission will
34 | * require a secure protocol (like HTTPS).
35 | * @type undefined
36 | *
37 | * @name $.cookie
38 | * @cat Plugins/Cookie
39 | * @author Klaus Hartl/klaus.hartl@stilbuero.de
40 | */
41 |
42 | /**
43 | * Get the value of a cookie with the given name.
44 | *
45 | * @example $.cookie('the_cookie');
46 | * @desc Get the value of a cookie.
47 | *
48 | * @param String name The name of the cookie.
49 | * @return The value of the cookie.
50 | * @type String
51 | *
52 | * @name $.cookie
53 | * @cat Plugins/Cookie
54 | * @author Klaus Hartl/klaus.hartl@stilbuero.de
55 | */
56 | jQuery.cookie = function(name, value, options) {
57 | if (typeof value != 'undefined') { // name and value given, set cookie
58 | options = options || {};
59 | if (value === null) {
60 | value = '';
61 | options.expires = -1;
62 | }
63 | var expires = '';
64 | if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) {
65 | var date;
66 | if (typeof options.expires == 'number') {
67 | date = new Date();
68 | date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
69 | } else {
70 | date = options.expires;
71 | }
72 | expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE
73 | }
74 | // CAUTION: Needed to parenthesize options.path and options.domain
75 | // in the following expressions, otherwise they evaluate to undefined
76 | // in the packed version for some reason...
77 | var path = options.path ? '; path=' + (options.path) : '';
78 | var domain = options.domain ? '; domain=' + (options.domain) : '';
79 | var secure = options.secure ? '; secure' : '';
80 | document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
81 | } else { // only name given, get cookie
82 | var cookieValue = null;
83 | if (document.cookie && document.cookie != '') {
84 | var cookies = document.cookie.split(';');
85 | for (var i = 0; i < cookies.length; i++) {
86 | var cookie = jQuery.trim(cookies[i]);
87 | // Does this cookie string begin with the name we want?
88 | if (cookie.substring(0, name.length + 1) == (name + '=')) {
89 | cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
90 | break;
91 | }
92 | }
93 | }
94 | return cookieValue;
95 | }
96 | };
--------------------------------------------------------------------------------
/polymorphic_tree/templates/admin/polymorphic_tree/change_form.html:
--------------------------------------------------------------------------------
1 | {% extends "admin/change_form.html" %}
2 |
3 | {% block breadcrumbs %}{% if not is_popup %}{% include "admin/polymorphic_tree/change_form_breadcrumbs.html" %}{% endif %}{% endblock %}
4 |
--------------------------------------------------------------------------------
/polymorphic_tree/templates/admin/polymorphic_tree/change_form_breadcrumbs.html:
--------------------------------------------------------------------------------
1 | {% load i18n admin_urls polymorphic_admin_tags polymorphic_tree_admin_tags %}
2 |
3 | {% breadcrumb_scope base_opts %}
4 |
5 |
{% trans 'Home' %}
6 | ›
{{ opts.app_config.verbose_name }}
7 |
8 | {# not using module_name, because the 'opts' correclty point to the base model #}
9 | › {% if has_change_permission %}
{{ opts.verbose_name_plural|capfirst }}{% else %}{{ opts.verbose_name_plural|capfirst }}{% endif %}
10 |
11 | {# Add tree levels to polymorphic breadcrumb #}
12 | {% for parent in original|mptt_breadcrumb %}
13 | ›
{{ parent }}
14 | {% endfor %}
15 |
16 | › {% if add %}{% trans 'Add' %} {{ opts.verbose_name }}{% else %}{{ original|truncatewords:"18" }}{% endif %}
17 |
{# DIV for HTML validation #}
6 | {% for item in result_hidden_fields %}{{ item }}{% endfor %}
7 |
8 | {% endif %}
9 | {% if results %}
10 |
11 |
12 |
13 | {# This is the Django 1.3 style for columns, so it works with both v1.3 and 1.4. #}
14 | {% for header in result_headers %}|
15 | {{ header.text|capfirst }}
16 | {% endfor %}
17 | |
18 |
19 |
20 | {% for result in results %}
21 | {% if result.form.non_field_errors %}
22 | | {{ result.form.non_field_errors }} |
23 | {% endif %}
24 | {% for item in result %}{{ item }}{% endfor %}
25 | {% endfor %}
26 |
27 |
28 |
%s | " % force_str(form[cl.model._meta.pk.name]))
191 |
192 |
193 | def _get_mptt_indent_field(cl, result):
194 | """
195 | Find the first field of the list, it will be indented visually.
196 | Allow working with normal models too.
197 | """
198 | if not hasattr(result, "_mptt_meta"):
199 | return None
200 |
201 | # Taken from mptt_items_for_result() in mptt/templatetags/mptt_admin.py
202 | mptt_indent_field = None
203 | for field_name in cl.list_display:
204 | try:
205 | cl.lookup_opts.get_field(field_name)
206 | except FieldDoesNotExist:
207 | if mptt_indent_field is None:
208 | attr = getattr(result, field_name, None)
209 | if callable(attr):
210 | # first callable field, use this if we can't find any model fields
211 | mptt_indent_field = field_name
212 | else:
213 | # first model field, use this one
214 | mptt_indent_field = field_name
215 | break
216 | return mptt_indent_field
217 |
218 |
219 | def stylable_column_repr(cl, result, field_name):
220 | """
221 | Get the string representation for a column item.
222 | This can be a model field, callable or property.
223 | """
224 | try:
225 | f = cl.lookup_opts.get_field(field_name)
226 | except FieldDoesNotExist:
227 | return _get_non_field_repr(cl, result, field_name) # Field not found (maybe a function)
228 | else:
229 | row_classes = None
230 | value = display_for_field(
231 | getattr(result, f.attname), f, cl.model_admin.get_empty_value_display()
232 | ) # Standard field
233 | if isinstance(f, models.DateField) or isinstance(f, models.TimeField):
234 | row_classes = ["nowrap"]
235 | return value, row_classes
236 |
237 |
238 | def _get_non_field_repr(cl, result, field_name):
239 | """
240 | Render the visual representation of a column
241 | which does not refer to a field in the model
242 | """
243 | # For non-field list_display values, the value is either:
244 | # - a method
245 | # - a attribute of the ModelAdmin
246 | # - a property or method of the model.
247 | try:
248 | if callable(field_name):
249 | attr = field_name
250 | value = attr(result)
251 | elif hasattr(cl.model_admin, field_name) and field_name not in ("__str__", "__unicode__"):
252 | attr = getattr(cl.model_admin, field_name)
253 | value = attr(result)
254 | else:
255 | attr = getattr(result, field_name)
256 | if callable(attr):
257 | value = attr()
258 | else:
259 | value = attr
260 |
261 | # Parse special attributes of the item
262 | allow_tags = getattr(attr, "allow_tags", False)
263 | boolean = getattr(attr, "boolean", False)
264 | if boolean:
265 | allow_tags = True
266 | result_repr = _boolean_icon(value)
267 | elif isinstance(value, SafeData):
268 | allow_tags = True
269 | result_repr = value
270 | else:
271 | result_repr = smart_str(value)
272 |
273 | except (AttributeError, ObjectDoesNotExist):
274 | result_repr = cl.model_admin.get_empty_value_display()
275 | else:
276 | # Strip HTML tags in the resulting text, except if the
277 | # function has an "allow_tags" attribute set to True.
278 | if not allow_tags:
279 | result_repr = escape(result_repr)
280 | else:
281 | result_repr = mark_safe(result_repr)
282 |
283 | return result_repr, None
284 |
285 |
286 | # from Django 1.4:
287 | def display_for_field(value, field, empty_value_display):
288 | from django.contrib.admin.templatetags.admin_list import _boolean_icon
289 |
290 | if field.flatchoices:
291 | return dict(field.flatchoices).get(value, empty_value_display)
292 | # NullBooleanField needs special-case null-handling, so it comes
293 | # before the general null test.
294 | elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField):
295 | return _boolean_icon(value)
296 | elif value is None:
297 | return empty_value_display
298 | elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):
299 | if isinstance(field, models.DateTimeField):
300 | value = timezone.localtime(value)
301 | return formats.localize(value)
302 | elif isinstance(field, models.DecimalField):
303 | return formats.number_format(value, field.decimal_places)
304 | elif isinstance(field, models.FloatField):
305 | return formats.number_format(value)
306 | else:
307 | return smart_str(value)
308 |
--------------------------------------------------------------------------------
/polymorphic_tree/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/django-polymorphic/django-polymorphic-tree/99e92880bfcc7f0992f12e4b35633be2a5171435/polymorphic_tree/tests/__init__.py
--------------------------------------------------------------------------------
/polymorphic_tree/tests/admin.py:
--------------------------------------------------------------------------------
1 | from polymorphic_tree.admin import PolymorphicMPTTChildModelAdmin, PolymorphicMPTTParentModelAdmin
2 | from polymorphic_tree.tests.models import ModelWithCustomParentName
3 |
4 |
5 | class BaseChildAdmin(PolymorphicMPTTChildModelAdmin):
6 | """Test child admin"""
7 |
8 | GENERAL_FIELDSET = (
9 | None,
10 | {
11 | "fields": ("chief", "field5"),
12 | },
13 | )
14 |
15 | base_model = ModelWithCustomParentName
16 | base_fieldsets = (GENERAL_FIELDSET,)
17 |
18 |
19 | class TreeNodeParentAdmin(PolymorphicMPTTParentModelAdmin):
20 | """Test parent admin"""
21 |
22 | base_model = ModelWithCustomParentName
23 | child_models = ((ModelWithCustomParentName, BaseChildAdmin),)
24 |
25 | list_display = (
26 | "field5",
27 | "actions_column",
28 | )
29 |
--------------------------------------------------------------------------------
/polymorphic_tree/tests/models.py:
--------------------------------------------------------------------------------
1 | from django.core.exceptions import ValidationError
2 | from django.db import models
3 | from mptt.exceptions import InvalidMove
4 | from polymorphic.showfields import ShowFieldContent
5 |
6 | from polymorphic_tree.models import PolymorphicMPTTModel, PolymorphicTreeForeignKey
7 |
8 |
9 | class PlainA(models.Model):
10 | field1 = models.CharField(max_length=10)
11 |
12 |
13 | class PlainB(PlainA):
14 | field2 = models.CharField(max_length=10)
15 |
16 |
17 | class PlainC(PlainB):
18 | field3 = models.CharField(max_length=10)
19 |
20 |
21 | class Model2A(ShowFieldContent, PolymorphicMPTTModel):
22 | parent = PolymorphicTreeForeignKey(
23 | "self", blank=True, null=True, related_name="children", verbose_name="parent", on_delete=models.CASCADE
24 | )
25 | field1 = models.CharField(max_length=10)
26 |
27 |
28 | class Model2B(Model2A):
29 | field2 = models.CharField(max_length=10)
30 |
31 |
32 | class Model2C(Model2B):
33 | field3 = models.CharField(max_length=10)
34 |
35 |
36 | class Model2D(Model2C):
37 | field4 = models.CharField(max_length=10)
38 |
39 |
40 | class One2OneRelatingModel(PolymorphicMPTTModel):
41 | parent = PolymorphicTreeForeignKey(
42 | "self", blank=True, null=True, related_name="children", verbose_name="parent", on_delete=models.CASCADE
43 | )
44 | one2one = models.OneToOneField(Model2A, on_delete=models.CASCADE)
45 | field1 = models.CharField(max_length=10)
46 |
47 |
48 | class One2OneRelatingModelDerived(One2OneRelatingModel):
49 | field2 = models.CharField(max_length=10)
50 |
51 |
52 | class Base(ShowFieldContent, PolymorphicMPTTModel):
53 | parent = PolymorphicTreeForeignKey(
54 | "self", blank=True, null=True, related_name="children", verbose_name="parent", on_delete=models.CASCADE
55 | )
56 | field_b = models.CharField(max_length=10)
57 |
58 |
59 | class ModelX(Base):
60 | field_x = models.CharField(max_length=10)
61 |
62 |
63 | class ModelY(Base):
64 | field_y = models.CharField(max_length=10)
65 |
66 |
67 | class ModelWithCustomParentName(PolymorphicMPTTModel):
68 | """Model with custom parent name
69 |
70 | A model where ``PolymorphicTreeForeignKey`` attribute has not ``parent``
71 | name, but ``chief``
72 |
73 | Attributes:
74 | chief (ModelWithCustomParentName): parent
75 | field5 (str): test field
76 | """
77 |
78 | chief = PolymorphicTreeForeignKey(
79 | "self", blank=True, null=True, related_name="subordinate", verbose_name="Chief", on_delete=models.CASCADE
80 | )
81 | field5 = models.CharField(max_length=10)
82 |
83 | class MPTTMeta:
84 | parent_attr = "chief"
85 |
86 | def __str__(self):
87 | return self.field5
88 |
89 |
90 | class ModelWithValidation(PolymorphicMPTTModel):
91 | """Model with custom validation
92 |
93 | A model with redefined ``clean`` and ``validate_move_to`` methods
94 |
95 | ``clean`` method always raises ``ValidationError``
96 | ``validate_move_to`` always calls ``clean``
97 |
98 | Attributes:
99 | parent (ModelWithValidation): parent
100 | field6 (str): test field
101 | """
102 |
103 | parent = PolymorphicTreeForeignKey("self", blank=True, null=True, related_name="children", on_delete=models.CASCADE)
104 |
105 | field6 = models.CharField(max_length=10)
106 |
107 | def clean(self):
108 | """Raise validation error"""
109 | raise ValidationError({"parent": "There is something with parent field"})
110 |
111 | def validate_move_to(self, target):
112 | """Execute ``clean``"""
113 | self.clean()
114 |
115 |
116 | class ModelWithInvalidMove(PolymorphicMPTTModel):
117 | """Model with custom validation
118 |
119 | A model with redefined only ``validate_move_to`` method which always raises
120 | ``InvalidMove``
121 |
122 | Attributes:
123 | parent (ModelWithValidation): parent
124 | field7 (str): test field
125 | """
126 |
127 | parent = PolymorphicTreeForeignKey("self", blank=True, null=True, related_name="children", on_delete=models.CASCADE)
128 |
129 | field7 = models.CharField(max_length=10)
130 |
131 | def validate_move_to(self, target):
132 | """Raise ``InvalidMove``"""
133 | raise InvalidMove("Invalid move")
134 |
135 |
136 | class ModelMustBeChildRoot(PolymorphicMPTTModel):
137 | """Model that must be a child"""
138 |
139 | can_be_root = True
140 |
141 | parent = PolymorphicTreeForeignKey("self", blank=True, null=True, related_name="children", on_delete=models.CASCADE)
142 | field8 = models.CharField(max_length=10)
143 |
144 |
145 | class ModelMustBeChild(ModelMustBeChildRoot):
146 | can_be_root = False
147 |
148 |
149 | class ModelRestrictedChildren(Base):
150 | child_types = [
151 | ModelX,
152 | ]
153 |
--------------------------------------------------------------------------------
/polymorphic_tree/tests/test_admin.py:
--------------------------------------------------------------------------------
1 | import sys
2 | from unittest import TestCase
3 | from unittest.mock import MagicMock
4 |
5 | from django.contrib.admin import AdminSite
6 |
7 | import polymorphic_tree.templatetags.stylable_admin_list # noqa (only for import testing)
8 | from polymorphic_tree.admin.parentadmin import get_permission_codename
9 | from polymorphic_tree.tests.admin import TreeNodeParentAdmin
10 | from polymorphic_tree.tests.models import Model2A, ModelWithCustomParentName, ModelWithInvalidMove, ModelWithValidation
11 |
12 |
13 | class PolymorphicAdminTests(TestCase):
14 | """Tests for admin"""
15 |
16 | def setUp(self):
17 | self.parent = ModelWithCustomParentName.objects.create(field5="parent")
18 | self.child1 = ModelWithCustomParentName.objects.create(field5="child1", chief=self.parent)
19 | self.child2 = ModelWithCustomParentName.objects.create(field5="child2", chief=self.parent)
20 | self.parent_admin = TreeNodeParentAdmin(ModelWithCustomParentName, AdminSite())
21 |
22 | self.parent_with_validation = ModelWithValidation.objects.create(field6="parent")
23 | self.child1_with_validation = ModelWithValidation.objects.create(
24 | field6="child1", parent=self.parent_with_validation
25 | )
26 | self.child2_with_validation = ModelWithValidation.objects.create(
27 | field6="child2", parent=self.parent_with_validation
28 | )
29 |
30 | self.parent_admin_with_validation = TreeNodeParentAdmin(ModelWithValidation, AdminSite())
31 |
32 | self.parent_invalid_move = ModelWithInvalidMove.objects.create(field7="parent")
33 | self.child1_invalid_move = ModelWithInvalidMove.objects.create(field7="child1", parent=self.parent_invalid_move)
34 | self.child2_invalid_move = ModelWithInvalidMove.objects.create(field7="child2", parent=self.parent_invalid_move)
35 |
36 | self.parent_admin_invalid_move = TreeNodeParentAdmin(ModelWithInvalidMove, AdminSite())
37 |
38 | def test_make_child2_child_child1(self):
39 | """Make ``self.child2`` child of ``self.child1``"""
40 | request = MagicMock()
41 | request.POST = {
42 | "moved_id": self.child2.id,
43 | "target_id": self.child1.id,
44 | "previous_parent_id": self.parent.id,
45 | "position": "inside",
46 | }
47 | self.parent_admin.api_node_moved_view(request)
48 | # Analog of self.child2.refresh_from_db()
49 | # This hack used for django 1.7 support
50 | self.child2 = ModelWithCustomParentName.objects.get(pk=self.child2.pk)
51 | self.assertEqual(self.child2.chief, self.child1)
52 |
53 | def test_validation_error(self):
54 | """Ensure that if move can't be performed due validation error, move
55 | can't be performed and json error returned
56 | """
57 | request = MagicMock()
58 | request.POST = {
59 | "moved_id": self.child2_with_validation.id,
60 | "target_id": self.child1_with_validation.id,
61 | "previous_parent_id": self.parent_with_validation.id,
62 | "position": "inside",
63 | }
64 |
65 | resp = self.parent_admin_with_validation.api_node_moved_view(request)
66 |
67 | self.assertEqual(resp.status_code, 409)
68 |
69 | def test_invalid_move(self):
70 | """Ensure that if move can't be performed due validation error, move
71 | can't be performed and json error returned
72 | """
73 | request = MagicMock()
74 | request.POST = {
75 | "moved_id": self.child2_invalid_move.id,
76 | "target_id": self.child1_invalid_move.id,
77 | "previous_parent_id": self.parent_invalid_move.id,
78 | "position": "inside",
79 | }
80 |
81 | resp = self.parent_admin_invalid_move.api_node_moved_view(request)
82 |
83 | self.assertEqual(resp.status_code, 409)
84 |
85 | def test_get_permission_codename(self):
86 | # This is to test whether our function works in older Django versions.
87 | self.assertEqual(get_permission_codename("change", Model2A._meta), "change_model2a")
88 |
--------------------------------------------------------------------------------
/polymorphic_tree/tests/test_models.py:
--------------------------------------------------------------------------------
1 | from django.db.models import Q
2 | from django.test import TestCase
3 |
4 | from polymorphic_tree.managers import PolymorphicMPTTModelManager
5 |
6 | from .models import *
7 |
8 |
9 | class PolymorphicTests(TestCase):
10 | """
11 | Test Suite, largely derived from django-polymorphic tests
12 |
13 | TODO: potentially port these tests from django_polymorphic.tests
14 |
15 | test_foreignkey_field()
16 | test_onetoone_field()
17 | test_manytomany_field()
18 | test_extra_method()
19 | test_instance_of_filter()
20 | test_polymorphic___filter()
21 | test_delete()
22 | test_combine_querysets()
23 | test_multiple_inheritance()
24 | test_relation_base()
25 | test_user_defined_manager()
26 | test_manager_inheritance()
27 | test_queryset_assignment()
28 | test_proxy_models()
29 | test_proxy_get_real_instance_class()
30 | test_content_types_for_proxy_models()
31 | test_proxy_model_inheritance()
32 | test_custom_pk()
33 | test_fix_getattribute()
34 | test_parent_link_and_related_name()
35 | test_child_type_validation_in_memory()
36 |
37 | """
38 |
39 | def create_model2abcd(self):
40 | """
41 | Create the chain of objects of Model2,
42 | this is reused in various tests.
43 | """
44 | Model2A.objects.create(field1="A1")
45 | Model2B.objects.create(field1="B1", field2="B2")
46 | Model2C.objects.create(field1="C1", field2="C2", field3="C3")
47 | Model2D.objects.create(field1="D1", field2="D2", field3="D3", field4="D4")
48 |
49 | def test_simple_inheritance(self):
50 | self.create_model2abcd()
51 |
52 | objects = list(Model2A.objects.all())
53 | self.assertEqual(
54 | repr(objects[0]), ''
55 | )
56 | self.assertEqual(
57 | repr(objects[1]),
58 | '',
59 | )
60 | self.assertEqual(
61 | repr(objects[2]),
62 | '',
63 | )
64 | self.assertEqual(
65 | repr(objects[3]),
66 | '',
67 | )
68 |
69 | def test_manual_get_real_instance(self):
70 | self.create_model2abcd()
71 |
72 | o = Model2A.objects.non_polymorphic().get(field1="C1")
73 | self.assertEqual(
74 | repr(o.get_real_instance()),
75 | '',
76 | )
77 |
78 | def test_non_polymorphic(self):
79 | self.create_model2abcd()
80 |
81 | objects = list(Model2A.objects.all().non_polymorphic())
82 | self.assertEqual(
83 | repr(objects[0]), ''
84 | )
85 | self.assertEqual(
86 | repr(objects[1]), ''
87 | )
88 | self.assertEqual(
89 | repr(objects[2]), ''
90 | )
91 | self.assertEqual(
92 | repr(objects[3]), ''
93 | )
94 |
95 | def test_get_real_instances(self):
96 | self.create_model2abcd()
97 | qs = Model2A.objects.all().non_polymorphic()
98 |
99 | # from queryset
100 | objects = qs.get_real_instances()
101 | self.assertEqual(
102 | repr(objects[0]), ''
103 | )
104 | self.assertEqual(
105 | repr(objects[1]),
106 | '',
107 | )
108 | self.assertEqual(
109 | repr(objects[2]),
110 | '',
111 | )
112 | self.assertEqual(
113 | repr(objects[3]),
114 | '',
115 | )
116 |
117 | # from a manual list
118 | objects = Model2A.objects.get_real_instances(list(qs))
119 | self.assertEqual(
120 | repr(objects[0]), ''
121 | )
122 | self.assertEqual(
123 | repr(objects[1]),
124 | '',
125 | )
126 | self.assertEqual(
127 | repr(objects[2]),
128 | '',
129 | )
130 | self.assertEqual(
131 | repr(objects[3]),
132 | '',
133 | )
134 |
135 | def test_translate_polymorphic_q_object(self):
136 | self.create_model2abcd()
137 |
138 | q = Model2A.translate_polymorphic_Q_object(Q(instance_of=Model2C))
139 | objects = Model2A.objects.filter(q)
140 | self.assertEqual(
141 | repr(objects[0]),
142 | '',
143 | )
144 | self.assertEqual(
145 | repr(objects[1]),
146 | '',
147 | )
148 |
149 | def test_base_manager(self):
150 | def base_manager(model):
151 | return (type(model._base_manager), model._base_manager.model)
152 |
153 | self.assertEqual(base_manager(PlainA), (models.Manager, PlainA))
154 | self.assertEqual(base_manager(PlainB), (models.Manager, PlainB))
155 | self.assertEqual(base_manager(PlainC), (models.Manager, PlainC))
156 |
157 | # Unlike standard polymorphic, the manager persists everywhere.
158 | # This makes sure that the features of MPTT are also available everywhere.
159 | self.assertEqual(base_manager(Model2A), (PolymorphicMPTTModelManager, Model2A))
160 | self.assertEqual(base_manager(Model2B), (PolymorphicMPTTModelManager, Model2B))
161 | self.assertEqual(base_manager(Model2C), (PolymorphicMPTTModelManager, Model2C))
162 |
163 | self.assertEqual(base_manager(One2OneRelatingModel), (PolymorphicMPTTModelManager, One2OneRelatingModel))
164 | self.assertEqual(
165 | base_manager(One2OneRelatingModelDerived), (PolymorphicMPTTModelManager, One2OneRelatingModelDerived)
166 | )
167 |
168 | def test_instance_default_manager(self):
169 | def show_default_manager(instance):
170 | return "{} {}".format(repr(type(instance.__class__.objects)), repr(instance.__class__.objects.model))
171 |
172 | plain_a = PlainA(field1="C1")
173 | plain_b = PlainB(field2="C1")
174 | plain_c = PlainC(field3="C1")
175 |
176 | model_2a = Model2A(field1="C1")
177 | model_2b = Model2B(field2="C1")
178 | model_2c = Model2C(field3="C1")
179 |
180 | self.assertEqual(
181 | show_default_manager(plain_a),
182 | " ",
183 | )
184 | self.assertEqual(
185 | show_default_manager(plain_b),
186 | " ",
187 | )
188 | self.assertEqual(
189 | show_default_manager(plain_c),
190 | " ",
191 | )
192 |
193 | self.assertEqual(
194 | show_default_manager(model_2a),
195 | " ",
196 | )
197 | self.assertEqual(
198 | show_default_manager(model_2b),
199 | " ",
200 | )
201 | self.assertEqual(
202 | show_default_manager(model_2c),
203 | " ",
204 | )
205 |
206 |
207 | class MPTTTests(TestCase):
208 | """
209 | Tests relating to tree structure of polymorphic objects
210 |
211 | TODO: port some tests from https://github.com/django-mptt/django-mptt/blob/master/tests/myapp/tests.py
212 | """
213 |
214 | def test_sibling_methods(self):
215 | """https://github.com/edoburu/django-polymorphic-tree/issues/37"""
216 | root_node = Base.objects.create(field_b="root")
217 | sibling_a = Base.objects.create(field_b="first", parent=root_node)
218 | sibling_b = ModelX.objects.create(field_b="second", field_x="ModelX", parent=root_node)
219 | sibling_c = ModelY.objects.create(field_b="third", field_y="ModelY", parent=root_node)
220 |
221 | # sanity checks
222 | self.assertEqual(list(root_node.get_descendants()), [sibling_a, sibling_b, sibling_c])
223 | self.assertEqual(list(sibling_a.get_siblings()), [sibling_b, sibling_c])
224 | self.assertEqual(list(sibling_b.get_siblings()), [sibling_a, sibling_c])
225 | self.assertEqual(list(sibling_c.get_siblings()), [sibling_a, sibling_b])
226 |
227 | # When looking for siblings, it should be done from the base model,
228 | # not and not the child model type (which may not find all instances)
229 | self.assertEqual(sibling_a.get_previous_sibling(), None)
230 | self.assertEqual(sibling_a.get_next_sibling(), sibling_b)
231 |
232 | self.assertEqual(sibling_b.get_previous_sibling(), sibling_a)
233 | self.assertEqual(sibling_b.get_next_sibling(), sibling_c)
234 |
235 | self.assertEqual(sibling_c.get_previous_sibling(), sibling_b)
236 | self.assertEqual(sibling_c.get_next_sibling(), None)
237 |
238 | def test_get_ancestors(self):
239 | """https://github.com/edoburu/django-polymorphic-tree/issues/32"""
240 | root_node = Base.objects.create(field_b="root")
241 | child = ModelX.objects.create(field_b="child", field_x="ModelX", parent=root_node)
242 | grandchild = ModelY.objects.create(field_b="grandchild", field_y="ModelY", parent=child)
243 |
244 | self.assertEqual(list(root_node.get_ancestors()), [])
245 | self.assertEqual(list(child.get_ancestors()), [root_node])
246 | self.assertEqual(list(grandchild.get_ancestors()), [root_node, child])
247 |
248 | self.assertEqual(list(root_node.get_ancestors(include_self=True)), [root_node])
249 | self.assertEqual(list(child.get_ancestors(include_self=True)), [root_node, child])
250 | self.assertEqual(list(grandchild.get_ancestors(include_self=True)), [root_node, child, grandchild])
251 |
252 | self.assertEqual(list(root_node.get_ancestors(ascending=True)), [])
253 | self.assertEqual(list(child.get_ancestors(ascending=True)), [root_node])
254 | self.assertEqual(list(grandchild.get_ancestors(ascending=True)), [child, root_node])
255 |
256 | def test_is_ancestor_of(self):
257 | root_node = Base.objects.create(field_b="root")
258 | child = ModelX.objects.create(field_b="child", field_x="ModelX", parent=root_node)
259 | grandchild = ModelY.objects.create(field_b="grandchild", field_y="ModelY", parent=child)
260 |
261 | self.assertTrue(root_node.is_ancestor_of(child))
262 | self.assertTrue(root_node.is_ancestor_of(grandchild))
263 | self.assertFalse(child.is_ancestor_of(root_node))
264 | self.assertTrue(child.is_ancestor_of(grandchild))
265 | self.assertFalse(grandchild.is_ancestor_of(child))
266 | self.assertFalse(grandchild.is_ancestor_of(root_node))
267 |
268 | def test_node_type_checking(self):
269 | root_node = Base.objects.create(field_b="root")
270 | child = ModelX.objects.create(field_b="child", field_x="ModelX", parent=root_node)
271 | grandchild = ModelY.objects.create(field_b="grandchild", field_y="ModelY", parent=child)
272 |
273 | self.assertFalse(root_node.is_child_node())
274 | self.assertFalse(root_node.is_leaf_node())
275 | self.assertTrue(root_node.is_root_node())
276 |
277 | self.assertTrue(child.is_child_node())
278 | self.assertFalse(child.is_leaf_node())
279 | self.assertFalse(child.is_root_node())
280 |
281 | self.assertTrue(grandchild.is_child_node())
282 | self.assertTrue(grandchild.is_leaf_node())
283 | self.assertFalse(grandchild.is_root_node())
284 |
285 | def test_child_type_validation_in_memory(self):
286 | root_node = ModelRestrictedChildren.objects.create(field_b="root")
287 |
288 | valid_child = ModelX(field_b="valid_child", field_x="ModelX", parent=root_node)
289 | valid_child.clean()
290 |
291 | with self.assertRaises(ValidationError) as context:
292 | invalid_child = ModelY(field_b="invalid_child", field_y="ModelY", parent=root_node)
293 | invalid_child.clean()
294 |
295 | msg = context.exception.args[0]["parent"]
296 | self.assertIn("a model restricted children does not allow model y as a child!", msg)
297 |
298 | def test_tree_manager(self):
299 | # Having the tree manager correct is absolutely essential,
300 | # so our move validation is also triggered.
301 | self.assertIsInstance(Model2A()._tree_manager, PolymorphicMPTTModelManager)
302 | self.assertIsInstance(Model2B()._tree_manager, PolymorphicMPTTModelManager)
303 | self.assertIsInstance(Model2C()._tree_manager, PolymorphicMPTTModelManager)
304 |
305 | def test_can_be_root(self):
306 | node = ModelMustBeChild(field8="foo")
307 | self.assertRaisesMessage(ValidationError, "This node type should have a parent", lambda: node.clean())
308 |
309 | parent = ModelMustBeChildRoot(field8="test")
310 | parent.clean()
311 | parent.save()
312 | node.parent = parent
313 | node.clean()
314 | node.save()
315 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [tool.isort]
2 | profile = "black"
3 | line_length = 120
4 |
5 | [tool.black]
6 | line-length = 120
7 | exclude = '''
8 | /(
9 | \.git
10 | | \.tox
11 | | \.venv
12 | | dist
13 | )/
14 | '''
15 |
--------------------------------------------------------------------------------
/runtests.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python -Wd
2 | import sys
3 | import warnings
4 | from os import path
5 |
6 | import django
7 | from django.conf import global_settings as default_settings
8 | from django.conf import settings
9 | from django.core.management import execute_from_command_line
10 |
11 | # python -Wd, or run via coverage:
12 | warnings.simplefilter("always", DeprecationWarning)
13 |
14 | # Give feedback on used versions
15 | sys.stderr.write(f"Using Python version {sys.version[:5]} from {sys.executable}\n")
16 | sys.stderr.write(
17 | "Using Django version {} from {}\n".format(django.get_version(), path.dirname(path.abspath(django.__file__)))
18 | )
19 |
20 | if not settings.configured:
21 | module_root = path.dirname(path.realpath(__file__))
22 |
23 | sys.path.insert(0, path.join(module_root, "example"))
24 |
25 | settings.configure(
26 | DEBUG=False, # will be False anyway by DjangoTestRunner.
27 | DATABASES={"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}},
28 | DEFAULT_AUTO_FIELD="django.db.models.AutoField",
29 | CACHES={
30 | # By explicit since many tests also need the caching support
31 | "default": {
32 | "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
33 | "LOCATION": "unique-snowflake",
34 | }
35 | },
36 | SECRET_KEY="testtest",
37 | TEMPLATES=[
38 | {
39 | "BACKEND": "django.template.backends.django.DjangoTemplates",
40 | "DIRS": (),
41 | "OPTIONS": {
42 | "debug": True,
43 | "loaders": (
44 | "django.template.loaders.filesystem.Loader",
45 | "django.template.loaders.app_directories.Loader",
46 | ),
47 | "context_processors": (
48 | "django.template.context_processors.debug",
49 | "django.template.context_processors.i18n",
50 | "django.template.context_processors.media",
51 | "django.template.context_processors.request",
52 | "django.template.context_processors.static",
53 | "django.contrib.auth.context_processors.auth",
54 | "django.contrib.messages.context_processors.messages",
55 | ),
56 | },
57 | },
58 | ],
59 | INSTALLED_APPS=(
60 | "django.contrib.admin",
61 | "django.contrib.auth",
62 | "django.contrib.contenttypes",
63 | "django.contrib.messages",
64 | "django.contrib.sites",
65 | "mptt",
66 | "polymorphic",
67 | "polymorphic_tree",
68 | "polymorphic_tree.tests",
69 | ),
70 | # we define MIDDLEWARE_CLASSES explicitly, the default were changed in django 1.7
71 | MIDDLEWARE=(
72 | "django.contrib.sessions.middleware.SessionMiddleware",
73 | "django.contrib.auth.middleware.AuthenticationMiddleware",
74 | "django.contrib.messages.middleware.MessageMiddleware",
75 | "django.middleware.locale.LocaleMiddleware", # / will be redirected to //
76 | ),
77 | ROOT_URLCONF="example.urls",
78 | TEST_RUNNER="django.test.runner.DiscoverRunner",
79 | )
80 |
81 |
82 | DEFAULT_TEST_APPS = [
83 | "polymorphic_tree",
84 | ]
85 |
86 |
87 | def runtests():
88 | other_args = list(filter(lambda arg: arg.startswith("-"), sys.argv[1:]))
89 | test_apps = list(filter(lambda arg: not arg.startswith("-"), sys.argv[1:])) or DEFAULT_TEST_APPS
90 | argv = sys.argv[:1] + ["test", "--traceback"] + other_args + test_apps
91 | execute_from_command_line(argv)
92 |
93 |
94 | if __name__ == "__main__":
95 | runtests()
96 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | import codecs
3 | import os
4 | import re
5 | import sys
6 | from os import path
7 |
8 | from setuptools import find_packages, setup
9 |
10 | # When creating the sdist, make sure the django.mo file also exists:
11 | if "sdist" in sys.argv or "develop" in sys.argv:
12 | os.chdir("polymorphic_tree")
13 | try:
14 | from django.core import management
15 |
16 | management.call_command("compilemessages", stdout=sys.stderr, verbosity=1)
17 | except ImportError:
18 | if "sdist" in sys.argv:
19 | raise
20 | finally:
21 | os.chdir("..")
22 |
23 |
24 | def read(*parts):
25 | file_path = path.join(path.dirname(__file__), *parts)
26 | return codecs.open(file_path, encoding="utf-8").read()
27 |
28 |
29 | def find_version(*parts):
30 | version_file = read(*parts)
31 | version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M)
32 | if version_match:
33 | return str(version_match.group(1))
34 | raise RuntimeError("Unable to find version string.")
35 |
36 |
37 | setup(
38 | name="django-polymorphic-tree",
39 | version=find_version("polymorphic_tree", "__init__.py"),
40 | license="Apache 2.0",
41 | install_requires=[
42 | "django-polymorphic>=3",
43 | "django-mptt>=0.9.1",
44 | "django-tag-parser>=2.1",
45 | ],
46 | requires=[
47 | "Django (>=2.1)",
48 | ],
49 | description="A polymorphic mptt structure to display content in a tree.",
50 | long_description=read("README.rst"),
51 | author="Diederik van der Boor",
52 | author_email="opensource@edoburu.nl",
53 | url="https://github.com/django-polymorphic/django-polymorphic-tree",
54 | download_url="https://github.com/django-polymorphic/django-polymorphic-tree/zipball/master",
55 | packages=find_packages(),
56 | include_package_data=True,
57 | zip_safe=False,
58 | classifiers=[
59 | "Development Status :: 5 - Production/Stable",
60 | "Environment :: Web Environment",
61 | "Framework :: Django",
62 | "Intended Audience :: Developers",
63 | "License :: OSI Approved :: Apache Software License",
64 | "Operating System :: OS Independent",
65 | "Programming Language :: Python",
66 | "Programming Language :: Python :: 3.7",
67 | "Programming Language :: Python :: 3.8",
68 | "Programming Language :: Python :: 3.9",
69 | "Framework :: Django",
70 | "Framework :: Django :: 2.2",
71 | "Framework :: Django :: 3.0",
72 | "Framework :: Django :: 3.1",
73 | "Topic :: Internet :: WWW/HTTP",
74 | "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
75 | "Topic :: Software Development :: Libraries :: Python Modules",
76 | ],
77 | )
78 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | envlist=
3 | py37-django{21,22,30,31},
4 | ; docs,
5 |
6 | [testenv]
7 | deps =
8 | django-polymorphic >= 3.0
9 | django-mptt >= 0.9.0
10 | django21: Django ~= 2.1
11 | django22: Django ~= 2.2
12 | django30: Django ~= 3.0
13 | django31: Django ~= 3.1
14 | ; django-dev: https://github.com/django/django/tarball/master
15 | commands=
16 | python runtests.py
17 |
18 | ; Have no configuration for sphinx in project repository
19 | ;[testenv:docs]
20 | ;deps=Sphinx
21 | ;changedir = docs
22 | ;commands = sphinx-build -W -b html -d {envtmpdir}/doctrees . {envtmpdir}/html
23 |
--------------------------------------------------------------------------------
'.format(
90 | parent_attr=self.model._mptt_meta.parent_attr,
91 | id=node.pk,
92 | title=_("Add sub node"),
93 | static=settings.STATIC_URL,
94 | )
95 | )
96 | else:
97 | actions.append(self.EMPTY_ACTION_ICON.format(STATIC_URL=settings.STATIC_URL, css_class="add-child-object"))
98 |
99 | if self.can_preview_object(node):
100 | actions.append(
101 | ''
102 | '
'.format(
103 | url=node.get_absolute_url(), title=_("View on site"), static=settings.STATIC_URL
104 | )
105 | )
106 |
107 | # The is_first_sibling and is_last_sibling is quite heavy. Instead rely on CSS to hide the arrows.
108 | move_up = f'\u2191'
109 | move_down = f'\u2193'
110 | actions.append(f'{move_up}{move_down}')
111 | return actions
112 |
113 | def can_preview_object(self, node):
114 | """
115 | Define whether a node can be previewed.
116 | """
117 | return hasattr(node, "get_absolute_url")
118 |
119 | # ---- Custom views ----
120 |
121 | def get_urls(self):
122 | """
123 | Add custom URLs for moving nodes.
124 | """
125 | base_urls = super().get_urls()
126 | info = _get_opt(self.model)
127 | extra_urls = [
128 | path(
129 | "api/node-moved/",
130 | self.admin_site.admin_view(self.api_node_moved_view),
131 | name="{}_{}_moved".format(*info),
132 | ),
133 | re_path(r"^(\d+)/move_up/$", self.admin_site.admin_view(self.move_up_view)),
134 | re_path(r"^(\d+)/move_down/$", self.admin_site.admin_view(self.move_down_view)),
135 | ]
136 | return extra_urls + base_urls
137 |
138 | @property
139 | def api_node_moved_view_url(self):
140 | # Provided for result list template
141 | info = _get_opt(self.model)
142 | return reverse("admin:{}_{}_moved".format(*info), current_app=self.admin_site.name)
143 |
144 | @transaction.atomic
145 | def api_node_moved_view(self, request):
146 | """
147 | Update the position of a node, from a API request.
148 | """
149 | try:
150 | moved_id = _get_pk_value(request.POST["moved_id"])
151 | target_id = _get_pk_value(request.POST["target_id"])
152 | position = request.POST["position"]
153 |
154 | if request.POST.get("previous_parent_id"):
155 | previous_parent_id = _get_pk_value(request.POST["previous_parent_id"])
156 | else:
157 | previous_parent_id = None
158 |
159 | # Not using .non_polymorphic() so all models are downcasted to the derived model.
160 | # This causes the signal below to be emitted from the proper class as well.
161 | moved = self.model.objects.get(pk=moved_id)
162 | target = self.model.objects.get(pk=target_id)
163 | except (ValueError, KeyError) as e:
164 | return HttpResponseBadRequest(
165 | json.dumps({"action": "foundbug", "error": str(e[0])}), content_type="application/json"
166 | )
167 | except self.model.DoesNotExist as e:
168 | return HttpResponseNotFound(
169 | json.dumps({"action": "reload", "error": str(e[0])}), content_type="application/json"
170 | )
171 |
172 | if not request.user.has_perm(
173 | "{}.{}".format(moved._meta.app_label, get_permission_codename("change", moved._meta))
174 | ):
175 | return HttpResponse(
176 | json.dumps(
177 | {
178 | "action": "reject",
179 | "moved_id": moved_id,
180 | "error": gettext("You do not have permission to move this node."),
181 | }
182 | ),
183 | content_type="application/json",
184 | status=409,
185 | )
186 |
187 | # Compare on strings to support UUID fields.
188 | parent_attr_id = f"{moved._mptt_meta.parent_attr}_id"
189 | if str(getattr(moved, parent_attr_id)) != str(previous_parent_id):
190 | return HttpResponse(
191 | json.dumps({"action": "reload", "error": "Client seems to be out-of-sync, please reload!"}),
192 | content_type="application/json",
193 | status=409,
194 | )
195 |
196 | mptt_position = {
197 | "inside": "first-child",
198 | "before": "left",
199 | "after": "right",
200 | }[position]
201 | try:
202 | moved.move_to(target, mptt_position)
203 | except ValidationError as e:
204 | return HttpResponse(
205 | json.dumps({"action": "reject", "moved_id": moved_id, "error": "\n".join(e.messages)}),
206 | content_type="application/json",
207 | status=409,
208 | ) # Conflict
209 | except InvalidMove as e:
210 | return HttpResponse(
211 | json.dumps({"action": "reject", "moved_id": moved_id, "error": str(e)}),
212 | content_type="application/json",
213 | status=409,
214 | )
215 |
216 | # Some packages depend on calling .save() or post_save signal after updating a model.
217 | # This is required by django-fluent-pages for example to update the URL caches.
218 | moved.save()
219 |
220 | # Report back to client.
221 | return HttpResponse(
222 | json.dumps(
223 | {
224 | "action": "success",
225 | "error": None,
226 | "moved_id": moved_id,
227 | "action_column": self.actions_column(moved),
228 | }
229 | ),
230 | content_type="application/json",
231 | )
232 |
233 | def move_up_view(self, request, object_id):
234 | node = self.model.objects.get(pk=object_id)
235 |
236 | if node is not None:
237 | previous_sibling_category = node.get_previous_sibling()
238 | if previous_sibling_category is not None:
239 | node.move_to(previous_sibling_category, position="left")
240 |
241 | return HttpResponseRedirect("../../")
242 |
243 | def move_down_view(self, request, object_id):
244 | node = self.model.objects.get(pk=object_id)
245 |
246 | if node is not None:
247 | next_sibling_category = node.get_next_sibling()
248 | if next_sibling_category is not None:
249 | node.move_to(next_sibling_category, position="right")
250 |
251 | return HttpResponseRedirect("../../")
252 |
253 |
254 | def _get_opt(model):
255 | try:
256 | return model._meta.app_label, model._meta.model_name # Django 1.7 format
257 | except AttributeError:
258 | return model._meta.app_label, model._meta.module_name
259 |
260 |
261 | def _get_pk_value(text):
262 | try:
263 | return int(text)
264 | except ValueError:
265 | return text # Allow uuid fields
266 |
--------------------------------------------------------------------------------
/polymorphic_tree/locale/es_AR/LC_MESSAGES/django.po:
--------------------------------------------------------------------------------
1 | # Copyright (C) 2010-2012
2 | # This file is distributed under the same license as the PACKAGE package.
3 | #
4 | # Gonzalo Bustos, 2016.
5 | msgid ""
6 | msgstr ""
7 | "Project-Id-Version: \n"
8 | "Report-Msgid-Bugs-To: \n"
9 | "POT-Creation-Date: 2017-02-18 19:29+0100\n"
10 | "PO-Revision-Date: 2011-01-10 23:54+0100\n"
11 | "Last-Translator: Gonzalo Bustos\n"
12 | "Language-Team: Spanish (Argentina)