Removed backwards-compatibility for database template loader. Added VERSION information.
[philo.git] / forms / entities.py
1 from django.forms.models import ModelFormMetaclass, ModelForm, ModelFormOptions
2 from django.utils.datastructures import SortedDict
3 from philo.utils import fattr
4
5
6 __all__ = ('EntityForm',)
7
8
9 def proxy_fields_for_entity_model(entity_model, fields=None, exclude=None, widgets=None, formfield_callback=None):
10         field_list = []
11         ignored = []
12         opts = entity_model._entity_meta
13         for f in opts.proxy_fields:
14                 if not f.editable:
15                         continue
16                 if fields and not f.name in fields:
17                         continue
18                 if exclude and f.name in exclude:
19                         continue
20                 if widgets and f.name in widgets:
21                         kwargs = {'widget': widgets[f.name]}
22                 else:
23                         kwargs = {}
24                 
25                 if formfield_callback is None:
26                         formfield = f.formfield(**kwargs)
27                 elif not callable(formfield_callback):
28                         raise TypeError('formfield_callback must be a function or callable')
29                 else:
30                         formfield = formfield_callback(f, **kwargs)
31                 
32                 if formfield:
33                         field_list.append((f.name, formfield))
34                 else:
35                         ignored.append(f.name)
36         field_dict = SortedDict(field_list)
37         if fields:
38                 field_dict = SortedDict(
39                         [(f, field_dict.get(f)) for f in fields
40                                 if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored) and (f in field_dict)]
41                 )
42         return field_dict
43
44
45 # HACK until http://code.djangoproject.com/ticket/14082 is resolved.
46 _old = ModelFormMetaclass.__new__
47 def _new(cls, name, bases, attrs):
48         if cls == ModelFormMetaclass:
49                 m = attrs.get('__metaclass__', None)
50                 if m is None:
51                         parents = [b for b in bases if issubclass(b, ModelForm)]
52                         for c in parents:
53                                 if c.__metaclass__ != ModelFormMetaclass:
54                                         m = c.__metaclass__
55                                         break
56         
57                 if m is not None:
58                         return m(name, bases, attrs)
59         
60         return _old(cls, name, bases, attrs)
61 ModelFormMetaclass.__new__ = staticmethod(_new)
62 # END HACK
63
64
65 class EntityFormMetaclass(ModelFormMetaclass):
66         def __new__(cls, name, bases, attrs):
67                 try:
68                         parents = [b for b in bases if issubclass(b, EntityForm)]
69                 except NameError:
70                         # We are defining EntityForm itself
71                         parents = None
72                 sup = super(EntityFormMetaclass, cls)
73                 
74                 if not parents:
75                         # Then there's no business trying to use proxy fields.
76                         return sup.__new__(cls, name, bases, attrs)
77                 
78                 # Fake a declaration of all proxy fields so they'll be handled correctly.
79                 opts = ModelFormOptions(attrs.get('Meta', None))
80                 
81                 if opts.model:
82                         formfield_callback = attrs.get('formfield_callback', None)
83                         proxy_fields = proxy_fields_for_entity_model(opts.model, opts.fields, opts.exclude, opts.widgets, formfield_callback)
84                 else:
85                         proxy_fields = {}
86                 
87                 new_attrs = proxy_fields.copy()
88                 new_attrs.update(attrs)
89                 
90                 new_class = sup.__new__(cls, name, bases, new_attrs)
91                 new_class.proxy_fields = proxy_fields
92                 return new_class
93
94
95 class EntityForm(ModelForm):
96         __metaclass__ = EntityFormMetaclass
97         
98         def __init__(self, *args, **kwargs):
99                 initial = kwargs.pop('initial', None)
100                 instance = kwargs.get('instance', None)
101                 if instance is not None:
102                         new_initial = {}
103                         for f in instance._entity_meta.proxy_fields:
104                                 if self._meta.fields and not f.name in self._meta.fields:
105                                         continue
106                                 if self._meta.exclude and f.name in self._meta.exclude:
107                                         continue
108                                 new_initial[f.name] = f.value_from_object(instance)
109                 else:
110                         new_initial = {}
111                 if initial is not None:
112                         new_initial.update(initial)
113                 kwargs['initial'] = new_initial
114                 super(EntityForm, self).__init__(*args, **kwargs)
115         
116         @fattr(alters_data=True)
117         def save(self, commit=True):
118                 cleaned_data = self.cleaned_data
119                 instance = super(EntityForm, self).save(commit=False)
120                 
121                 for f in instance._entity_meta.proxy_fields:
122                         if not f.editable or not f.name in cleaned_data:
123                                 continue
124                         if self._meta.fields and f.name not in self._meta.fields:
125                                 continue
126                         if self._meta.exclude and f.name in self._meta.exclude:
127                                 continue
128                         setattr(instance, f.attname, f.get_storage_value(cleaned_data[f.name]))
129                 
130                 if commit:
131                         instance.save()
132                         self.save_m2m()
133                 
134                 return instance