def normalize_markdown_fields(self,
obj,
text_fields,
old_rich_text,
model_field_map={},
**kwargs):
if 'rich_text' in kwargs:
rich_text = kwargs['rich_text']
# If the caller has changed the rich_text setting, we will need to
# update any affected fields we already have stored that weren't
# changed in this request by escaping or unescaping their
# contents.
if rich_text != old_rich_text:
for text_field in text_fields:
if text_field not in kwargs:
model_field = \
model_field_map.get(text_field, text_field)
markdown_set_field_escaped(obj, model_field, rich_text)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set for
# for rich-text, in which case we'll need to pre-escape any text
# fields that came in.
for text_field in text_fields:
if text_field in kwargs:
model_field = model_field_map.get(text_field, text_field)
markdown_set_field_escaped(obj, model_field, old_rich_text)
def set_extra_data_text_fields(self, obj, text_field, extra_fields,
**kwargs):
"""Normalizes Markdown-capable text fields in extra_data.
This will check if any Markdown-capable text fields in extra_data
have been changed (either by changing the text or the text type),
and handle the saving of the text and type.
This works just like set_text_fields, but specially handles
how things are stored in extra_data (text_type vs. rich_text fields,
possible lack of presence of a text_type field, etc.).
"""
text_type_field = self._get_text_type_field_name(text_field)
extra_data = obj.extra_data
extra_data_text_field = 'extra_data.' + text_field
extra_data_text_type_field = 'extra_data.' + text_type_field
if extra_data_text_field in extra_fields:
# This field was updated in this request. Make sure it's
# stripped.
extra_data[text_field] = \
extra_fields[extra_data_text_field].strip()
elif extra_data_text_type_field not in extra_fields:
# Nothing about this field has changed, so bail.
return
old_text_type = extra_data.get(text_type_field)
text_type = extra_fields.get(extra_data_text_type_field,
kwargs.get('text_type'))
if text_type is not None:
if old_text_type is None:
old_text_type = self.DEFAULT_EXTRA_DATA_TEXT_TYPE
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if (text_type != old_text_type and
extra_data_text_field not in extra_fields):
markdown_set_field_escaped(
extra_data, text_field,
text_type == self.TEXT_TYPE_MARKDOWN)
elif old_text_type:
# The user didn't specify a text type, but the object may be set
# for Markdown, in which case we'll need to pre-escape the text
# field.
if extra_data_text_field in extra_fields:
markdown_set_field_escaped(
extra_data, text_field,
old_text_type == self.TEXT_TYPE_MARKDOWN)
# Ensure we have a text type set for this field. If one wasn't
# provided or set above, we'll set it to the default now.
extra_data[text_type_field] = \
text_type or self.DEFAULT_EXTRA_DATA_TEXT_TYPE
def set_extra_data_text_fields(self, obj, text_field, extra_fields,
**kwargs):
"""Normalizes Markdown-capable text fields in extra_data.
This will check if any Markdown-capable text fields in extra_data
have been changed (either by changing the text or the text type),
and handle the saving of the text and type.
This works just like set_text_fields, but specially handles
how things are stored in extra_data (text_type vs. rich_text fields,
possible lack of presence of a text_type field, etc.).
"""
text_type_field = self._get_text_type_field_name(text_field)
extra_data = obj.extra_data
extra_data_text_field = 'extra_data.' + text_field
extra_data_text_type_field = 'extra_data.' + text_type_field
if extra_data_text_field in extra_fields:
# This field was updated in this request. Make sure it's
# stripped.
extra_data[text_field] = \
extra_fields[extra_data_text_field].strip()
elif extra_data_text_type_field not in extra_fields:
# Nothing about this field has changed, so bail.
return
old_text_type = extra_data.get(text_type_field)
text_type = extra_fields.get(extra_data_text_type_field,
kwargs.get('text_type'))
if text_type is not None:
if old_text_type is None:
old_text_type = self.DEFAULT_EXTRA_DATA_TEXT_TYPE
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if (text_type != old_text_type and
extra_data_text_field not in extra_fields):
markdown_set_field_escaped(
extra_data, text_field,
text_type == self.TEXT_TYPE_MARKDOWN)
elif old_text_type:
# The user didn't specify a text type, but the object may be set
# for Markdown, in which case we'll need to pre-escape the text
# field.
if extra_data_text_field in extra_fields:
markdown_set_field_escaped(
extra_data, text_field,
old_text_type == self.TEXT_TYPE_MARKDOWN)
# Ensure we have a text type set for this field. If one wasn't
# provided or set above, we'll set it to the default now.
extra_data[text_type_field] = \
text_type or self.DEFAULT_EXTRA_DATA_TEXT_TYPE
def set_text_fields(self,
obj,
text_field,
rich_text_field_name=None,
text_type_field_name=None,
text_model_field=None,
**kwargs):
"""Normalizes Markdown-capable text fields that are being saved."""
if not text_model_field:
text_model_field = text_field
if not text_type_field_name:
text_type_field_name = self._get_text_type_field_name(text_field)
if not rich_text_field_name:
rich_text_field_name = self._get_rich_text_field_name(text_field)
old_rich_text = getattr(obj, rich_text_field_name, None)
if text_field in kwargs:
setattr(obj, text_model_field, kwargs[text_field].strip())
if text_type_field_name in kwargs or 'text_type' in kwargs:
text_type = kwargs.get(text_type_field_name,
kwargs.get('text_type'))
rich_text = (text_type == self.TEXT_TYPE_MARKDOWN)
setattr(obj, rich_text_field_name, rich_text)
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if rich_text != old_rich_text and text_field not in kwargs:
markdown_set_field_escaped(obj, text_model_field, rich_text)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set
# for rich-text, in which case we'll need to pre-escape the text
# field.
if text_field in kwargs:
markdown_set_field_escaped(obj, text_model_field,
old_rich_text)
def set_text_fields(self, obj, text_field,
rich_text_field_name=None,
text_type_field_name=None,
text_model_field=None,
**kwargs):
"""Normalizes Markdown-capable text fields that are being saved."""
if not text_model_field:
text_model_field = text_field
if not text_type_field_name:
text_type_field_name = self._get_text_type_field_name(text_field)
if not rich_text_field_name:
rich_text_field_name = self._get_rich_text_field_name(text_field)
old_rich_text = getattr(obj, rich_text_field_name, None)
if text_field in kwargs:
setattr(obj, text_model_field, kwargs[text_field].strip())
if text_type_field_name in kwargs or 'text_type' in kwargs:
text_type = kwargs.get(text_type_field_name,
kwargs.get('text_type'))
rich_text = (text_type == self.TEXT_TYPE_MARKDOWN)
setattr(obj, rich_text_field_name, rich_text)
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if rich_text != old_rich_text and text_field not in kwargs:
markdown_set_field_escaped(obj, text_model_field,
rich_text)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set
# for rich-text, in which case we'll need to pre-escape the text
# field.
if text_field in kwargs:
markdown_set_field_escaped(obj, text_model_field,
old_rich_text)
def normalize_markdown_fields(self, obj, text_fields, old_rich_text,
model_field_map={}, **kwargs):
if 'rich_text' in kwargs:
rich_text = kwargs['rich_text']
# If the caller has changed the rich_text setting, we will need to
# update any affected fields we already have stored that weren't
# changed in this request by escaping or unescaping their
# contents.
if rich_text != old_rich_text:
for text_field in text_fields:
if text_field not in kwargs:
model_field = \
model_field_map.get(text_field, text_field)
markdown_set_field_escaped(obj, model_field, rich_text)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set for
# for rich-text, in which case we'll need to pre-escape any text
# fields that came in.
for text_field in text_fields:
if text_field in kwargs:
model_field = model_field_map.get(text_field, text_field)
markdown_set_field_escaped(obj, model_field, old_rich_text)
def set_extra_data_text_fields(self, obj, text_field, extra_fields,
**kwargs):
"""Normalize Markdown-capable text fields in extra_data.
This will check if any Markdown-capable text fields in extra_data
have been changed (either by changing the text or the text type),
and handle the saving of the text and type.
This works just like :py:meth:`set_text_fields`, but specially handles
how things are stored in extra_data (text_type vs. rich_text fields,
possible lack of presence of a text_type field, etc.).
Args:
obj (django.db.models.Model):
The object containing Markdown-capable fields to modify.
text_field (unicode):
The key from ``kwargs`` containing the new value for the
text fields.
extra_fields (dict):
Fields passed to the API resource that aren't natively handled
by that resource. These may contain ``extra_data.``-prefixed
keys.
**kwargs (dict):
Any fields passed by the client. This may be checked for a
legacy ``text_type`` field.
Returns:
set:
The keys in ``extra_data`` that were set based on the request.
"""
modified_fields = set()
text_type_field = self._get_text_type_field_name(text_field)
extra_data = obj.extra_data
extra_data_text_field = 'extra_data.' + text_field
extra_data_text_type_field = 'extra_data.' + text_type_field
if extra_data_text_field in extra_fields:
# This field was updated in this request. Make sure it's
# stripped.
extra_data[text_field] = \
extra_fields[extra_data_text_field].strip()
modified_fields.add(text_field)
elif extra_data_text_type_field not in extra_fields:
# Nothing about this field has changed, so bail.
return modified_fields
old_text_type = extra_data.get(text_type_field)
text_type = extra_fields.get(extra_data_text_type_field,
kwargs.get('text_type'))
if text_type is not None:
if old_text_type is None:
old_text_type = self.DEFAULT_EXTRA_DATA_TEXT_TYPE
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if (text_type != old_text_type
and extra_data_text_field not in extra_fields):
markdown_set_field_escaped(
extra_data, text_field,
text_type == self.TEXT_TYPE_MARKDOWN)
modified_fields.add(text_field)
elif old_text_type:
# The user didn't specify a text type, but the object may be set
# for Markdown, in which case we'll need to pre-escape the text
# field.
if extra_data_text_field in extra_fields:
markdown_set_field_escaped(
extra_data, text_field,
old_text_type == self.TEXT_TYPE_MARKDOWN)
modified_fields.add(text_field)
# Ensure we have a text type set for this field. If one wasn't
# provided or set above, we'll set it to the default now.
extra_data[text_type_field] = \
text_type or self.DEFAULT_EXTRA_DATA_TEXT_TYPE
modified_fields.add(text_type_field)
return modified_fields
def set_text_fields(self,
obj,
text_field,
rich_text_field_name=None,
text_type_field_name=None,
text_model_field=None,
**kwargs):
"""Normalize Markdown-capable text fields that are being saved.
Args:
obj (django.db.models.Model):
The object containing Markdown-capable fields to modify.
text_field (unicode):
The key from ``kwargs`` containing the new value for the
text fields.
rich_text_field_name (unicode, optional):
The name of the boolean field on ``obj`` representing the
rich text state.
If not provided, a name will be generated based on the value
of ``text_field`` (``'rich_text'`` if ``text_field`` is
``'text'``, or :samp:`{text_field}_rich_text` otherwise).
text_type_field_name (unicode, optional):
The key from ``kwargs`` containing the text type.
If not provided, a name will be generated based on the value
of ``text_field`` (``'text_type'`` if ``text_field`` is
``'text'``, or :samp:`{text_field}_text_type` otherwise).
text_model_field (unicode, optional):
The name of the text field on ``obj``.
If not provided, ``text_field`` will be used for the value.
**kwargs (dict):
Any fields passed by the client. These should be values
corresponding to ``text_type_field_name`` and ``text_field``
in here.
This may also contain a legacy value of ``'text_type'``,
which will be used if ``text_type_field_name`` is not present.
Returns:
set:
The fields on ``obj`` that were set based on the request.
"""
modified_fields = set()
if not text_model_field:
text_model_field = text_field
if not text_type_field_name:
text_type_field_name = self._get_text_type_field_name(text_field)
if not rich_text_field_name:
rich_text_field_name = self._get_rich_text_field_name(text_field)
old_rich_text = getattr(obj, rich_text_field_name, None)
text = kwargs.get(text_field)
if text is not None:
setattr(obj, text_model_field, text.strip())
modified_fields.add(text_model_field)
legacy_text_type = kwargs.get('text_type')
text_type = kwargs.get(text_type_field_name, legacy_text_type)
if text_type is not None:
rich_text = (text_type == self.TEXT_TYPE_MARKDOWN)
setattr(obj, rich_text_field_name, rich_text)
modified_fields.add(rich_text_field_name)
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if rich_text != old_rich_text and text is None:
markdown_set_field_escaped(obj, text_model_field, rich_text)
modified_fields.add(text_model_field)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set
# for rich-text, in which case we'll need to pre-escape the text
# field.
if text is not None:
markdown_set_field_escaped(obj, text_model_field,
old_rich_text)
modified_fields.add(text_model_field)
return modified_fields
def set_extra_data_text_fields(self, obj, text_field, extra_fields,
**kwargs):
"""Normalize Markdown-capable text fields in extra_data.
This will check if any Markdown-capable text fields in extra_data
have been changed (either by changing the text or the text type),
and handle the saving of the text and type.
This works just like :py:meth:`set_text_fields`, but specially handles
how things are stored in extra_data (text_type vs. rich_text fields,
possible lack of presence of a text_type field, etc.).
Args:
obj (django.db.models.Model):
The object containing Markdown-capable fields to modify.
text_field (unicode):
The key from ``kwargs`` containing the new value for the
text fields.
extra_fields (dict):
Fields passed to the API resource that aren't natively handled
by that resource. These may contain ``extra_data.``-prefixed
keys.
**kwargs (dict):
Any fields passed by the client. This may be checked for a
legacy ``text_type`` field.
Returns:
set:
The keys in ``extra_data`` that were set based on the request.
"""
modified_fields = set()
text_type_field = self._get_text_type_field_name(text_field)
extra_data = obj.extra_data
extra_data_text_field = 'extra_data.' + text_field
extra_data_text_type_field = 'extra_data.' + text_type_field
if extra_data_text_field in extra_fields:
# This field was updated in this request. Make sure it's
# stripped.
extra_data[text_field] = \
extra_fields[extra_data_text_field].strip()
modified_fields.add(text_field)
elif extra_data_text_type_field not in extra_fields:
# Nothing about this field has changed, so bail.
return modified_fields
old_text_type = extra_data.get(text_type_field)
text_type = extra_fields.get(extra_data_text_type_field,
kwargs.get('text_type'))
if text_type is not None:
if old_text_type is None:
old_text_type = self.DEFAULT_EXTRA_DATA_TEXT_TYPE
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if (text_type != old_text_type and
extra_data_text_field not in extra_fields):
markdown_set_field_escaped(
extra_data, text_field,
text_type == self.TEXT_TYPE_MARKDOWN)
modified_fields.add(text_field)
elif old_text_type:
# The user didn't specify a text type, but the object may be set
# for Markdown, in which case we'll need to pre-escape the text
# field.
if extra_data_text_field in extra_fields:
markdown_set_field_escaped(
extra_data, text_field,
old_text_type == self.TEXT_TYPE_MARKDOWN)
modified_fields.add(text_field)
# Ensure we have a text type set for this field. If one wasn't
# provided or set above, we'll set it to the default now.
extra_data[text_type_field] = \
text_type or self.DEFAULT_EXTRA_DATA_TEXT_TYPE
modified_fields.add(text_type_field)
return modified_fields
def set_text_fields(self, obj, text_field,
rich_text_field_name=None,
text_type_field_name=None,
text_model_field=None,
**kwargs):
"""Normalize Markdown-capable text fields that are being saved.
Args:
obj (django.db.models.Model):
The object containing Markdown-capable fields to modify.
text_field (unicode):
The key from ``kwargs`` containing the new value for the
text fields.
rich_text_field_name (unicode, optional):
The name of the boolean field on ``obj`` representing the
rich text state.
If not provided, a name will be generated based on the value
of ``text_field`` (``'rich_text'`` if ``text_field`` is
``'text'``, or :samp:`{text_field}_rich_text` otherwise).
text_type_field_name (unicode, optional):
The key from ``kwargs`` containing the text type.
If not provided, a name will be generated based on the value
of ``text_field`` (``'text_type'`` if ``text_field`` is
``'text'``, or :samp:`{text_field}_text_type` otherwise).
text_model_field (unicode, optional):
The name of the text field on ``obj``.
If not provided, ``text_field`` will be used for the value.
**kwargs (dict):
Any fields passed by the client. These should be values
corresponding to ``text_type_field_name`` and ``text_field``
in here.
This may also contain a legacy value of ``'text_type'``,
which will be used if ``text_type_field_name`` is not present.
Returns:
set:
The fields on ``obj`` that were set based on the request.
"""
modified_fields = set()
if not text_model_field:
text_model_field = text_field
if not text_type_field_name:
text_type_field_name = self._get_text_type_field_name(text_field)
if not rich_text_field_name:
rich_text_field_name = self._get_rich_text_field_name(text_field)
old_rich_text = getattr(obj, rich_text_field_name, None)
text = kwargs.get(text_field)
if text is not None:
setattr(obj, text_model_field, text.strip())
modified_fields.add(text_model_field)
legacy_text_type = kwargs.get('text_type')
text_type = kwargs.get(text_type_field_name, legacy_text_type)
if text_type is not None:
rich_text = (text_type == self.TEXT_TYPE_MARKDOWN)
setattr(obj, rich_text_field_name, rich_text)
modified_fields.add(rich_text_field_name)
# If the caller has changed the text type for this field, but
# hasn't provided a new field value, then we will need to update
# the affected field's existing contents by escaping or
# unescaping.
if rich_text != old_rich_text and text is None:
markdown_set_field_escaped(obj, text_model_field, rich_text)
modified_fields.add(text_model_field)
elif old_rich_text:
# The user didn't specify rich-text, but the object may be set
# for rich-text, in which case we'll need to pre-escape the text
# field.
if text is not None:
markdown_set_field_escaped(obj, text_model_field,
old_rich_text)
modified_fields.add(text_model_field)
return modified_fields
