Admin view + custom relationships

CHANGELOG.md

@@ -0,0 +1,12 @@
+1.6.3
+
+- Added `ENABLE_SELF_LINKS` option, default False.
+  When enabled, links will include reference to the current resource.
+
+- Made `serializer_class` optional on `DynamicRelationField`.
+  `DynamicRelationField` will attempt to infer `serializer_class` from the
+  `source` using `DynamicRouter.get_canonical_serializer`.
+
+- Added `getter`/`setter` support to `DynamicRelationField`, allowing
+  for custom relationship getting and setting. This can be useful for simplifying 
+  complex "through"-relations.

dynamic_rest/compat.py

@@ -0,0 +1,39 @@
+# flake8: noqa
+from __future__ import absolute_import
+
+from django import VERSION
+
+DJANGO110 = VERSION >= (1, 10)
+
+try:
+    from django.urls import (
+        NoReverseMatch,
+        RegexURLPattern,
+        RegexURLResolver,
+        ResolverMatch,
+        Resolver404,
+        get_script_prefix,
+        reverse,
+        reverse_lazy,
+        resolve
+    )
+except ImportError:
+    from django.core.urlresolvers import (  # Will be removed in Django 2.0
+        NoReverseMatch,
+        RegexURLPattern,
+        RegexURLResolver,
+        ResolverMatch,
+        Resolver404,
+        get_script_prefix,
+        reverse,
+        reverse_lazy,
+        resolve
+    )
+
+
+def set_many(instance, field, value):
+    if DJANGO110:
+        field = getattr(instance, field)
+        field.set(value)
+    else:
+        setattr(instance, field, value)

dynamic_rest/conf.py

@@ -2,6 +2,8 @@
 from django.test.signals import setting_changed
 
 DYNAMIC_REST = {
+    'ADMIN_TEMPLATE': 'dynamic_rest/admin.html',
+
     # DEBUG: enable/disable internal debugging
     'DEBUG': False,
 
@@ -12,6 +14,9 @@
     # ENABLE_LINKS: enable/disable relationship links
     'ENABLE_LINKS': True,
 
+    # ENABLE_SELF_LINKS: enable/disable links to self
+    'ENABLE_SELF_LINKS': False,
+
     # ENABLE_SERIALIZER_CACHE: enable/disable caching of related serializers
     'ENABLE_SERIALIZER_CACHE': True,
 
@@ -32,6 +37,14 @@
     # Can be overriden at the viewset level.
     'MAX_PAGE_SIZE': None,
 
+    # LOGIN_URL: the login URL, defaults to reverse-URL lookup
+    'LOGIN_URL': '',
+
+    # LOGOUT_URL: the logout URL, defaults to reverse-URL lookup
+    'LOGOUT_URL': '',
+
+    'LOGIN_TEMPLATE': 'dynamic_rest/login.html',
+
     # PAGE_QUERY_PARAM: global setting for the pagination query parameter.
     # Can be overriden at the viewset level.
     'PAGE_QUERY_PARAM': 'page',
@@ -52,6 +65,14 @@
     # through the dynamic router.  If a resource doesn't have a canonical
     # path registered, links will default back to being resource-relative urls
     'ENABLE_HOST_RELATIVE_LINKS': True,
+
+    # Whether or not the root API view requires authentication
+    'ROOT_REQUIRES_AUTHENTICATION': False,
+
+    # Name of the root API view
+    'ROOT_VIEW_NAME': 'API',
+
+    'ROOT_DESCRIPTION': '',
 }
 
 

dynamic_rest/fields/__init__.py

@@ -1,2 +1,10 @@
-from dynamic_rest.fields.fields import *  # noqa
-from dynamic_rest.fields.generic import *  # noqa
+# flake8: noqa
+from .base import (
+    DynamicField,
+    CountField,
+    DynamicComputedField
+)
+from .relation import DynamicRelationField
+from .generic import DynamicGenericRelationField
+from .choices import DynamicChoicesField
+from .model import *

dynamic_rest/fields/base.py

@@ -0,0 +1,135 @@
+from rest_framework import fields
+from dynamic_rest.meta import get_model_field
+
+
+class DynamicField(fields.Field):
+
+    """
+    Generic field base to capture additional custom field attributes.
+    """
+
+    def __init__(
+        self,
+        requires=None,
+        deferred=None,
+        field_type=None,
+        immutable=False,
+        get_class=None,
+        **kwargs
+    ):
+        """
+        Arguments:
+            deferred: Whether or not this field is deferred.
+                Deferred fields are not included in the response,
+                unless explicitly requested.
+            field_type: Field data type, if not inferrable from model.
+            requires: List of fields that this field depends on.
+                Processed by the view layer during queryset build time.
+        """
+        self.requires = requires
+        self.deferred = deferred
+        self.field_type = field_type
+        self.immutable = immutable
+        self.kwargs = kwargs
+        super(DynamicField, self).__init__(**kwargs)
+
+    def to_representation(self, value):
+        return value
+
+    def to_internal_value(self, value):
+        return value
+
+    @property
+    def parent_model(self):
+        if not hasattr(self, '_parent_model'):
+            self._parent_model = getattr(self.parent.Meta, 'model', None)
+        return self._parent_model
+
+    @property
+    def model_field(self):
+        if not hasattr(self, '_model_field'):
+            try:
+                self._model_field = get_model_field(
+                    self.parent_model, self.source
+                )
+            except:
+                self._model_field = None
+        return self._model_field
+
+
+class DynamicComputedField(DynamicField):
+    def __init__(self, *args, **kwargs):
+        kwargs['read_only'] = True
+        super(DynamicComputedField, self).__init__(*args, **kwargs)
+
+
+class CountField(DynamicComputedField):
+
+    """
+    Computed field that counts the number of elements in another field.
+    """
+
+    def __init__(self, serializer_source, *args, **kwargs):
+        """
+        Arguments:
+            serializer_source: A serializer field.
+            unique: Whether or not to perform a count of distinct elements.
+        """
+        self.field_type = int
+        # Use `serializer_source`, which indicates a field at the API level,
+        # instead of `source`, which indicates a field at the model level.
+        self.serializer_source = serializer_source
+        # Set `source` to an empty value rather than the field name to avoid
+        # an attempt to look up this field.
+        kwargs['source'] = ''
+        self.unique = kwargs.pop('unique', True)
+        return super(CountField, self).__init__(*args, **kwargs)
+
+    def get_attribute(self, obj):
+        source = self.serializer_source
+        if source not in self.parent.fields:
+            return None
+        value = self.parent.fields[source].get_attribute(obj)
+        data = self.parent.fields[source].to_representation(value)
+
+        # How to count None is undefined... let the consumer decide.
+        if data is None:
+            return None
+
+        # Check data type. Technically len() works on dicts, strings, but
+        # since this is a "count" field, we'll limit to list, set, tuple.
+        if not isinstance(data, (list, set, tuple)):
+            raise TypeError(
+                "'%s' is %s. Must be list, set or tuple to be countable." % (
+                    source, type(data)
+                )
+            )
+
+        if self.unique:
+            # Try to create unique set. This may fail if `data` contains
+            # non-hashable elements (like dicts).
+            try:
+                data = set(data)
+            except TypeError:
+                pass
+
+        return len(data)
+
+
+class WithRelationalFieldMixin(object):
+    """Mostly code shared by DynamicRelationField and
+        DynamicGenericRelationField.
+    """
+
+    def _get_request_fields_from_parent(self):
+        """Get request fields from the parent serializer."""
+        if not self.parent:
+            return None
+
+        if not getattr(self.parent, 'request_fields'):
+            return None
+
+        if not isinstance(self.parent.request_fields, dict):
+            return None
+
+        return self.parent.request_fields.get(self.field_name)

dynamic_rest/fields/choices.py

@@ -0,0 +1,22 @@
+from .base import DynamicField
+from rest_framework.serializers import ChoiceField
+from dynamic_rest.utils import DynamicValue
+
+
+class DynamicChoicesField(
+    ChoiceField,
+    DynamicField
+):
+    def __init__(self, *args, **kwargs):
+        self.class_choices = kwargs.pop(
+            'class_choices', {}
+        )
+        super(DynamicChoicesField, self).__init__(*args, **kwargs)
+
+    def to_representation(self, value):
+        return DynamicValue(
+            super(DynamicChoicesField, self).to_representation(value),
+            self.choices.get(value, value),
+            classes=self.class_choices.get(value, None),
+            display_name=True
+        )

dynamic_rest/fields/generic.py

@@ -2,9 +2,7 @@
 
 from rest_framework.exceptions import ValidationError
 
-from dynamic_rest.fields.common import WithRelationalFieldMixin
-from dynamic_rest.fields.fields import DynamicField
-from dynamic_rest.routers import DynamicRouter
+from .base import WithRelationalFieldMixin, DynamicField
 from dynamic_rest.tagged import TaggedDict
 
 
@@ -64,6 +62,7 @@ def get_pk_object(self, type_key, id_value):
         }
 
     def get_serializer_class_for_instance(self, instance):
+        from dynamic_rest.routers import DynamicRouter
         return DynamicRouter.get_canonical_serializer(
             resource_key=None,
             instance=instance
@@ -118,6 +117,7 @@ def to_internal_value(self, data):
         model_name = data.get('type', None)
         model_id = data.get('id', None)
         if model_name and model_id:
+            from dynamic_rest.routers import DynamicRouter
             serializer_class = DynamicRouter.get_canonical_serializer(
                 resource_key=None,
                 resource_name=model_name

dynamic_rest/fields/model.py

@@ -0,0 +1,45 @@
+import sys
+from .base import DynamicField
+from rest_framework import serializers
+
+for cls_name in (
+    'BooleanField',
+    'CharField',
+    'DateField',
+    'DateTimeField',
+    'DecimalField',
+    'DictField',
+    'EmailField',
+    'FileField',
+    'FilePathField',
+    'FloatField',
+    'HiddenField',
+    'IPAddressField',
+    'ImageField',
+    'IntegerField',
+    'JSONField',
+    'ListField',
+    'RegexField',
+    'SlugField',
+    'TimeField',
+    'URLField',
+    'UUIDField',
+):
+    cls = getattr(serializers, cls_name, None)
+    if not cls:
+        continue
+
+    new_name = 'Dynamic%s' % cls_name
+    new_cls = type(
+        new_name,
+        (cls, DynamicField),
+        {}
+    )
+    setattr(sys.modules[__name__], new_name, new_cls)
+
+
+class DynamicMethodField(
+    serializers.SerializerMethodField,
+    DynamicField
+):
+    pass