def _field_to_python(self, field_name, resource_method_fields,
model_fields, m2m_fields, obj, serialization_format,
**kwargs):
if field_name == '_obj_name':
return force_text(obj)
elif field_name in resource_method_fields:
return self._method_to_python(resource_method_fields[field_name],
obj, serialization_format, **kwargs)
elif field_name in m2m_fields:
return self._m2m_field_to_python(m2m_fields[field_name], obj,
serialization_format, **kwargs)
elif field_name in model_fields:
return self._model_field_to_python(model_fields[field_name], obj,
serialization_format, **kwargs)
else:
val = getattr(obj, field_name, None) if hasattr(
obj, field_name) else None
if hasattr(val, 'all'):
return self._reverse_qs_to_python(val, field_name, obj,
serialization_format,
**kwargs)
elif isinstance(val, Model):
return self._reverse_to_python(val, field_name, obj,
serialization_format, **kwargs)
elif callable(val):
return self._method_to_python(val, obj, serialization_format,
**kwargs)
else:
method = get_class_method(obj, field_name)
return self._data_to_python(
self._value_to_raw_verbose(val, method, obj),
serialization_format,
allow_tags=method is not None
and getattr(method, 'allow_tags', False),
**kwargs)
def get_model_method_or_property_data(field_name, model, fun_kwargs):
from is_core.forms.widgets import ReadonlyWidget
class_method = get_class_method(model, field_name)
method = (getattr(model, field_name)
if hasattr(model, field_name) and not class_method
and is_callable(getattr(model, field_name)) else class_method)
if method:
if hasattr(method, 'field'):
# Generic relation
label = getattr(method.field, 'verbose_name',
pretty_name(field_name))
else:
label = getattr(method, 'short_description',
pretty_name(field_name))
try:
return ((None, label,
ReadonlyWidget) if isinstance(model, type) else
(_get_method_or_property_value(method, field_name, model,
fun_kwargs), label,
ReadonlyWidget))
except InvalidMethodArguments:
return None
elif hasattr(model, field_name):
return (getattr(model,
field_name), pretty_name(field_name), ReadonlyWidget)
else:
return None
def _get_header_label(self, model, field_name):
try:
return model._meta.get_field(field_name).verbose_name
except FieldDoesNotExist:
method = get_class_method(model, field_name)
return getattr(method, 'short_description',
pretty_name(field_name))
def _get_field_label_from_model_method(self, model, field_name):
method = get_class_method(model, field_name)
if not method:
return None
elif hasattr(method, 'short_description'):
return method.short_description
elif hasattr(method, 'field'):
# Generic relation
return getattr(method.field, 'verbose_name', pretty_name(field_name))
else:
return pretty_name(field_name)
def _get_field_label_from_model_method(self, model, field_name):
method = get_class_method(model, field_name)
if not method:
return None
elif hasattr(method, 'short_description'):
return method.short_description
elif hasattr(method, 'field'):
# Generic relation
return getattr(method.field, 'verbose_name', pretty_name(field_name))
else:
return pretty_name(field_name)
def _get_field_or_method_label(self, model, field_name):
try:
field = model._meta.get_field(field_name)
if field.auto_created and (field.one_to_many
or field.many_to_many):
return (getattr(field.field, 'reverse_verbose_name', None)
or field.related_model._meta.verbose_name_plural)
elif field.auto_created and field.one_to_one:
return (getattr(field.field, 'reverse_verbose_name', None)
or field.related_model._meta.verbose_name)
else:
return field.verbose_name
except FieldDoesNotExist:
method = get_class_method(model, field_name)
return getattr(method, 'short_description',
pretty_name(field_name))
def get_model_field_or_method_filter(full_field_term,
model,
value=None,
filter_term=None):
if not filter_term:
filter_term = full_field_term
next_filter_term = None
current_filter_term = filter_term
if '__' in filter_term:
current_filter_term, next_filter_term = filter_term.split('__', 1)
field_or_method = None
try:
field_or_method = model._meta.get_field(current_filter_term)
if (next_filter_term and next_filter_term
not in field_or_method.filter.get_suffixes()
and isinstance(field_or_method, RelatedField)):
return get_model_field_or_method_filter(
filter_term,
model._meta.get_field(current_filter_term).rel.to, value,
next_filter_term)
except FieldDoesNotExist:
field_or_method = get_class_method(model, current_filter_term)
if field_or_method:
if hasattr(field_or_method, 'filter_by'):
full_field_term = full_field_term[:-len(
current_filter_term)] + field_or_method.filter_by
return get_model_field_or_method_filter(
full_field_term, model, value, field_or_method.filter_by)
else:
raise FilterException(_('Not valid filter: %s') % full_field_term)
if (hasattr(field_or_method, 'filter')
and (not next_filter_term
or next_filter_term in field_or_method.filter.get_suffixes())
and field_or_method.filter):
return field_or_method.filter(filter_term, full_field_term,
field_or_method, value)
else:
raise FilterException(_('Not valid filter: %s') % full_field_term)
def _get_header_order_by(self, model, full_field_name):
if '__' in full_field_name:
prefix, field_name = full_field_name.rsplit('__', 1)
else:
prefix, field_name = '', full_field_name
try:
field = model._meta.get_field(field_name)
default_order_by = full_field_name
except FieldDoesNotExist:
field = get_class_method(model, field_name)
default_order_by = False
order_by = getattr(field, 'order_by', None)
if order_by:
return '__'.join(filter(None, (prefix, order_by)))
if order_by is None:
return default_order_by
return order_by
def get_instance_readonly_field_data(field_name, instance, fun_kwargs,
request):
from is_core.forms.widgets import ReadonlyWidget
if '__' in field_name:
current_field_name, next_field_name = field_name.split('__', 1)
return get_instance_readonly_field_data(
next_field_name, getattr(instance, current_field_name), fun_kwargs,
request)
else:
field = None
if isinstance(instance, Model):
try:
field = instance._meta.get_field_by_name(field_name)[0]
except (FieldDoesNotExist, AttributeError):
pass
if field:
label = field.verbose_name
humanized_value = field_humanized_value(instance, field)
display_value = field_display_value(instance, field)
if display_value is None:
value_or_callable = getattr(instance, field_name)
value = field_value(instance, field, value_or_callable,
fun_kwargs)
else:
value = display_value
if humanized_value:
value = ReadonlyValue(value, humanized_value)
widget = field_widget(instance, field)
else:
value_or_callable = getattr(instance, field_name)
value = get_callable_value_or_value(value_or_callable, fun_kwargs)
label = get_class_method(instance, field_name).short_description
widget = ReadonlyWidget
return value, label, widget
def _get_header_label(self, model, full_field_name, field_name):
field_labels = self._get_field_labels()
if field_labels and full_field_name in field_labels:
return field_labels.get(full_field_name)
else:
try:
field = model._meta.get_field(field_name)
if field.auto_created and (field.one_to_many or field.many_to_many):
return (
getattr(field.field, 'reverse_verbose_name', None) or
field.related_model._meta.verbose_name_plural
)
elif field.auto_created and field.one_to_one:
return (
getattr(field.field, 'reverse_verbose_name', None) or
field.related_model._meta.verbose_name
)
else:
return field.verbose_name
except FieldDoesNotExist:
method = get_class_method(model, field_name)
return getattr(method, 'short_description', pretty_name(field_name))
def get_cls_or_inst_method_or_property_data(field_name, cls_or_inst, fun_kwargs):
from is_core.forms.widgets import ReadonlyWidget
class_method = get_class_method(cls_or_inst, field_name)
method = (
getattr(cls_or_inst, field_name)
if hasattr(cls_or_inst, field_name) and not class_method and is_callable(getattr(cls_or_inst, field_name))
else class_method
)
if method:
label = getattr(method, 'short_description', pretty_name(field_name))
try:
return (
(None, label, ReadonlyWidget) if isinstance(cls_or_inst, type)
else (get_callable_value_or_value(method, field_name, cls_or_inst, fun_kwargs), label, ReadonlyWidget)
)
except InvalidMethodArguments:
return None
elif hasattr(cls_or_inst, field_name):
return (getattr(cls_or_inst, field_name), pretty_name(field_name), ReadonlyWidget)
else:
return None
def _field_to_python(self, field_name, resource_method_fields, model_fields, m2m_fields,
obj, serialization_format, **kwargs):
if field_name == '_obj_name':
return force_text(obj)
elif field_name in resource_method_fields:
return self._method_to_python(resource_method_fields[field_name], obj, serialization_format,
**kwargs)
elif field_name in m2m_fields:
return self._m2m_field_to_python(m2m_fields[field_name], obj, serialization_format, **kwargs)
elif field_name in model_fields:
return self._model_field_to_python(model_fields[field_name], obj, serialization_format, **kwargs)
else:
val = getattr(obj, field_name, None) if hasattr(obj, field_name) else None
if hasattr(val, 'all'):
return self._reverse_qs_to_python(val, field_name, obj, serialization_format, **kwargs)
elif isinstance(val, Model):
return self._reverse_to_python(val, field_name, obj, serialization_format, **kwargs)
elif callable(val):
return self._method_to_python(val, obj, serialization_format, **kwargs)
else:
method = get_class_method(obj, field_name)
return self._data_to_python(self._value_to_raw_verbose(val, method, obj), serialization_format,
allow_tags=method is not None and getattr(method, 'allow_tags', False),
**kwargs)
def test_should_return_class_method(self, expected_method, cls_or_inst,
method_name):
assert_equal(expected_method, get_class_method(cls_or_inst,
method_name))
def get_method_or_none(model, name):
try:
return get_class_method(model, name)
except (AttributeError, FieldDoesNotExist):
return None
def _field_to_python(self,
field_name,
resource_method_fields,
model_fields,
m2m_fields,
reverse_fields,
obj,
serialization_format,
allow_tags=False,
**kwargs):
real_field_name = self._get_real_field_name(field_name)
if real_field_name in resource_method_fields:
return self._method_to_python(
resource_method_fields[real_field_name],
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif real_field_name == '_obj_name':
return self._data_to_python(str(obj),
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif real_field_name in m2m_fields:
return self._m2m_field_to_python(m2m_fields[real_field_name],
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif real_field_name in model_fields:
return self._model_field_to_python(model_fields[real_field_name],
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif hasattr(obj.__class__, real_field_name):
if real_field_name in reverse_fields:
val = getattr(obj, real_field_name, None) if hasattr(
obj, real_field_name) else None
else:
val = getattr(obj, real_field_name)
if hasattr(val, 'all'):
return self._reverse_qs_to_python(val,
real_field_name,
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif isinstance(val, Model):
return self._reverse_to_python(val,
real_field_name,
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
elif callable(val):
return self._method_to_python(val,
obj,
serialization_format,
allow_tags=allow_tags,
**kwargs)
else:
method = get_class_method(obj, real_field_name)
return self._data_to_python(
self._value_to_raw_verbose(val, method, obj),
serialization_format,
allow_tags=allow_tags or method is not None
and getattr(method, 'allow_tags', False),
**kwargs)
else:
raise SerializerFieldNotFound(
'Field "{}" was not found'.format(field_name))
def _get_field_label_from_resource_or_model_method(self, resource_or_model, field_name):
return get_class_method(resource_or_model, field_name).short_description
def get_method_or_none(model, name):
try:
return get_class_method(model, name)
except (AttributeError, FieldDoesNotExist):
return None
def _get_field_label_from_resource_or_model_method(self, resource_or_model,
field_name):
return get_class_method(resource_or_model,
field_name).short_description
def test_should_return_class_method(self, expected_method, cls_or_inst, method_name):
assert_equal(expected_method, get_class_method(cls_or_inst, method_name))
