valar 1.0.21__py3-none-any.whl → 1.0.22__py3-none-any.whl

valar/data/handlers.py

@@ -1,28 +0,0 @@
-import time
-
-from ..channels import ValarSocketSender
-from ..channels.utils import channel_wrapper
-from ..data.utils import get_dao
-
-@channel_wrapper
-def save_many_handler(data, sender: ValarSocketSender):
-    start_time = time.time()
-    entity, array, db = data.get("entity"), data.get("array",[]), data.get("db")
-    dao = get_dao(db, entity)
-    index, length = 1, len(array)
-    for item in array:
-        item['saved'] = True
-        dao.save_one(item)
-        current_time = time.time()
-        time_span = current_time - start_time
-        if time_span > 1:
-            start_time = current_time
-            send(index, length, sender)
-        index += 1
-
-
-
-def send(index, length, sender):
-    percentage = round(index * 100 / length)
-    tick = {'length': length, 'index': index, 'percentage': percentage}
-    sender.to_clients(tick, sender.client)

valar/data/mon/__init__.py

@@ -1,123 +0,0 @@
-from bson import ObjectId
-from pymongo.results import InsertOneResult
-
-from django.conf import settings
-import pymongo
-
-from ..query import Query
-
-from pymongo import MongoClient
-from typing import Dict, Any, List, Optional
-
-try:
-    MONGO = settings.MONGO_SETTINGS
-except AttributeError:
-    MONGO = {
-        'host': 'localhost',
-        'port': 27017,
-    }
-host, port, username, password = MONGO.get('host'), MONGO.get('port'), MONGO.get('username'), MONGO.get('password')
-
-if username and password:
-    uri = f'mongodb://{username}:{password}@{host}:{port}/'
-else:
-    uri = f'mongodb://{host}:{port}/'
-mongo_params = {
-    'maxPoolSize': 10,
-    'minPoolSize': 0,
-    'maxIdleTimeMS': 10000,
-    'connectTimeoutMS': 10000,
-    'socketTimeoutMS': 10000,
-    'serverSelectionTimeoutMS': 10000,
-}
-
-def get_mongo_client():
-    client = pymongo.MongoClient(uri, **mongo_params)
-    client['admin'].command('ping')
-    return client
-
-
-
-class MongoDao:
-    def __init__(self, ref):
-        self.ref = ref
-        db_name = settings.BASE_APP
-        col_name = ref.replace('.', '_')
-        self.client = get_mongo_client()
-        self.collection = self.client[db_name][col_name]
-    def save_one(self, item):
-        _id = item.get('id', None)
-        _id = None if isinstance(_id, int) else _id
-        if _id is None:
-            bean:InsertOneResult = self.collection.insert_one(item)
-            _id = bean.inserted_id
-            self.collection.update_one({'_id': _id}, {'$set': {'sort':str(_id)}})
-        else:
-            del item['id']
-            _id = ObjectId(_id)
-            self.collection.update_one({'_id': _id}, {'$set': item})
-        return self.collection.find_one({'_id': _id})
-
-
-    def update_many(self, query, template):
-        self.collection.update_many(query.mon_conditions(), {'$set': template})
-
-
-    def delete_one(self, _id):
-        self.collection.delete_one({'_id': ObjectId(_id)})
-
-    def delete_many(self, query):
-        self.collection.delete_many(query.mon_conditions())
-
-
-    def find_one(self, _id):
-        return self.collection.find_one({'_id': ObjectId(_id)})
-
-    def find_many(self, query: Query, size=0, page=1) :
-        skip = (page - 1) * size
-        condition = query.mon_conditions()
-        total = self.collection.count_documents(condition)
-        cursor = self.collection.find(condition)
-
-        sort_fields = []
-        for key, value in query.orders.items():
-            sort_direction = pymongo.DESCENDING if value == -1 else pymongo.ASCENDING
-            sort_fields.append((key, sort_direction))
-
-        if sort_fields:
-            cursor = cursor.sort(sort_fields)
-            
-        if size:
-            cursor = cursor.skip(skip).limit(size)
-            
-        return cursor, total
-
-    def meta(self):
-        one = self.collection.find_one()
-        return one
-
-class MongoDBQuery:
-    #Mongo的查询
-    def __init__(self, connection_string: str, database_name: str):
-        self.client = MongoClient(connection_string)
-        self.db = self.client[database_name]
-        
-    def find(self, collection: str, query: Dict[str, Any], 
-             projection: Optional[Dict[str, Any]] = None,
-             sort: Optional[List[tuple]] = None,
-             limit: Optional[int] = None,
-             skip: Optional[int] = None) -> List[Dict[str, Any]]:
-        cursor = self.db[collection].find(query, projection)
-        if sort:
-            cursor = cursor.sort(sort) #好像有警告……但是能跑
-        if skip:
-            cursor = cursor.skip(skip)
-        if limit:
-            cursor = cursor.limit(limit)
-        return list(cursor)
-        
-    def count(self, collection: str, query: Dict[str, Any]) -> int:
-        return self.db[collection].count_documents(query)
-        
-    def close(self):
-        self.client.close()

valar/data/mon/query_translator.py

@@ -1,91 +0,0 @@
-class MongoQueryTranslator:
-    # 将Django ORM查询操作符映射到MongoDB操作符的字典
-    MONGO_OPERATORS = {
-        'exact': lambda v, e: {'$ne': v} if e else v,
-        'iexact': lambda v, e: {'$not': {'$regex': f'^{v}$', '$options': 'i'}} if e else {'$regex': f'^{v}$', '$options': 'i'},
-        'contains': lambda v, e: {'$not': {'$regex': f'{v}'}} if e else {'$regex': f'{v}'},
-        'icontains': lambda v, e: {'$not': {'$regex': f'{v}', '$options': 'i'}} if e else {'$regex': f'{v}', '$options': 'i'},
-        'startswith': lambda v, e: {'$not': {'$regex': f'^{v}'}} if e else {'$regex': f'^{v}'},
-        'istartswith': lambda v, e: {'$not': {'$regex': f'^{v}', '$options': 'i'}} if e else {'$regex': f'^{v}', '$options': 'i'},
-        'endswith': lambda v, e: {'$not': {'$regex': f'{v}$'}} if e else {'$regex': f'{v}$'},
-        'iendswith': lambda v, e: {'$not': {'$regex': f'{v}$', '$options': 'i'}} if e else {'$regex': f'{v}$', '$options': 'i'},
-        'gt': lambda v, e: {'$not': {'$gt': v}} if e else {'$gt': v},
-        'gte': lambda v, e: {'$not': {'$gte': v}} if e else {'$gte': v},
-        'lt': lambda v, e: {'$not': {'$lt': v}} if e else {'$lt': v},
-        'lte': lambda v, e: {'$not': {'$lte': v}} if e else {'$lte': v},
-        'in': lambda v, e: {'$nin': v} if e else {'$in': v},
-        'exists': lambda v, e: {'$eq': None} if (e and bool(v)) or (not e and not bool(v)) else {'$ne': None},
-        'isnull': lambda v, e: {'$ne': None} if e else {'$eq': None},
-    }
-    
-    @classmethod
-    def process_field_query(cls, key, value, is_exclude=False):
-        """处理单个字段查询"""
-        if '__' in key:
-            field, op = key.split('__', 1)
-            if op in cls.MONGO_OPERATORS:
-                return field, cls.MONGO_OPERATORS[op](value, is_exclude)
-        return key, {'$ne': value} if is_exclude else value
-    
-    @classmethod
-    def process_condition(cls, condition_dict, is_exclude=False):
-        """处理条件字典，返回MongoDB查询条件"""
-        return {field: query for field, query in 
-                [cls.process_field_query(k, v, is_exclude) for k, v in condition_dict.items()]}
-    
-    @classmethod
-    def process_finder(cls, finder):
-        """处理finder字段，转换为MongoDB查询条件"""
-        if not finder:
-            return {}
-        mongo_query = {}
-        if 'term' in finder and finder['term'] and isinstance(finder['term'], str):
-            term = finder['term']
-            fields = finder.get('fields', [])
-            if fields:
-                mongo_query['$or'] = [{field: {'$regex': term, '$options': 'i'}} for field in fields]
-            else:
-                mongo_query['$text'] = {'$search': term}
-        if 'range' in finder:
-            for field, ranges in finder['range'].items():
-                field_query = {f'${op}': val for op, val in ranges.items() if op in ['gt', 'gte', 'lt', 'lte']}
-                if field_query:
-                    mongo_query[field] = field_query
-        for query_type, operator in [('match', None), ('exists', '$ne')]:
-            if query_type in finder:
-                for field, value in finder[query_type].items():
-                    if operator == '$ne':
-                        # 处理exists查询，检查字段是否为空
-                        mongo_query[field] = {'$ne': None} if bool(value) else {'$eq': None}
-                    else:
-                        mongo_query[field] = value
-        return mongo_query
-    
-    @classmethod
-    def translate_query(cls, query_obj):
-        """
-        将Query对象转换为MongoDB查询
-        Args:
-            query_obj: Query对象，包含condition, search和finder
-        Returns:
-            转换后的MongoDB查询条件
-        """
-        query = {}
-        query.update(cls.process_condition(query_obj.condition.includes))
-        query.update(cls.process_condition(query_obj.condition.excludes, True))
-        # 处理搜索条件
-        if query_obj.search:
-            or_conditions = []
-            for sea in query_obj.search:
-                search_query = {}
-                search_query.update(cls.process_condition(sea.includes))
-                search_query.update(cls.process_condition(sea.excludes, True))
-                if search_query:
-                    or_conditions.append(search_query)
-            if or_conditions:
-                query["$or"] = or_conditions
-        # 处理和合并finder条件
-        finder_query = cls.process_finder(query_obj.finder)
-        if finder_query and query:
-            return {"$and": [query, finder_query]}
-        return finder_query or query 

valar/data/orm/__init__.py

@@ -1,135 +0,0 @@
-import datetime
-from django.apps import apps
-from django.core.paginator import Paginator
-from django.db.models import Manager, QuerySet, FileField
-
-from .meta_frame import load_meta_frame
-from ..file import minio_remove_path
-from ..orm.detacher import detach_props, save_detached
-from ..orm.meta_loader import load_meta, load_view, load_meta_field
-from ..models import VModel, VTree
-from ..query import Query
-
-
-load_meta_frame()
-
-def load_model(entity=None):
-    mapping = {}
-    for mod in apps.get_models():
-        if issubclass(mod, VModel):
-            path, name = mod.__module__, mod.__name__
-            __old = 'src.valar.' if path.startswith('src') else 'valar.'
-            app = path.replace('.models', '').replace(__old,'')
-            key = '%s.%s' % (app, name)
-            verbose_name = mod._meta.verbose_name
-            mapping[key] = [mod, verbose_name]
-    return mapping.get(entity) if entity else mapping
-
-
-
-
-class OrmDao:
-    def __init__(self, entity):
-        self.entity = entity
-        param = load_model(entity)
-        if param is None:
-            raise Exception('no entity named %s' % entity)
-        self.model = param[0]
-        self.isTree = issubclass(self.model, VTree)
-        self.name: str = param[1]
-        self.manager: Manager = self.model.objects
-        self.meta_fields = {}
-        self.model_fields = {}
-        for field in self.model._meta.get_fields():
-            _field = load_meta_field(field, self.isTree)
-            prop = _field['prop']
-            self.model_fields[prop] = field
-            self.meta_fields[prop] = _field
-
-
-    def tree(self, query: Query, root_id = 0):
-        all_set, _ = self.find_many(Query())
-        includes, excludes = query.orm_conditions()
-        if not len(includes) + len(excludes) + root_id:
-            return all_set
-        values = all_set.values('id','pid')
-        mapping = {item['id']: item['pid'] for item in values}
-        results, _ = self.find_many(query)
-        id_set = {root_id}
-        for item in results:
-            _id = item.id
-            route = []
-            while _id is not None:
-                route.append(_id)
-                _id = mapping.get(_id)
-            if root_id in route:
-                id_set.update(route)
-        return all_set.filter(id__in=id_set).order_by('-sort')
-
-    def __check_remove_file__(self, query_set, template:dict = None):
-        props = [key for key in self.model_fields if type(self.model_fields[key]) == FileField]
-        keys = [ key for key in props if template.get(key, 1) is None] if template else  props
-        if len(keys):
-            values = query_set.values(*props)
-            for row in values:
-                for path in row.values():
-                    if path:
-                        print(path)
-                        minio_remove_path(path)
-
-
-
-    def save_one(self, item):
-        _item = detach_props(item, self.meta_fields.values())
-        _id = item.get('id',0)
-        query_set = self.manager.filter(id=_id)
-        if len(query_set):
-            del item['id']
-            item['modify_time'] = datetime.datetime.now()
-            self.__check_remove_file__(query_set,item)
-            query_set.update(**item)
-            bean = query_set.first()
-        else:
-            bean = self.manager.create(**item)
-            bean.sort = bean.id
-            bean.save()
-        save_detached(bean, _item, self.model_fields)
-        return bean
-
-    def update_many(self, query: Query, template):
-        query_set, total = self.find_many(query)
-        query_set.update(**template)
-
-    def delete_one(self, _id):
-        query_set = self.manager.filter(id=_id)
-        self.__check_remove_file__(query_set)
-        query_set.delete()
-
-    def delete_many(self, query: Query):
-        query_set, total = self.find_many(query)
-        self.__check_remove_file__(query_set)
-        query_set.delete()
-
-    def find_one(self, _id):
-        return self.manager.filter(id=_id).first()
-
-    def find_many(self, query: Query, size=0, page=1):
-        includes, excludes = query.orm_conditions()
-        query_set = self.manager.filter(includes).exclude(excludes).order_by(*query.orm_orders())
-        total = query_set.count()
-        if size:
-            paginator = Paginator(query_set, size)
-            query_set = paginator.page(page).object_list
-        return query_set, total
-
-
-    def meta(self, code:str = 'default'):
-        omit = [ 'id', 'saved', 'sort', 'create_time', 'modify_time']
-        fields = [ self.meta_fields[prop] for prop in self.meta_fields if prop not in omit]
-        view =  load_view(self.entity, code, self.name, fields)
-        _view = load_meta(view)
-        _view['isTree'] = self.isTree
-        return _view
-
-
-

valar/data/orm/detacher.py

@@ -1,61 +0,0 @@
-from django.db.models import (ManyToOneRel, ForeignKey, ManyToManyRel, ManyToManyField, OneToOneField, CharField,
-                              OneToOneRel, IntegerField, BooleanField, FloatField, FileField, JSONField, DateField,
-                              DateTimeField, TimeField, QuerySet)
-
-from ..models import VModel
-
-
-def detach_props(item, fields):
-    keys = [field['prop'] for field in fields if
-            field['domain'] in ['ManyToOneRel', 'ManyToManyField', 'ManyToManyRel', 'OneToOneRel', 'OneToOneField']]
-    _item = {}
-    for key in keys:
-        value = item.get(key)
-        if value is not None:
-            _item[key] = value
-            del item[key]
-    return _item
-
-def save_detached(bean, _item, model_fields ):
-    for prop in _item:
-        value = _item[prop]
-        field = model_fields.get(prop)
-        clazz = type(field)
-        if clazz == ManyToManyField:
-            m2m = getattr(bean, prop)
-            m2m.clear()
-            m2m.add(*value)
-        elif clazz == ManyToOneRel:
-            getattr(bean, field.get_accessor_name()).clear()
-            remote_model: VModel = field.related_model
-            new_set: QuerySet = remote_model.objects.filter(id__in=value)
-            remote_field: ForeignKey = field.remote_field
-            k = remote_field.get_attname()
-            new_set.update(**{k: bean.id})
-        elif clazz == ManyToManyRel:
-            getattr(bean, field.get_accessor_name()).clear()
-            remote_model: VModel = field.related_model
-            remote_items: QuerySet = remote_model.objects.filter(id__in=value)
-            remote_field: ManyToManyField = field.remote_field
-            remote_field_prop = remote_field.get_attname()
-            for _bean in remote_items:
-                bean_set = getattr(_bean, remote_field_prop)
-                bean_set.add(bean)
-        elif clazz == OneToOneRel:
-            remote_model: VModel = field.related_model
-            remote_field: OneToOneField = field.remote_field
-            remote_field_prop = remote_field.get_attname()
-            _bean = remote_model.objects.get(id=value)
-            __bean = remote_model.objects.filter(**{remote_field_prop: bean.id}).first()
-            if __bean:
-                setattr(__bean, remote_field_prop, None)
-                __bean.save()
-            setattr(_bean, remote_field_prop, bean.id)
-            _bean.save()
-        elif clazz == OneToOneField:
-            __bean = field.model.objects.filter(**{prop: value}).first()
-            if __bean:
-                setattr(__bean, prop, None)
-                __bean.save()
-            setattr(bean, prop, value)
-            bean.save()

valar/data/orm/meta.py

@@ -1,99 +0,0 @@
-mf_common = ['prop','name']
-
-meta_props = {
-    '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']),
-    }
-}
-
-
-meta_defaults = {
-    'data.MetaFieldDomain':{
-        "default_id":{
-            "tool":"tree"
-        },
-        "search_id":{
-            "tool":"tree"
-        },
-        "tools":{
-            "tool":"tree",
-            "refer": {
-                "display":"code"
-            }
-        },
-        "align":{
-            "tool":"set",
-            "format":{
-                "set": {
-                    'left':'左对齐',
-                    'right':'右对齐',
-                    'center':'剧中对齐',
-                }
-            }
-        }
-    },
-    'data.MetaField':{
-        "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/data/orm/meta_frame.py

@@ -1,100 +0,0 @@
-
-from django.db import OperationalError
-
-from ...data.models import MetaFieldDomain, MetaFieldTool
-
-
-def load_meta_frame():
-    try:
-        MetaFieldTool.objects.all().delete()
-        MetaFieldDomain.objects.all().delete()
-        for row in meta_field_tool:
-            row['saved'] = True
-            MetaFieldTool.objects.create(**row)
-        for row in meta_field_domain:
-            row['saved'] = True
-            tools = row.get('tools', '').split(';')
-            del row['tools']
-            item = MetaFieldDomain.objects.create(**row)
-            for tk in tools:
-                item.tools.add(tk)
-    except OperationalError as e:
-        print('initialization')
-
-
-def convert_meta_fields(fields, entity):
-    values = MetaFieldDomain.objects.all().values('name', 'default__code', 'align')
-    mapping = {vs['name']: {
-        "tool": vs['default__code'],
-        "align": vs['align']
-    } for vs in values}
-    array = []
-    for field in fields:
-        node = mapping[field.domain]
-        _field = field.json
-        if field.tool == 'default':
-            _field['tool'] = node['tool']
-        _field['align'] = node['align']
-        _field['entity'] = entity
-        array.append(_field)
-    return array
-
-
-
-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': 27, 'sort': 39, 'pid': 0, 'isLeaf': True, 'name': '默认', 'code': 'default'},
-    {'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 = [
-    {'id': 12, 'sort': 22, 'name': 'CharField', 'default_id': 2, 'align': 'left', 'tools': '2;6;18;19;21;22;24;25;26;27;28;31;32;33;37;39;54'},
-    {'id': 11, 'sort': 21, 'name': 'TextField', 'default_id': 32, 'align': 'left', 'tools': '2;27;31;32'},
-    {'id': 13, 'sort': 20, 'name': 'BooleanField', 'default_id': 17, 'align': 'center', 'tools': '17;23;27;31'},
-    {'id': 9, 'sort': 18, 'name': 'IntegerField', 'default_id': 6, 'align': 'right', 'tools': '6;27;31'},
-    {'id': 8, 'sort': 16, 'name': 'FloatField', 'default_id': 6, 'align': 'right', 'tools': '6;27;31'},
-    {'id': 4, 'sort': 15, 'name': 'ForeignKey', 'default_id': 24, 'align': 'left', 'tools': '24;25;26;27;31'},
-    {'id': 2, 'sort': 13, 'name': 'ManyToOneRel', 'default_id': 24, 'align': 'center', 'tools': '20;24;25;26;27;31'},
-    {'id': 1, 'sort': 12, 'name': 'ManyToManyField', 'default_id': 24, 'align': 'center', 'tools': '20;24;25;26;27;31'},
-    {'id': 22, 'sort': 11, 'name': 'ManyToManyRel', 'default_id': 24, 'align': 'center', 'tools': '20;24;25;26;27;31'},
-    {'id': 5, 'sort': 10, 'name': 'OneToOneRel', 'default_id': 31, 'align': 'left', 'tools': '27;31'},
-    {'id': 21, 'sort': 9, 'name': 'OneToOneField', 'default_id': 31, 'align': 'left', 'tools': '27;31'},
-    {'id': 6, 'sort': 8, 'name': 'DateField', 'default_id': 22, 'align': 'center', 'tools': '22;27;31'},
-    {'id': 20, 'sort': 7, 'name': 'TimeField', 'default_id': 35, 'align': 'center', 'tools': '27;31;35'},
-    {'id': 7, 'sort': 6, 'name': 'DateTimeField', 'default_id': 22, 'align': 'center', 'tools': '22;27;31'},
-    {'id': 3, 'sort': 5, 'name': 'JSONField', 'default_id': 12, 'align': 'center', 'tools': '12;27;31'},
-    {'id': 15, 'sort': 4, 'name': 'FileField', 'default_id': 14, 'align': 'center', 'tools': '13;14;15;27;31'},
-    {'id': 16, 'sort': 3, 'name': 'BigAutoField', 'default_id': 31, 'align': 'right', 'tools': '27;31'},
-    {'id': 18, 'sort': 2, 'name': 'UUIDField', 'default_id': 31, 'align': 'left', 'tools': '27;31'},
-    {'id': 10, 'sort': 1, 'name': 'Custom', 'default_id': 31, 'align': 'left', 'tools': '27;31'}
-]