1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
from django.conf import settings
from django.db import models
from django.utils.safestring import mark_safe
from markupfield import widgets
from markupfield import markup
_rendered_field_name = lambda name: '_%s_rendered' % name
_markup_type_field_name = lambda name: '%s_markup_type' % name
# for fields that don't set markup_types: detected types or from settings
_MARKUP_TYPES = getattr(settings, 'MARKUP_FIELD_TYPES', markup.DEFAULT_MARKUP_TYPES)
class Markup(object):
def __init__(self, instance, field_name, rendered_field_name,
markup_type_field_name):
# instead of storing actual values store a reference to the instance
# along with field names, this makes assignment possible
self.instance = instance
self.field_name = field_name
self.rendered_field_name = rendered_field_name
self.markup_type_field_name = markup_type_field_name
# raw is read/write
def _get_raw(self):
return self.instance.__dict__[self.field_name]
def _set_raw(self, val):
setattr(self.instance, self.field_name, val)
raw = property(_get_raw, _set_raw)
# markup_type is read/write
def _get_markup_type(self):
return self.instance.__dict__[self.markup_type_field_name]
def _set_markup_type(self, val):
return setattr(self.instance, self.markup_type_field_name, val)
markup_type = property(_get_markup_type, _set_markup_type)
# rendered is a read only property
def _get_rendered(self):
return getattr(self.instance, self.rendered_field_name)
rendered = property(_get_rendered)
# allows display via templates to work without safe filter
def __unicode__(self):
return mark_safe(self.rendered)
class MarkupDescriptor(object):
def __init__(self, field):
self.field = field
self.rendered_field_name = _rendered_field_name(self.field.name)
self.markup_type_field_name = _markup_type_field_name(self.field.name)
def __get__(self, instance, owner):
if instance is None:
raise AttributeError('Can only be accessed via an instance.')
markup = instance.__dict__[self.field.name]
if markup is None:
return None
return Markup(instance, self.field.name, self.rendered_field_name,
self.markup_type_field_name)
def __set__(self, obj, value):
if isinstance(value, Markup):
obj.__dict__[self.field.name] = value.raw
setattr(obj, self.rendered_field_name, value.rendered)
setattr(obj, self.markup_type_field_name, value.markup_type)
else:
obj.__dict__[self.field.name] = value
class MarkupField(models.TextField):
def __init__(self, verbose_name=None, name=None, markup_type=None,
default_markup_type=None, markup_choices=_MARKUP_TYPES,
**kwargs):
if markup_type and default_markup_type:
raise ValueError('Cannot specify both markup_type and default_markup_type')
self.default_markup_type = markup_type or default_markup_type
self.markup_type_editable = markup_type is None
# pre 1.0 markup_choices might have been a dict
if isinstance(markup_choices, dict):
raise DeprecationWarning('passing a dictionary as markup_choices is deprecated')
self.markup_choices_dict = markup_choices
self.markup_choices_list = markup_choices.keys()
else:
self.markup_choices_list = [mc[0] for mc in markup_choices]
self.markup_choices_dict = dict(markup_choices)
if (self.default_markup_type and
self.default_markup_type not in self.markup_choices_list):
raise ValueError("Invalid default_markup_type for field '%s', allowed values: %s" %
(name, ', '.join(self.markup_choices_list)))
super(MarkupField, self).__init__(verbose_name, name, **kwargs)
def contribute_to_class(self, cls, name):
if not cls._meta.abstract:
choices = zip(self.markup_choices_list, self.markup_choices_list)
markup_type_field = models.CharField(max_length=30,
choices=choices, default=self.default_markup_type,
editable=self.markup_type_editable, blank=self.blank)
rendered_field = models.TextField(editable=False)
markup_type_field.creation_counter = self.creation_counter+1
rendered_field.creation_counter = self.creation_counter+2
cls.add_to_class(_markup_type_field_name(name), markup_type_field)
cls.add_to_class(_rendered_field_name(name), rendered_field)
super(MarkupField, self).contribute_to_class(cls, name)
setattr(cls, self.name, MarkupDescriptor(self))
def pre_save(self, model_instance, add):
value = super(MarkupField, self).pre_save(model_instance, add)
if value.markup_type not in self.markup_choices_list:
raise ValueError('Invalid markup type (%s), allowed values: %s' %
(value.markup_type,
', '.join(self.markup_choices_list)))
rendered = self.markup_choices_dict[value.markup_type](value.raw)
setattr(model_instance, _rendered_field_name(self.attname), rendered)
return value.raw
def get_db_prep_value(self, value):
# for Django 1.2+ rename this to get_prep_value
if isinstance(value, Markup):
return value.raw
else:
return value
def value_to_string(self, obj):
value = self._get_val_from_obj(obj)
return value.raw
def formfield(self, **kwargs):
defaults = {'widget': widgets.MarkupTextarea}
defaults.update(kwargs)
return super(MarkupField, self).formfield(**defaults)
# register MarkupField to use the custom widget in the Admin
from django.contrib.admin.options import FORMFIELD_FOR_DBFIELD_DEFAULTS
FORMFIELD_FOR_DBFIELD_DEFAULTS[MarkupField] = {'widget': widgets.AdminMarkupTextareaWidget}
|
