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_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