valar 1.0.28__py3-none-any.whl → 1.1.0__py3-none-any.whl

valar/core/meta/defaults/field_keys_default.py

@@ -1,17 +0,0 @@
-__mf_common__ = ['prop','name']
-
-meta_field_key_defaults = {
-    'data.Meta': {
-        'default': ('pick', ['entity','name']),
-    },
-    'data.MetaView': {
-        'list': ('pick', ['meta_id','code','view_name']),
-    },
-    'data.MetaField': {
-        'add': ('pick',['prop','domain','name']),
-        'tool': ('pick',[*__mf_common__,'domain','tool','refer','format']),
-        'rest': ('pick',[*__mf_common__,'not_null','allow_edit','allow_sort','allow_search','allow_download','allow_upload','allow_update']),
-        'table': ('pick',[*__mf_common__,'unit','column_width','fixed','align','edit_on_table','hide_on_table','header_color','cell_color']),
-        'form': ('pick',[*__mf_common__,'hide_on_form','hide_on_form_insert','hide_on_form_edit','hide_on_form_branch','hide_on_form_leaf','span']),
-    }
-}

valar/core/meta/defaults/field_values_default.py

@@ -1,85 +0,0 @@
-
-meta_field_value_defaults = {
-    'data.MetaFieldDomain':{
-        "__init__":{
-            "default_id":{
-                "tool":"tree"
-            },
-            "search_id":{
-                "tool":"tree"
-            },
-            "tools":{
-                "tool":"tree",
-                "refer": {
-                    "display":"code"
-                }
-            },
-            "align":{
-                "tool":"set",
-                "format":{
-                    "set": {
-                        'left':'左对齐',
-                        'right':'右对齐',
-                        'center':'剧中对齐',
-                    }
-                }
-            }
-        }
-    },
-    'data.MetaField':{
-        "__init__":{
-            "column_width":{
-                'unit':'px'
-            },
-            "fixed":{
-                "tool":"set",
-                "format":{
-                    "set": {
-                        'left':'左侧固定',
-                        'right':'右侧固定',
-                    }
-                }
-            },
-            "align":{
-                "tool":"set",
-                "format":{
-                    "set": {
-                        'left':'左对齐',
-                        'right':'右对齐',
-                        'center':'剧中对齐',
-                    }
-                }
-            },
-            "prop":{
-                'allow_edit': False,
-                'column_width': 120
-            },
-            "domain":{
-                'allow_edit': False,
-                'column_width': 120,
-            },
-            "tool":{
-                'column_width': 100,
-                'tool': 'tree',
-                'refer': {
-                    'entity':'data.MetaFieldTool',
-                    'includes': {'metafielddomain__name':'$domain'},
-                    'value': 'code'
-                }
-
-            },
-            "span":{
-                'column_width': 100,
-                "format": { "min": 0, "max": 24, "step": 1, "precision": 0, "step_strictly": True }
-            },
-            "refer":{
-                'allow_edit': False,
-                'column_width': 80
-            },
-            "format":{
-                'allow_edit': False,
-                'column_width': 80
-            },
-        }
-    }
-}

valar/core/meta/defaults/frame_defaults.py

@@ -1,136 +0,0 @@
-
-meta_field_tool = [
-    {'id': 2, 'sort': 32, 'pid': 7, 'isLeaf': True, 'name': '输入框', 'code': 'text'},
-    {'id': 3, 'sort': 17, 'pid': 0, 'isLeaf': False, 'name': 'SPEC', 'code': '特殊工具集'},
-    {'id': 5, 'sort': 22, 'pid': 0, 'isLeaf': False, 'name': 'DATE', 'code': '日期时间工具集'},
-    {'id': 6, 'sort': 21, 'pid': 8, 'isLeaf': True, 'name': '数字输入', 'code': 'number'},
-    {'id': 7, 'sort': 36, 'pid': 0, 'isLeaf': False, 'name': 'TEXT', 'code': '文本工具集'},
-    {'id': 8, 'sort': 26, 'pid': 0, 'isLeaf': False, 'name': 'NUMB', 'code': '数字工具集'},
-    {'id': 9, 'sort': 10, 'pid': 0, 'isLeaf': False, 'name': 'FILE', 'code': '文件工具集'},
-    {'id': 10, 'sort': 27, 'pid': 0, 'isLeaf': False, 'name': 'BOOL', 'code': '逻辑工具集'},
-    {'id': 11, 'sort': 31, 'pid': 0, 'isLeaf': False, 'name': 'LIST', 'code': '列表工具集'},
-    {'id': 12, 'sort': 8, 'pid': 3, 'isLeaf': True, 'name': '对象', 'code': 'object'},
-    {'id': 13, 'sort': 5, 'pid': 9, 'isLeaf': True, 'name': '图片上传', 'code': 'image'},
-    {'id': 14, 'sort': 2, 'pid': 9, 'isLeaf': True, 'name': '文件上传', 'code': 'file'},
-    {'id': 15, 'sort': 13, 'pid': 9, 'isLeaf': True, 'name': '富文本', 'code': 'rich'},
-    {'id': 17, 'sort': 11, 'pid': 10, 'isLeaf': True, 'name': '开关', 'code': 'switch'},
-    {'id': 18, 'sort': 7, 'pid': 3, 'isLeaf': True, 'name': '元数据', 'code': 'meta'},
-    {'id': 19, 'sort': 9, 'pid': 7, 'isLeaf': True, 'name': '颜色选择', 'code': 'color'},
-    {'id': 20, 'sort': 14, 'pid': 11, 'isLeaf': True, 'name': '穿梭框', 'code': 'transfer'},
-    {'id': 21, 'sort': 16, 'pid': 7, 'isLeaf': True, 'name': '自动填充', 'code': 'auto'},
-    {'id': 22, 'sort': 35, 'pid': 5, 'isLeaf': True, 'name': '日期选择', 'code': 'date'},
-    {'id': 23, 'sort': 12, 'pid': 10, 'isLeaf': True, 'name': '逻辑选择', 'code': 'boolean'},
-    {'id': 24, 'sort': 24, 'pid': 11, 'isLeaf': True, 'name': '列表选择', 'code': 'select'},
-    {'id': 25, 'sort': 15, 'pid': 11, 'isLeaf': True, 'name': '树形选择', 'code': 'tree'},
-    {'id': 26, 'sort': 23, 'pid': 11, 'isLeaf': True, 'name': '及联选择', 'code': 'cascade'},
-    {'id': 28, 'sort': 25, 'pid': 7, 'isLeaf': True, 'name': '图标', 'code': 'icon'},
-    {'id': 31, 'sort': 6, 'pid': 0, 'isLeaf': True, 'name': '无', 'code': 'none'},
-    {'id': 32, 'sort': 30, 'pid': 7, 'isLeaf': True, 'name': '文本框', 'code': 'textarea'},
-    {'id': 33, 'sort': 18, 'pid': 36, 'isLeaf': True, 'name': '时间区间', 'code': 'timerange'},
-    {'id': 35, 'sort': 33, 'pid': 5, 'isLeaf': True, 'name': '时间选择', 'code': 'time'},
-    {'id': 36, 'sort': 20, 'pid': 0, 'isLeaf': False, 'name': 'RANGE', 'code': '区间工具集'},
-    {'id': 37, 'sort': 38, 'pid': 36, 'isLeaf': True, 'name': '日期区间', 'code': 'daterange'},
-    {'id': 39, 'sort': 3, 'pid': 36, 'isLeaf': True, 'name': '多日期', 'code': 'dates'},
-    {'id': 54, 'sort': 54, 'pid': 7, 'isLeaf': True, 'name': '集合', 'code': 'set'}
-]
-
-meta_field_domain = [
-    {
-        'name': 'CharField',
-        'default_id': 'text', 'align': 'left',
-        'tools': [
-            'text', 'number', 'meta', 'color', 'auto', 'date', 'select', 'tree', 'cascade', 'icon',
-            'textarea', 'timerange', 'daterange', 'dates', 'set'
-        ]
-     },
-    {
-        'name': 'TextField',
-        'default_id': 'textarea', 'align': 'left',
-        'tools': ['text', 'textarea']
-    },
-    {
-        'name': 'BooleanField',
-        'default_id': 'switch', 'align': 'center',
-        'tools': ['switch', 'boolean']
-    },
-    {
-        'name': 'IntegerField',
-        'default_id': 'number', 'align': 'right',
-        'tools': ['number']
-    },
-    {
-        'name': 'FloatField',
-        'default_id': 'number', 'align': 'right',
-        'tools': ['number']
-    },
-    {
-        'name': 'ForeignKey',
-        'default_id': 'select', 'align': 'left',
-        'tools': ['select', 'tree', 'cascade']
-    },
-    {
-        'name': 'ManyToOneRel',
-        'default_id': 'select', 'align': 'center',
-        'tools': ['transfer', 'select', 'tree', 'cascade']
-    },
-    {
-        'name': 'ManyToManyField',
-        'default_id': 'select', 'align': 'center',
-        'tools': [ 'transfer', 'select', 'tree', 'cascade']
-    },
-    {
-        'name': 'ManyToManyRel',
-        'default_id': 'select', 'align': 'center',
-        'tools': ['transfer', 'select', 'tree', 'cascade']
-    },
-    {
-        'name': 'OneToOneRel',
-        'default_id': 'none', 'align': 'left',
-        'tools': []
-    },
-    {
-        'name': 'OneToOneField',
-        'default_id': 'none', 'align': 'left',
-        'tools': []
-    },
-    {
-        'name': 'DateField',
-        'default_id': 'date', 'align': 'center',
-        'tools': ['date']
-    },
-    {
-        'name': 'TimeField',
-        'default_id': 'time', 'align': 'center',
-        'tools': ['time']
-    },
-    {
-        'name': 'DateTimeField',
-        'default_id': 'date', 'align': 'center',
-        'tools': ['date']
-    },
-    {
-        'name': 'JSONField',
-        'default_id': 'object', 'align': 'center',
-        'tools': ['object']
-    },
-    {
-        'name': 'FileField',
-        'default_id': 'file', 'align': 'center',
-        'tools': ['image', 'file', 'rich']
-    },
-    {
-        'name': 'BigAutoField',
-        'default_id': 'none', 'align': 'right',
-        'tools': []
-    },
-    {
-        'name': 'UUIDField',
-        'default_id': 'none', 'align': 'left',
-        'tools': []
-    },
-    {
-        'name': 'Custom',
-        'default_id': 'none', 'align': 'left',
-        'tools': []
-    },
-]

valar/core/meta/defaults/view_defaults.py

@@ -1,7 +0,0 @@
-meta_view_default_values = {
-    'data.MetaView': {
-        '__init__': {
-           'allow_insert': False
-        }
-    }
-}

valar/core/meta/field_orm.py

@@ -1,144 +0,0 @@
-from deepmerge import always_merger
-from django.db.models import ManyToOneRel, ForeignKey, ManyToManyRel, ManyToManyField,OneToOneField,OneToOneRel
-from django.db.models import IntegerField, BooleanField, FloatField,TextField, CharField
-from django.db.models import FileField, JSONField
-from django.db.models import DateTimeField, TimeField, DateField
-
-
-
-class OrmField:
-
-    def __init__(self, entity, field, is_tree):
-        self.entity = entity
-        self.model_field = field
-        self.is_tree = is_tree
-        self.not_null = not field.null
-        self.clazz = type(field)
-        self.multiple = self.clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel]
-
-        self.prop = self.__prop__()
-        self.domain = self.__domain__()
-        self.model = self.__model__()
-        self.label = self.__label__()
-        self.column_width = self.__column_width__()
-        self.refer = self.__refer__()
-        self.align = self.___align__()
-        self.format = self.__formating__()
-
-
-
-
-
-    def json(self):
-        _field = {
-            "prop": self.prop,
-            "label": self.label,
-            "name": self.label,
-            "domain": self.domain,
-            "refer": self.refer,
-            "format": self.format,
-            "not_null": self.not_null,
-            "align": self.align,
-            "column_width": self.column_width,
-        }
-        if self.is_tree:
-            if self.prop in ['pid', 'isLeaf']:
-                _field['hide_on_table'] = True
-                _field['hide_on_form'] = True
-                _field['hide_on_form_branch'] = True
-                _field['hide_on_form_leaf'] = True
-            elif self.prop in ['icon']:
-                _field['tool'] = 'icon'
-        return _field
-
-
-    def __column_width__(self):
-        if self.clazz in [BooleanField, FileField, JSONField]:
-            return 100
-        elif self.clazz in [DateField, DateTimeField, TimeField]:
-            return 120
-        return 0
-
-    def __label__(self):
-        return self.model._meta.verbose_name \
-            if self.clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel, OneToOneRel, OneToOneField] \
-            else self.model_field.verbose_name
-
-
-    def __model__(self):
-        return self.model_field.related_model \
-            if self.clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel, OneToOneRel, OneToOneField, ForeignKey] \
-            else None
-
-
-    def __domain__(self):
-        return self.clazz.__name__ \
-            if self.clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel ,OneToOneRel, OneToOneField] \
-            else self.model_field.get_internal_type()
-
-    def __prop__(self):
-        return self.model_field.name + "_id" \
-            if self.clazz in [ForeignKey,OneToOneRel, OneToOneField] \
-            else self.model_field.name
-
-
-    def ___align__(self):
-        if self.clazz in [FloatField, IntegerField]:
-            return 'right'
-        elif self.clazz in [BooleanField, FileField, JSONField, DateField, DateTimeField, TimeField]:
-            return 'center'
-        return 'left'
-
-    def __refer__(self):
-        refer = {
-            "entity": None,
-            "value": "name", "label": 'name', "display": "id",
-            "multiple": self.multiple, "strict": False, "remote": False,
-            "includes": {}, "excludes": {},
-            "root": 0, "isTree": self.is_tree
-        }
-        if self.model:
-            module, name = self.model.__module__, self.model.__name__
-            refer['entity'] = '%s.%s' % (module.replace('.models', '').split('.')[-1], name)
-        return refer
-
-    def __formating__(self):
-        _format = {
-            # 文本
-            "maxlength": 0,
-            "type": 'text',
-
-            # 数值
-            "min": None,
-            "max": None,
-            "step": 1,
-            "precision": None,
-            "step_strictly": False,
-
-            # 日期
-            "frequency": "date",
-
-            # 文件
-            "maximum": 5,
-            "accept": [],
-            "width": 800,
-            "height": 0,
-            "file_name_field":None,
-            "locked": False,
-
-            #集合
-            "set": {}
-        }
-        if self.clazz == CharField:
-            _format['maxlength'] = self.model_field.max_length
-        if self.clazz == TextField:
-            _format['type'] = "textarea"
-        elif self.clazz == DateTimeField:
-            _format['frequency'] = "datetime"
-        elif self.clazz == IntegerField:
-            _format['precision'] = 0
-            _format['step_strictly'] = True
-        return _format
-
-
-

valar/core/meta/init_meta_frame.py

@@ -1,30 +0,0 @@
-import copy
-
-from .defaults.frame_defaults import meta_field_tool, meta_field_domain
-
-from ...data.models import MetaFieldDomain, MetaFieldTool
-
-
-def init_meta_frame():
-    from ..dao.dao_orm import OrmDao
-    tool_dao = OrmDao('data.MetaFieldTool')
-    domain_dao = OrmDao('data.MetaFieldDomain')
-    mapping = {}
-    for item in meta_field_tool:
-        _id, code = item['id'], item['code']
-        item.update({"saved": True})
-        if item['isLeaf']:
-            mapping[code] = _id
-        tool_dao.save_one(item)
-
-    for row in meta_field_domain:
-        default_id, tools = row['default_id'], row['tools']
-        print(mapping[default_id])
-        _row = copy.deepcopy(row)
-        _row.update({
-            'default_id': mapping[default_id],
-            'tools': [mapping[tool] for tool in tools],
-            "saved": True
-        })
-        domain_dao.save_one(_row)
-    return MetaFieldDomain.objects.all()

valar/core/meta/meta_orm.py

@@ -1,69 +0,0 @@
-from deepmerge import always_merger
-
-from .defaults.view_defaults import meta_view_default_values
-from ...core.dao.dao_orm import OrmDao
-from ...data.models import MetaView, Meta
-
-
-class OrmMeta:
-
-    def __init__(self, entity, code):
-        self.entity = entity
-        self.dao = OrmDao(entity)
-        self.code = code or 'default'
-
-
-        # load_meta
-        meta_dao = OrmDao('data.Meta')
-        _meta = {"entity": entity}
-        meta: Meta = meta_dao.search(_meta).first()
-        if meta is None:
-            _meta.update({"name": self.dao.model.name, 'saved': True})
-            meta = meta_dao.save_one(_meta)
-        self.meta = meta
-
-
-        # load_view
-        view_dao = OrmDao('data.MetaView')
-        _view = {"code": self.code, "meta_id": meta.id}
-        view: MetaView = view_dao.search(_view).first()
-        if view is None:
-            _view.update({"name": self.code.upper(), "saved": True})
-            view = view_dao.save_one(_view)
-            self.__init_view__(view)
-        self.view = view
-
-        # load_fields
-        if view.metafield_set.count() == 0:
-            field_dao = OrmDao('data.MetaField')
-            _fields = self.dao.model.initial_fields(code)
-            for _field in _fields:
-                _field.update({'view_id':view.id, "saved": True })
-                field_dao.save_one(_field)
-
-
-    def get_view(self):
-        _view = self.view.json()
-        meta = self.meta.json()
-        name, entity = meta['name'], meta['entity']
-        fields = self.view.metafield_set.all().order_by('-sort')
-        _fields = {field.prop: field.json(entity=entity, code=self.code, db='orm') for field in fields}
-        _view.update({
-            '$db': 'orm',
-            '$entity': entity,
-            '$code': self.code,
-            '$meta_name': name,
-            '$is_tree': self.dao.model.is_tree,
-            '$fields': _fields
-        })
-        return _view
-
-    def __init_view__(self, view: MetaView):
-        default_view = meta_view_default_values.get(self.entity, {})
-        default_values = default_view.get('__init__',{})
-        code_values = default_view.get(self.code, {})
-        values = always_merger.merge(default_values, code_values)
-        if len(values) > 0:
-            for key, value in values.items():
-                setattr(view, key, value)
-            view.save()

valar/core/middleware.py

@@ -1,20 +0,0 @@
-from django.http import HttpRequest
-from django.utils.deprecation import MiddlewareMixin
-from response import ValarResponse
-
-
-class Middleware(MiddlewareMixin):
-    @staticmethod
-    def process_response(request: HttpRequest, response: ValarResponse):
-        headers = response.headers
-        if type(response)==ValarResponse:
-            message, code = response.message, response.code
-            headers['valar_message'] = message
-            headers['valar_code'] = code
-
-        keys = ['client','auth','uid']
-        for key in keys:
-            value = request.headers.get(key)
-            if value:
-                headers[key] = value
-        return response

valar/core/response.py

@@ -1,7 +0,0 @@
-from django.http import JsonResponse
-
-class ValarResponse(JsonResponse):
-    def __init__(self, data, message='', code='info'):
-        self.message = message
-        self.code = code
-        super(ValarResponse, self).__init__(data, safe=False)

valar/core/singleton_meta.py

@@ -1,6 +0,0 @@
-class SingletonMeta(type):
-    _instances = {}
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
-        return cls._instances[cls]

valar/data/urls.py

@@ -1,18 +0,0 @@
-from django.urls import path
-
-from ..channels.views import handel_channel
-from .views.rest import save_many,delete_many,save_one,delete_one,find_one,find,update,table, tree, meta_view
-
-urlpatterns = [
-    path('socket/<str:handler>', handel_channel),
-    path('save_many', save_many),
-    path('delete_many', delete_many),
-    path('<str:db>/<str:entity>/save_one', save_one),
-    path('<str:db>/<str:entity>/delete_one', delete_one),
-    path('<str:db>/<str:entity>/find_one', find_one),
-    path('<str:db>/<str:entity>/find', find),
-    path('<str:db>/<str:entity>/update', update),
-    path('<str:db>/<str:entity>/table', table),
-    path('<str:db>/<str:entity>/tree', tree),
-    path('<str:db>/<str:entity>/meta_view', meta_view),
-]

valar/data/views/handler.py

@@ -1,41 +0,0 @@
-from ...channels.sender import ValarSocketSender
-from ...core.counter import Counter
-from ...core.dao.dao_base import Dao
-from ...core.dao.dao_mon import MonDao
-from ...core.dao.dao_orm import OrmDao
-
-
-
-
-def save_many_handler(sender: ValarSocketSender):
-    data = sender.data
-    entity, array, db = data.get("entity"), data.get("array",[]), data.get("db")
-    dao = Dao(entity, db)
-    counter = Counter(array)
-    for item in array:
-        item['saved'] = True
-        dao.save_one(item)
-        payload = counter.tick()
-        sender.to_clients(payload, sender.client, wait=True)
-
-
-
-def delete_many_handler(sender: ValarSocketSender):
-    data = sender.data
-    entity, conditions, db = data.get("entity"), data.get("conditions", []), data.get("db")
-    if db == 'orm':
-        dao = OrmDao(entity)
-        query_set, _ = dao.find(conditions)
-        paths = dao.model.get_file_paths(query_set)
-        query_set.delete()
-        counter = Counter(len(paths))
-        for path in paths:
-            dao.model.minio.remove_path(path)
-            payload = counter.tick()
-            sender.to_clients(payload, sender.client, wait=True)
-    else:
-        dao = MonDao(entity)
-        dao.delete(conditions)
-
-
-