[Update] 暂存

apps/authorization/admin.py

+from django.contrib import admin
+
+# Register your models here.

apps/authorization/apps.py

+from django.apps import AppConfig
+
+
+class AuthorizationConfig(AppConfig):
+    name = 'authorization'

apps/authorization/models.py

+from django.db import models
+from django.utils.translation import ugettext_lazy as _
+
+from common.fields import JsonListTextField
+
+
+class BaseRole(models.Model):
+    name = models.SlugField(max_length=128, unique=True, allow_unicode=True)
+    rules = models.ManyToManyField('Rule')
+    date_created = models.DateTimeField(auto_now_add=True)
+    created_by = models.CharField(max_length=128, blank=True, default='')
+
+    class Meta:
+        abstract = True
+
+
+class Role(BaseRole):
+    org_id = models.CharField(max_length=36, blank=True, default='',
+                              verbose_name=_("Organization"), db_index=True)
+
+
+class ClusterRole(BaseRole):
+    non_resource_urls = JsonListTextField()
+
+
+class Rule(models.Model):
+    VERBOSE_CHOICES = [
+        ('list', 'List'),
+        ('retrieve', 'Retrieve'),
+        ('create', 'Create'),
+        ('update', 'Update'),
+        ('patch', 'PartialUpdate'),
+        ('delete', 'Delete'),
+    ]
+    api_groups = JsonListTextField()
+    resources = JsonListTextField()
+    resourcesIDs = JsonListTextField()
+    verbs = JsonListTextField()
+
+
+class BaseRoleBinding(models.Model):
+
+    class Meta:
+        abstract = True
+
+
+class RoleBinding(BaseRoleBinding):
+    pass
+
+
+class ClusterRoleBinding(BaseRoleBinding):
+    pass

apps/authorization/tests.py

+from django.test import TestCase
+
+# Create your tests here.

apps/authorization/views.py

+from django.shortcuts import render
+
+# Create your views here.

apps/common/fields/__init__.py

+# -*- coding: utf-8 -*-
+#
+
+from .form import *
+from .model import *
+from .serializer import *

apps/common/fields.py → apps/common/fields/form.py

@@ -2,16 +2,19 @@
 #
 import json
 
-from django.db import models
 from django import forms
 from django.utils import six
 from django.core.exceptions import ValidationError
 from django.utils.translation import ugettext as _
-from rest_framework import serializers
-from .utils import get_signer
+from ..utils import get_signer
 
 signer = get_signer()
 
+__all__ = [
+    'FormDictField', 'FormEncryptCharField', 'FormEncryptDictField',
+    'FormEncryptMixin',
+]
+
 
 class FormDictField(forms.Field):
     widget = forms.Textarea
@@ -44,38 +47,6 @@ class FormDictField(forms.Field):
         return self.to_python(initial) != self.to_python(data)
 
 
-class StringIDField(serializers.Field):
-    def to_representation(self, value):
-        return {"pk": value.pk, "name": value.__str__()}
-
-
-class StringManyToManyField(serializers.RelatedField):
-    def to_representation(self, value):
-        return value.__str__()
-
-
-class EncryptMixin:
-    def from_db_value(self, value, expression, connection, context):
-        if value is not None:
-            return signer.unsign(value)
-        return super().from_db_value(self, value, expression, connection, context)
-
-    def get_prep_value(self, value):
-        if value is None:
-            return value
-        return signer.sign(value)
-
-
-class EncryptTextField(EncryptMixin, models.TextField):
-    description = _("Encrypt field using Secret Key")
-
-
-class EncryptCharField(EncryptMixin, models.CharField):
-    def __init__(self, *args, **kwargs):
-        kwargs['max_length'] = 2048
-        super().__init__(*args, **kwargs)
-
-
 class FormEncryptMixin:
     pass
 
@@ -88,19 +59,5 @@ class FormEncryptDictField(FormEncryptMixin, FormDictField):
     pass
 
 
-class ChoiceDisplayField(serializers.ChoiceField):
-    def __init__(self, *args, **kwargs):
-        super(ChoiceDisplayField, self).__init__(*args, **kwargs)
-        self.choice_strings_to_display = {
-            six.text_type(key): value for key, value in self.choices.items()
-        }
 
-    def to_representation(self, value):
-        if value is None:
-            return value
-        return {
-            'value': self.choice_strings_to_values.get(six.text_type(value),
-                                                       value),
-            'display': self.choice_strings_to_display.get(six.text_type(value),
-                                                          value),
-        }
+

apps/common/fields/model.py

+# -*- coding: utf-8 -*-
+#
+import json
+from django.db import models
+from django.utils.translation import ugettext_lazy as _
+
+from ..utils import get_signer
+
+
+__all__ = [
+    'JsonMixin', 'JsonDictMixin', 'JsonListMix', 'JsonTypeMixin',
+    'JsonCharField', 'JsonTextField', 'JsonListCharField', 'JsonListTextField',
+    'JsonDictCharField', 'JsonDictTextField', 'EncryptCharField',
+    'EncryptTextField', 'EncryptMixin',
+]
+signer = get_signer()
+
+
+class JsonMixin:
+    tp = None
+
+    @staticmethod
+    def json_decode(data):
+        try:
+            return json.loads(data)
+        except (TypeError, json.JSONDecodeError):
+            return None
+
+    @staticmethod
+    def json_encode(data):
+        return json.dumps(data)
+
+    def from_db_value(self, value, expression, connection, context):
+        if value is None:
+            return value
+        return self.json_decode(value)
+
+    def to_python(self, value):
+        if value is None:
+            return value
+
+        if not isinstance(value, str) or not value.startswith('"'):
+            return value
+        else:
+            return self.json_decode(value)
+
+    def get_prep_value(self, value):
+        if value is None:
+            return value
+        return self.json_encode(value)
+
+
+class JsonTypeMixin(JsonMixin):
+    tp = dict
+
+    def from_db_value(self, value, expression, connection, context):
+        value = super().from_db_value(value, expression, connection, context)
+        if not isinstance(value, self.tp):
+            value = self.tp()
+        return value
+
+    def to_python(self, value):
+        data = super().to_python(value)
+        if not isinstance(data, self.tp):
+            data = self.tp()
+        return data
+
+    def get_prep_value(self, value):
+        if not isinstance(value, self.tp):
+            value = self.tp()
+        return self.json_encode(value)
+
+
+class JsonDictMixin(JsonTypeMixin):
+    tp = dict
+
+
+class JsonDictCharField(JsonDictMixin, models.CharField):
+    description = _("Marshal dict data to char field")
+
+
+class JsonDictTextField(JsonDictMixin, models.TextField):
+    description = _("Marshal dict data to text field")
+
+
+class JsonListMix(JsonTypeMixin):
+    tp = list
+
+
+class JsonListCharField(JsonListMix, models.CharField):
+    description = _("Marshal list data to char field")
+
+
+class JsonListTextField(JsonListMix, models.TextField):
+    description = _("Marshal list data to text field")
+
+
+class EncryptMixin:
+    def from_db_value(self, value, expression, connection, context):
+        if value is not None:
+            return signer.unsign(value)
+        return None
+
+    def get_prep_value(self, value):
+        if value is None:
+            return value
+        return signer.sign(value)
+
+
+class EncryptTextField(EncryptMixin, models.TextField):
+    description = _("Encrypt field using Secret Key")
+
+
+class EncryptCharField(EncryptMixin, models.CharField):
+    def __init__(self, *args, **kwargs):
+        kwargs['max_length'] = 2048
+        super().__init__(*args, **kwargs)
+
+
+class JsonCharField(JsonMixin, models.CharField):
+    description = _("Marshal data to char field")
+
+
+class JsonTextField(JsonMixin, models.TextField):
+    description = _("Marshal data to text field")

apps/common/fields/serializer.py

+# -*- coding: utf-8 -*-
+#
+
+from rest_framework import serializers
+from django.utils import six
+
+
+__all__ = ['StringIDField', 'StringManyToManyField', 'ChoiceDisplayField']
+
+
+class StringIDField(serializers.Field):
+    def to_representation(self, value):
+        return {"pk": value.pk, "name": value.__str__()}
+
+
+class StringManyToManyField(serializers.RelatedField):
+    def to_representation(self, value):
+        return value.__str__()
+
+
+class ChoiceDisplayField(serializers.ChoiceField):
+    def __init__(self, *args, **kwargs):
+        super(ChoiceDisplayField, self).__init__(*args, **kwargs)
+        self.choice_strings_to_display = {
+            six.text_type(key): value for key, value in self.choices.items()
+        }
+
+    def to_representation(self, value):
+        if value is None:
+            return value
+        return {
+            'value': self.choice_strings_to_values.get(six.text_type(value), value),
+            'display': self.choice_strings_to_display.get(six.text_type(value), value),
+        }
+
+
+class DictField(serializers.DictField):
+    def to_representation(self, value):
+        if not value or not isinstance(value, dict):
+            value = {}
+        return super().to_representation(value)