Added philo-root reversal caching to Node.construct_url.
[philo.git] / philo / admin / forms / containers.py
1 from django import forms
2 from django.contrib.admin.widgets import AdminTextareaWidget
3 from django.core.exceptions import ObjectDoesNotExist
4 from django.db.models import Q
5 from django.forms.models import ModelForm, BaseInlineFormSet, BaseModelFormSet
6 from django.forms.formsets import TOTAL_FORM_COUNT
7 from django.utils.datastructures import SortedDict
8
9 from philo.admin.widgets import ModelLookupWidget
10 from philo.models import Contentlet, ContentReference
11
12
13 __all__ = (
14         'ContentletForm',
15         'ContentletInlineFormSet',
16         'ContentReferenceForm',
17         'ContentReferenceInlineFormSet'
18 )
19
20
21 class ContainerForm(ModelForm):
22         def __init__(self, *args, **kwargs):
23                 super(ContainerForm, self).__init__(*args, **kwargs)
24                 self.verbose_name = self.instance.name.replace('_', ' ')
25                 self.prefix = self.instance.name
26
27
28 class ContentletForm(ContainerForm):
29         content = forms.CharField(required=False, widget=AdminTextareaWidget, label='Content')
30         
31         def should_delete(self):
32                 # Delete iff: the data has changed and is now empty.
33                 return self.has_changed() and not bool(self.cleaned_data['content'])
34         
35         class Meta:
36                 model = Contentlet
37                 fields = ['content']
38
39
40 class ContentReferenceForm(ContainerForm):
41         def __init__(self, *args, **kwargs):
42                 super(ContentReferenceForm, self).__init__(*args, **kwargs)
43                 try:
44                         self.fields['content_id'].widget = ModelLookupWidget(self.instance.content_type)
45                 except ObjectDoesNotExist:
46                         # This will happen when an empty form (which we will never use) gets instantiated.
47                         pass
48         
49         def should_delete(self):
50                 return self.has_changed() and (self.cleaned_data['content_id'] is None)
51         
52         class Meta:
53                 model = ContentReference
54                 fields = ['content_id']
55
56
57 class ContainerInlineFormSet(BaseInlineFormSet):
58         @property
59         def containers(self):
60                 if not hasattr(self, '_containers'):
61                         self._containers = self.get_containers()
62                 return self._containers
63         
64         def total_form_count(self):
65                 # This ignores the posted management form data... but that doesn't
66                 # seem to have any ill side effects.
67                 return len(self.containers.keys())
68         
69         def _get_initial_forms(self):
70                 return [form for form in self.forms if form.instance.pk is not None]
71         initial_forms = property(_get_initial_forms)
72         
73         def _get_extra_forms(self):
74                 return [form for form in self.forms if form.instance.pk is None]
75         extra_forms = property(_get_extra_forms)
76         
77         def _construct_form(self, i, **kwargs):
78                 if 'instance' not in kwargs:
79                         kwargs['instance'] = self.containers.values()[i]
80                 
81                 # Skip over the BaseModelFormSet. We have our own way of doing things!
82                 form = super(BaseModelFormSet, self)._construct_form(i, **kwargs)
83                 
84                 # Since we skipped over BaseModelFormSet, we need to duplicate what BaseInlineFormSet would do.
85                 if self.save_as_new:
86                         # Remove the primary key from the form's data, we are only
87                         # creating new instances
88                         form.data[form.add_prefix(self._pk_field.name)] = None
89                         
90                         # Remove the foreign key from the form's data
91                         form.data[form.add_prefix(self.fk.name)] = None
92                 
93                 # Set the fk value here so that the form can do it's validation.
94                 setattr(form.instance, self.fk.get_attname(), self.instance.pk)
95                 return form
96         
97         def add_fields(self, form, index):
98                 """Override the pk field's initial value with a real one."""
99                 super(ContainerInlineFormSet, self).add_fields(form, index)
100                 if index is not None:
101                         pk_value = self.containers.values()[index].pk
102                 else:
103                         pk_value = None
104                 form.fields[self._pk_field.name].initial = pk_value
105         
106         def save_existing_objects(self, commit=True):
107                 self.changed_objects = []
108                 self.deleted_objects = []
109                 if not self.get_queryset():
110                         return []
111                 
112                 saved_instances = []
113                 for form in self.initial_forms:
114                         pk_name = self._pk_field.name
115                         raw_pk_value = form._raw_value(pk_name)
116                         
117                         # clean() for different types of PK fields can sometimes return
118                         # the model instance, and sometimes the PK. Handle either.
119                         pk_value = form.fields[pk_name].clean(raw_pk_value)
120                         pk_value = getattr(pk_value, 'pk', pk_value)
121                         
122                         # if the pk_value is None, they have just switched to a
123                         # template which didn't contain data about this container.
124                         # Skip!
125                         if pk_value is not None:
126                                 obj = self._existing_object(pk_value)
127                                 if form.should_delete():
128                                         self.deleted_objects.append(obj)
129                                         obj.delete()
130                                         continue
131                                 if form.has_changed():
132                                         self.changed_objects.append((obj, form.changed_data))
133                                         saved_instances.append(self.save_existing(form, obj, commit=commit))
134                                         if not commit:
135                                                 self.saved_forms.append(form)
136                 return saved_instances
137
138         def save_new_objects(self, commit=True):
139                 self.new_objects = []
140                 for form in self.extra_forms:
141                         if not form.has_changed():
142                                 continue
143                         # If someone has marked an add form for deletion, don't save the
144                         # object.
145                         if form.should_delete():
146                                 continue
147                         self.new_objects.append(self.save_new(form, commit=commit))
148                         if not commit:
149                                 self.saved_forms.append(form)
150                 return self.new_objects
151
152
153 class ContentletInlineFormSet(ContainerInlineFormSet):
154         def get_containers(self):
155                 try:
156                         containers = self.instance.containers[0]
157                 except ObjectDoesNotExist:
158                         containers = []
159                 
160                 qs = self.get_queryset().filter(name__in=containers)
161                 container_dict = SortedDict([(container.name, container) for container in qs])
162                 for name in containers:
163                         if name not in container_dict:
164                                 container_dict[name] = self.model(name=name)
165                 
166                 container_dict.keyOrder = containers
167                 return container_dict
168
169
170 class ContentReferenceInlineFormSet(ContainerInlineFormSet):
171         def get_containers(self):
172                 try:
173                         containers = self.instance.containers[1]
174                 except ObjectDoesNotExist:
175                         containers = {}
176                 
177                 filter = Q()
178                 for name, ct in containers.items():
179                         filter |= Q(name=name, content_type=ct)
180                 qs = self.get_queryset().filter(filter)
181                 
182                 container_dict = SortedDict([(container.name, container) for container in qs])
183                 
184                 keyOrder = []
185                 for name, ct in containers.items():
186                         keyOrder.append(name)
187                         if name not in container_dict:
188                                 container_dict[name] = self.model(name=name, content_type=ct)
189                 
190                 container_dict.keyOrder = keyOrder
191                 return container_dict