def __get_serializer_fields__(self, callback): """ Gets serializer fields if set in the view. Returns dictionaries with field properties (read-only, default, min and max length) """ data = [] if not hasattr(callback, 'get_serializer_class'): return data factory = RequestFactory() request = factory.get('') request.user = get_user_model()() if hasattr(callback, '__call__'): callback = callback() callback.request = request serializer = callback.get_serializer_class() try: fields = serializer().get_fields() except: return for name, field in fields.items(): field_data = {} field_data['type'] = self.__camelcase_to_spaces(field.__class__.__name__) for key in ('read_only', 'default', 'max_length', 'min_length'): if hasattr(field, key): field_data[key] = getattr(field, key) data.append({name: field_data}) return data
def _get_flagged_field_names(self, fields, attr, meta_attr=None): if meta_attr is None: meta_attr = '%s_fields' % attr meta_list = set(getattr(self.Meta, meta_attr, [])) return { name for name, field in iter(fields.items()) if getattr(field, attr, None) is True or name in meta_list }
def get_field(self, field_name): # it might be deferred fields = self.get_all_fields() if field_name == 'pk': meta = self.get_meta() if hasattr(meta, '_pk'): return meta._pk field = None model = self.get_model() primary_key = getattr(meta, 'primary_key', None) if primary_key: field = fields.get(primary_key) else: for n, f in fields.items(): # try to use model fields try: if getattr(field, 'primary_key', False): field = f break model_field = get_model_field(model, f.source or n) if model_field.primary_key: field = f break except: pass if not field: # fall back to a field called ID if 'id' in fields: field = fields['id'] if field: meta._pk = field return field else: if field_name in fields: field = fields[field_name] return field raise ValidationError( {field_name: '"%s" is not an API field' % field_name})
def __get_serializer_fields__(self, callback): """ Gets serializer fields if set in the view. Returns dictionaries with field properties (read-only, default, min and max length) """ data = [] if not hasattr(callback, 'get_serializer_class'): return data factory = RequestFactory() request = factory.get('') request.user = get_user_model()() if hasattr(callback, '__call__'): callback = callback() callback.request = request serializer = callback.get_serializer_class() try: fields = serializer().get_fields() except: return for name, field in fields.items(): field_data = {} field_data['type'] = self.__camelcase_to_spaces( field.__class__.__name__) for key in ('read_only', 'default', 'max_length', 'min_length'): if hasattr(field, key): field_data[key] = getattr(field, key) data.append({name: field_data}) return data
def extract_serializer_fields(serializer, write=False): if serializer is None: return [] if hasattr(serializer, '__call__'): fields = serializer().get_fields() else: fields = serializer.get_fields() serializer_data = [] for name, field in fields.items(): data_type, data_format = get_data_type(field) or ('string', 'string') if data_type == 'hidden': continue data_format = get_normalized_data_format(data_type, data_format) field_data = { 'minimum': None, 'maximum': None, 'enum': None, 'items': None, '$ref': None, 'name': name, 'type': data_type, 'format': data_format, 'write_only': getattr(field, 'write_only', False), 'read_only': getattr(field, 'read_only', False), 'required': getattr(field, 'required', False), 'default': get_default_value(field), } help_text = getattr(field, 'help_text', '') field_data['description'] = help_text.strip() if help_text else '' # guess format # data_format = 'string' # if data_type in BaseMethodIntrospector.PRIMITIVES: # data_format = BaseMethodIntrospector.PRIMITIVES.get(data_type)[0] # Min/Max values max_value = getattr(field, 'max_value', None) min_value = getattr(field, 'min_value', None) if data_type == 'integer': field_data['minimum'] = min_value field_data['maximum'] = max_value # ENUM options if data_type in BaseMethodIntrospector.ENUMS: if isinstance(field.choices, list): field_data['enum'] = [k for k, v in field.choices] elif isinstance(field.choices, dict): field_data['enum'] = [k for k, v in field.choices.items()] # Support for complex types if rest_framework.VERSION < '3.0.0': has_many = hasattr(field, 'many') and field.many else: from rest_framework.serializers import ListSerializer, ManyRelatedField has_many = isinstance(field, (ListSerializer, ManyRelatedField)) if isinstance(field, rest_framework.serializers.BaseSerializer) or has_many: field_serializer = None if hasattr(field, 'is_documented') and not field.is_documented: field_data['type'] = 'object' elif isinstance(field, rest_framework.serializers.BaseSerializer): field_serializer = get_serializer_name(field, write) if getattr(field, 'write_only', False): field_serializer = "Write{}".format(field_serializer) if not has_many: field_data['$ref'] = '#/definitions/' + field_serializer else: data_type = 'string' if has_many: field_data['type'] = 'array' if field_serializer: field_data['items'] = {'$ref': '#/definitions/' + field_serializer} elif data_type in BaseMethodIntrospector.PRIMITIVES: field_data['items'] = {'type': data_type} elif isinstance(field, rest_framework.serializers.ListField): field_data['type'] = 'array' if not field.child: field_data['items'] = {'type': 'string'} child_type, child_format = get_data_type(field.child) or ('string', 'string') field_data['items'] = {'type': child_type} serializer_data.append(field_data) return serializer_data