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