valar 1.1.4__py3-none-any.whl → 1.2.1__py3-none-any.whl

valar/dao/defaults/field_values_default.py

@@ -0,0 +1,135 @@
+meta_field_value_defaults = {
+    'valar.Meta': {
+        "__init__": {
+            "db": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'orm': 'SQL',
+                        'mon': 'MongoDB',
+                        'center': '剧中对齐',
+                    }
+                }
+            },
+        }
+    },
+    'valar.MetaView': {
+        "__init__": {
+            "meta_id": {
+                'allow_edit': False,
+            },
+            "code": {
+                'allow_edit': False,
+            },
+            "name": {
+                'span': 24
+            }
+        },
+        "core": {
+            "name": {
+                'span': 16
+            },
+            "enable": {
+                "span": 8
+            }
+        }
+    },
+    'valar.MetaFieldDomain': {
+        "__init__": {
+            "default_id": {
+                "tool": "tree"
+            },
+            "search_id": {
+                "tool": "tree"
+            },
+            "tools": {
+                "tool": "tree",
+                "refer": {
+                    "display": "code"
+                }
+            },
+            "align": {
+                "tool": "set",
+                "format": {
+                    "set": {
+                        'left': '左对齐',
+                        'right': '右对齐',
+                        'center': '剧中对齐',
+                    }
+                }
+            }
+        }
+    },
+    'valar.MetaField': {
+        "rest": {
+            "name": {
+                'hide_on_form': False
+            },
+        },
+        "__init__": {
+            "column_width": {
+                'unit': 'px'
+            },
+            "name": {
+                'span': 24,
+                'hide_on_form': True
+            },
+            "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,
+                'span': 24,
+                'tool': 'tree',
+                'refer': {
+                    'entity': 'valar.MetaFieldTool',
+                    'includes': {'metafielddomain__name': '${domain}'},
+                    'value': 'code', 'display': 'code', "isTree": True
+                }
+
+            },
+            "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
+            },
+            'header_color': {
+                'tool': 'color',
+            },
+            'cell_color': {
+                'tool': 'color',
+            }
+        }
+    }
+}

valar/dao/defaults/view_defaults.py

@@ -0,0 +1,26 @@
+meta_view_default_values = {
+    'valar.Meta': {
+        '__init__': {
+            'allow_insert': False,
+            'allow_upload': False,
+            'lock': True
+        }
+    },
+    'valar.MetaView': {
+        '__init__': {
+            'allow_insert': False,
+            'allow_upload': False,
+            'lock': True
+        },
+    },
+    'valar.MetaField': {
+        '__init__': {
+            'allow_insert': False,
+            'allow_upload': False,
+            'lock': True
+        },
+        'tool': {
+            'allow_edit_on_form': False,
+        }
+    }
+}

valar/dao/engine.py

@@ -0,0 +1,80 @@
+import pymongo
+from django.apps import apps
+from django.conf import settings
+from urllib.parse import urlparse
+from minio import Minio
+from pymongo.synchronous.collection import Collection
+
+from ..classes.singleton_meta import SingletonMeta
+from ..classes.valar_minio import ValarMinio
+from ..models.core import VModel, VTree
+
+
+class ValarEngine(metaclass=SingletonMeta):
+
+    def __init__(self):
+        orm_engine = {}
+        for model in apps.get_models():
+            meta = getattr(model, '_meta')
+            app = meta.app_label
+            if app not in ['sessions']:
+                entity = f'{app}.{model.__name__}'
+                orm_engine[entity] = model
+        self.orm_engine = orm_engine
+
+        # mon
+        if hasattr(settings, 'MONGO_URI'):
+            self.mongo_client = pymongo.MongoClient(
+                settings.MONGO_URI,
+                **{
+                    'maxPoolSize': 10,
+                    'minPoolSize': 0,
+                    'maxIdleTimeMS': 10000,
+                    'connectTimeoutMS': 10000,
+                    'socketTimeoutMS': 10000,
+                    'serverSelectionTimeoutMS': 10000,
+                }
+            )
+            self.mongo_engine = self.mongo_client[settings.BASE_APP]
+        else:
+            self.mongo_client = None
+            self.mongo_engine = None
+
+        # minio
+        if hasattr(settings, 'MINIO_URL'):
+            parsed = urlparse(settings.MINIO_URL)
+            endpoint = f'{parsed.hostname}:{parsed.port}'
+            access_key = parsed.username
+            secret_key = parsed.password
+            self.minio_engine = Minio(
+                endpoint=endpoint,
+                access_key=access_key,
+                secret_key=secret_key,
+                secure=False
+            )
+        else:
+            self.minio_engine = None
+
+    def get_orm_model(self, entity) -> VModel:
+        return self.orm_engine[entity]
+
+    def get_mongo_collection(self, entity) -> Collection:
+        return self.mongo_engine[entity]
+
+    def get_minio_bucket(self, entity):
+        return ValarMinio(self.minio_engine, entity) if self.minio_engine else None
+
+    # def meta_tree(self):
+    #     mapping = {}
+    #     names = self.mongo_engine.list_collection_names()
+    #
+    #     for entity, model in self.orm_engine.items():
+    #         app, value = entity.split('.')
+    #         is_tree = issubclass(model, VTree)
+    #         meta = getattr(model, '_meta')
+    #         name = meta.verbose_name
+    #
+    #         node = mapping.get(app, {'label': app, 'value': app, 'db': 'orm', 'children': []})
+    #         node['children'].append({"label": name, "value": value, 'isTree': is_tree})
+    #         mapping[app] = node
+    #     return list(mapping.values())

valar/dao/frame.py

@@ -0,0 +1,189 @@
+import copy
+
+from ..classes.singleton_meta import SingletonMeta
+
+
+class MetaFrame(metaclass=SingletonMeta):
+    def __init__(self):
+        from .orm_dao import OrmDao
+        from .meta import ValarMeta
+        from ..models.core import VTree
+        from .engine import ValarEngine
+        tool_dao = OrmDao('valar.MetaFieldTool')
+        domain_dao = OrmDao('valar.MetaFieldDomain')
+        tool_dao.delete()
+        domain_dao.delete()
+        mapping = {}
+        for item in meta_field_tool:
+            item = copy.deepcopy(item)
+            _id, code = item['id'], item['code']
+            item.update({"saved": True})
+            if item['isLeaf']:
+                mapping[code] = _id
+            tool_dao.save_one(item, True)
+        for row in meta_field_domain:
+            row = copy.deepcopy(row)
+            default_id, tools = row['default_id'], row['tools']
+            _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)
+
+        meta_dao = OrmDao('valar.Meta')
+        meta_dao.delete([{"includes": {'db__exact': 'orm', 'entity__startswith': 'valar.'}}])
+        engine = ValarEngine()
+        for entity, model in engine.orm_engine.items():
+            tree = issubclass(model, VTree)
+            ValarMeta('orm', entity, 'default')
+        cols = engine.mongo_engine.list_collections()
+        for col in cols:
+            entity = col['name']
+            ValarMeta('mon', entity, 'default')
+
+
+meta_field_tool = [
+    {'id': 2, 'sort': 32, 'pid': 7, 'isLeaf': True, 'name': '输入框', 'code': 'text', 'align': 'left'},
+    {'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', 'align': 'right'},
+    {'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', 'align': 'center'},
+    {'id': 13, 'sort': 5, 'pid': 9, 'isLeaf': True, 'name': '图片上传', 'code': 'image', 'align': 'center'},
+    {'id': 14, 'sort': 2, 'pid': 9, 'isLeaf': True, 'name': '文件上传', 'code': 'file', 'align': 'center'},
+    {'id': 15, 'sort': 13, 'pid': 7, 'isLeaf': True, 'name': '富文本', 'code': 'rich', 'align': 'center'},
+    {'id': 17, 'sort': 11, 'pid': 10, 'isLeaf': True, 'name': '开关', 'code': 'switch', 'align': 'center'},
+    {'id': 19, 'sort': 9, 'pid': 7, 'isLeaf': True, 'name': '颜色选择', 'code': 'color', 'align': 'center'},
+    {'id': 20, 'sort': 14, 'pid': 11, 'isLeaf': True, 'name': '穿梭框', 'code': 'transfer', 'align': 'left'},
+    {'id': 21, 'sort': 16, 'pid': 7, 'isLeaf': True, 'name': '自动填充', 'code': 'auto', 'align': 'left'},
+    {'id': 22, 'sort': 35, 'pid': 5, 'isLeaf': True, 'name': '日期选择', 'code': 'date', 'align': 'left'},
+    {'id': 23, 'sort': 12, 'pid': 10, 'isLeaf': True, 'name': '逻辑选择', 'code': 'boolean', 'align': 'center'},
+    {'id': 24, 'sort': 24, 'pid': 11, 'isLeaf': True, 'name': '列表选择', 'code': 'select', 'align': 'left'},
+    {'id': 25, 'sort': 15, 'pid': 11, 'isLeaf': True, 'name': '树形选择', 'code': 'tree', 'align': 'left'},
+    {'id': 26, 'sort': 23, 'pid': 11, 'isLeaf': True, 'name': '及联选择', 'code': 'cascade', 'align': 'left'},
+    {'id': 28, 'sort': 25, 'pid': 7, 'isLeaf': True, 'name': '图标', 'code': 'icon', 'align': 'center'},
+    {'id': 32, 'sort': 30, 'pid': 7, 'isLeaf': True, 'name': '文本框', 'code': 'textarea', 'align': 'left'},
+    {'id': 33, 'sort': 18, 'pid': 36, 'isLeaf': True, 'name': '时间区间', 'code': 'timerange', 'align': 'left'},
+    {'id': 35, 'sort': 33, 'pid': 5, 'isLeaf': True, 'name': '时间选择', 'code': 'time', 'align': 'left'},
+    {'id': 36, 'sort': 20, 'pid': 0, 'isLeaf': False, 'name': 'RANGE', 'code': '区间工具集'},
+    {'id': 37, 'sort': 38, 'pid': 36, 'isLeaf': True, 'name': '日期区间', 'code': 'daterange', 'align': 'left'},
+    {'id': 39, 'sort': 3, 'pid': 36, 'isLeaf': True, 'name': '多日期', 'code': 'dates', 'align': 'left'},
+    {'id': 54, 'sort': 54, 'pid': 7, 'isLeaf': True, 'name': '集合', 'code': 'set', 'align': 'left'},
+    {'id': 31, 'sort': 6, 'pid': 0, 'isLeaf': True, 'name': '无', 'code': 'none', 'align': 'left'},
+]
+
+meta_field_tool_mapping = {
+    row['code']: row['align']
+    for row in meta_field_tool
+    if row['isLeaf']
+}
+meta_field_domain = [
+    {
+        'name': 'CharField',
+        'default_id': 'text',
+        'tools': [
+            'text', 'number', 'color', 'auto', 'date', 'time', 'select', 'tree', 'cascade', 'icon',
+            'textarea', 'timerange', 'daterange', 'dates', 'set'
+        ]
+    },
+    {
+        'name': 'TextField',
+        'default_id': 'textarea',
+        'tools': ['text', 'textarea', 'rich']
+    },
+    {
+        'name': 'BooleanField',
+        'default_id': 'switch',
+        'tools': ['switch', 'boolean']
+    },
+    {
+        'name': 'IntegerField',
+        'default_id': 'number',
+        'tools': ['number']
+    },
+    {
+        'name': 'FloatField',
+        'default_id': 'number',
+        'tools': ['number']
+    },
+    {
+        'name': 'ForeignKey',
+        'default_id': 'select',
+        'tools': ['select', 'tree', 'cascade']
+    },
+    {
+        'name': 'ManyToOneRel',
+        'default_id': 'select',
+        'tools': ['transfer', 'select', 'tree', 'cascade']
+    },
+    {
+        'name': 'ManyToManyField',
+        'default_id': 'select',
+        'tools': ['transfer', 'select', 'tree', 'cascade']
+    },
+    {
+        'name': 'ManyToManyRel',
+        'default_id': 'select',
+        'tools': ['transfer', 'select', 'tree', 'cascade']
+    },
+    {
+        'name': 'OneToOneRel',
+        'default_id': 'select',
+        'tools': ['select']
+    },
+    {
+        'name': 'OneToOneField',
+        'default_id': 'select',
+        'tools': ['select']
+    },
+    {
+        'name': 'DateField',
+        'default_id': 'date',
+        'tools': ['date']
+    },
+    {
+        'name': 'TimeField',
+        'default_id': 'time',
+        'tools': ['time']
+    },
+    {
+        'name': 'DateTimeField',
+        'default_id': 'date',
+        'tools': ['date']
+    },
+    {
+        'name': 'JSONField',
+        'default_id': 'object',
+        'tools': ['object']
+    },
+    {
+        'name': 'FileField',
+        'default_id': 'file',
+        'tools': ['image', 'file']
+    },
+    {
+        'name': 'BigAutoField',
+        'default_id': 'none',
+        'tools': ['none']
+    },
+    {
+        'name': 'UUIDField',
+        'default_id': 'none',
+        'tools': ['none']
+    },
+    {
+        'name': 'Custom',
+        'default_id': 'none',
+        'tools': ['none']
+    },
+]
+meta_field_domain_mapping = {
+    row['name']: row['default_id']
+    for row in meta_field_domain
+}

valar/dao/meta.py

@@ -0,0 +1,128 @@
+import copy
+
+from deepmerge import always_merger
+from django.conf import settings
+
+from ..dao.defaults.field_keys_default import meta_field_key_defaults
+from ..dao.defaults.field_values_default import meta_field_value_defaults
+from ..dao.defaults.view_defaults import meta_view_default_values
+from ..dao.abstract import AbstractDao
+from ..dao.frame import meta_field_tool_mapping
+from ..dao.mon_dao import MonDao
+from ..dao.orm_dao import OrmDao
+from ..dao.orm_field import column_width
+from ..models.frame import MetaFieldDomain
+from ..models.meta import Meta, MetaView
+
+
+class ValarMeta:
+    def __init__(self, db, entity, code):
+        self.entity = entity
+        self.db = db
+        self.dao: AbstractDao = MonDao(entity) if db == 'mon' else OrmDao(entity)
+        self.code = code or 'default'
+
+        meta_dao = OrmDao('valar.Meta')
+        view_dao = OrmDao('valar.MetaView')
+        field_dao = OrmDao('valar.MetaField')
+
+        meta_item = {"entity": entity, 'db': db}
+        meta: Meta = meta_dao.search(meta_item).first()
+        if meta is None:
+            meta_item.update({"name": self.dao.name, 'saved': True, 'tree': self.dao.is_tree})
+            meta = meta_dao.save_one(meta_item)
+        self.meta = meta
+
+        # load_view
+        view_item = {"code": self.code, "meta_id": meta.id}
+        view: MetaView = view_dao.search(view_item).first()
+        if view is None:
+            self.__initial_view__(view_item)
+            view = view_dao.save_one(view_item)
+        self.view = view
+
+        # load_fields
+        if view.metafield_set.count() == 0:
+            _fields = self.__initial_fields__()
+            for _field in _fields:
+                if _field['prop'] not in ['sort', 'create_time', 'modify_time', 'saved']:
+                    _field.update({'view_id': view.id, "saved": True})
+                    field_dao.save_one(_field)
+
+    def meta_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 = {}
+        _minio = settings.MINIO_ROOT if hasattr(settings, 'MINIO_ROOT') else '/minio'
+        for field in fields:
+            _field = field.json(entity=entity, code=self.code, db='orm', minio=_minio)
+            align, tool, width, domain = _field['align'], _field['tool'], _field['column_width'], _field['domain']
+            _field['align'] = align if align else meta_field_tool_mapping.get(tool, 'left')
+            _field['column_width'] = width if width else column_width(domain, tool)
+
+            _fields[field.prop] = _field
+
+        _minio = settings.MINIO_ROOT if hasattr(settings, 'MINIO_ROOT') else '/minio'
+        _view.update({
+            '$minio': _minio,
+            '$db': 'orm',
+            '$entity': entity,
+            '$code': self.code,
+            '$meta_name': name,
+            '$isTree': self.dao.is_tree,
+            '$fields': _fields,
+            '$modes': self.dao.full_props()
+        })
+        return _view
+
+    """ 默认的view设置 """
+
+    def __initial_view__(self, view_item: dict):
+        default_view = meta_view_default_values.get(self.entity, {})
+        default_values = copy.deepcopy(default_view.get('__init__', {}))
+        code_values = copy.deepcopy(default_view.get(self.code, {}))
+        view_item.update({
+            "name": self.code.upper(),
+            "saved": True,
+            "property": {
+                "value": "id",
+                "label": "name",
+                "display": "id",
+                "sort": "sort",
+                "disabled": "disabled",
+                "isLeaf": "isLeaf",
+                "icon": "icon",
+                "children": "children",
+                "pid": "pid",
+            }
+        })
+        values = always_merger.merge(default_values, code_values)
+        view_item.update(values)
+
+    def __initial_fields__(self):
+        default_keys = meta_field_key_defaults.get(self.entity, {})
+        method, array = default_keys.get(self.code, ('omit', []))
+
+        def fun(prop):
+            return prop not in array if method == 'omit' else prop in array
+
+        props = [prop for prop in self.dao.props() if fun(prop)]
+        if method == 'pick':
+            props = [prop for prop in array if prop in props]
+
+        default_values = copy.deepcopy(meta_field_value_defaults.get(self.entity, {}))
+        init_values = default_values.get('__init__', {})
+        code_values = default_values.get(self.code, {})
+        default_fields = always_merger.merge(init_values, code_values)
+
+        fields = []
+        for prop in props:
+            field = self.dao.get_meta_field(prop)
+            field_json = field.to_dict()
+            default_field = default_fields.get(prop, {})
+            always_merger.merge(field_json, default_field)
+            fields.append(field_json)
+        fields.reverse()
+        return fields

valar/dao/mon_dao.py

@@ -0,0 +1,113 @@
+from pymongo.synchronous.collection import Collection
+from pymongo.results import InsertOneResult
+from pymongo.synchronous.cursor import Cursor
+
+from collections import defaultdict
+
+from .query import Query
+from ..dao.abstract import AbstractDao
+from ..dao.mon_field import MonField
+
+domain_mapping = {
+    'ObjectId': ('BigAutoField', 'none'),
+    'int': ('CharField', 'number'),
+    'str': ('TextField', 'text'),
+    'float': ('CharField', 'number'),
+    'bool': ('BooleanField', 'boolean'),
+}
+
+
+class MonDao(AbstractDao):
+
+    def __init__(self, entity):
+        self.db = 'mon'
+        self.entity = entity
+        self.name = entity
+        self.manager: Collection = self.engine.get_mongo_collection(entity)
+        self.is_tree = False
+        fields = {}
+        for prop, domain, tool in self.__analyze_field_types__():
+            fields[prop] = MonField(entity, prop, domain, tool)
+        self.fields = fields
+
+    def __analyze_field_types__(self):
+        array = []
+        type_map = defaultdict(set)
+        cursor = self.manager.find().limit(1000)
+        for doc in cursor:
+            for key, value in doc.items():
+                type_map[key].add(type(value).__name__)
+        for prop, domains in dict(type_map).items():
+            domain, tool = domain_mapping[domains.pop()]
+            prop = 'id' if prop == '_id' else prop
+            array.append((prop, domain, tool))
+        return array
+
+    def __detach_item__(self, item):
+        _id = item.get('id')
+        if _id:
+            del item['id']
+            return self.object_id(_id), item
+        else:
+            return None, item
+
+    def save_many(self, array: list):
+        self.manager.insert_many(array)
+
+    def values(self, conditions, props):
+        return None
+
+    def save_one(self, item, with_id=False):
+        oid, item = self.__detach_item__(item)
+        if oid:
+            self.manager.update_one({'_id': oid}, {'$set': item})
+        else:
+            bean: InsertOneResult = self.manager.insert_one(item)
+            oid = bean.inserted_id
+            self.manager.update_one({'_id': oid}, {'$set': {'sort': str(oid)}})
+        return self.manager.find_one({'_id': oid})
+
+    def delete_one(self, _id):
+        oid = self.object_id(_id)
+        flag = oid is not None
+        if flag:
+            self.manager.delete_one({'_id': oid})
+        return flag
+
+    def find_one(self, _id):
+        oid = self.object_id(_id)
+        return self.manager.find_one({'_id': oid}) if oid else None
+
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        finder, orders = Query(conditions, orders).mon()
+        skip = (page - 1) * size
+        total = self.manager.count_documents(finder)
+        cursor = self.manager.find(finder).skip(skip).sort(orders)
+        if size:
+            cursor = cursor.limit(size)
+        return cursor, total
+
+    def update(self, template, conditions):
+        flag = template is not None and len(template.keys())
+        if flag:
+            oid, item = self.__detach_item__(template)
+            finder, _ = Query(conditions).mon()
+            self.manager.update_many(finder, {'$set': item})
+        return flag
+
+    def delete(self, conditions=None) -> list:
+        finder, _ = Query(conditions).mon()
+        self.manager.delete_many(finder)
+        return []
+
+    def serialize(self, o, code=None):
+        return [__to_item__(doc) for doc in o] if isinstance(o, Cursor) else __to_item__(o)
+
+    def tree(self, root, conditions=None):
+        pass
+
+
+def __to_item__(o):
+    o['id'] = str(o['_id'])
+    del o['_id']
+    return o