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

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,49 +0,0 @@
-import os
-
-from django.db import OperationalError
-
-from ...data.models import MetaFieldDomain, MetaFieldTool
-import pandas as pd
-
-
-def load_meta_frame():
-    try:
-        MetaFieldTool.objects.all().delete()
-        MetaFieldDomain.objects.all().delete()
-        project_root = os.path.dirname(os.path.abspath(__file__))
-        file_path = os.path.join(project_root, 'meta_frame.xlsx')
-        array = pd.read_excel(file_path, sheet_name='tool').to_dict("records")
-        for row in array:
-            row['saved'] = True
-            MetaFieldTool.objects.create(**row)
-        array = pd.read_excel(file_path, sheet_name='domain').to_dict("records")
-        for row in array:
-            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
-
-
-

valar/data/orm/meta_loader.py

@@ -1,200 +0,0 @@
-from django.db.models import (ManyToOneRel, ForeignKey, ManyToManyRel, ManyToManyField, OneToOneField, CharField,
-                              OneToOneRel, IntegerField, BooleanField, FloatField, FileField, JSONField, DateField,
-                              TextField,DateTimeField, TimeField)
-
-from .meta_frame import convert_meta_fields
-from ..orm.meta import meta_props, meta_defaults
-from ..models import Meta, MetaView, VModel, MetaField, VTree
-
-from deepmerge import always_merger
-
-
-def __save_model(model):
-    model.save()
-    model.sort = model.id
-    model.saved = True
-    model.save()
-
-
-
-def load_view(entity, code, name, fields):
-    meta = Meta.objects.filter(entity=entity).first()
-    if meta is None:
-        meta = Meta(entity=entity, name=name)
-        __save_model(meta)
-    view = MetaView.objects.filter(meta__entity=entity, code=code).first()
-    if view is None:
-        view = MetaView(meta=meta, code=code, view_name=code.upper())
-        __save_model(view)
-    if view.metafield_set.count() == 0:
-        t, p = meta_props.get(entity, {}).get(code,('omit',[]))
-        _fields = [f for f in fields if f['prop'] not in p] if t=='omit' else [f for f in fields if f['prop']  in p]
-        defaults = meta_defaults.get(entity,{})
-        for _field in _fields:
-            prop = _field['prop']
-            _field = always_merger.merge(_field,defaults.get(prop,{}))
-        _fields.reverse()
-        for f in _fields:
-            f['view'] = view
-            field = MetaField.objects.create(**f)
-            __save_model(field)
-    return view
-
-def load_meta(view):
-    _view = view.full
-    _meta = _view['meta']
-    fields = view.metafield_set.all().order_by('-sort')
-    _fields = convert_meta_fields(fields,_meta['entity'])
-    # _fields = [f.json for f in fields]
-    clear_item(_view, 'meta_id', 'metafield', 'metafield_set', 'meta')
-    _view['meta_name'] = _meta['name']
-    _view['entity'] = _meta['entity']
-    _view['fields'] = {}
-    for _field in _fields:
-        clear_item(_field, 'view_id')
-        prop = _field['prop']
-        _view['fields'][prop] = _field
-    return _view
-
-
-
-def clear_item(item, *keys):
-    del item['saved']
-    del item['sort']
-    del item['create_time']
-    del item['modify_time']
-    for key in keys:
-        del item[key]
-
-
-def get_default_refer():
-    return {
-        "entity": None,
-        "value": "name", "label": 'name', "display": "id",
-        "strict": False, "remote": False, "multiple": False,
-        "includes": {}, "excludes": {}, "root": 0, "isTree": False
-    }
-
-
-def get_refer(model, multiple = False):
-    module, name = model.__module__, model.__name__
-    entity = '%s.%s' % (module.replace('.models', '').split('.')[-1], name)
-    return {
-        "entity": entity,
-        "value": "id", "label": 'name', "display": "id",
-        "strict": False, "remote": False, "multiple": multiple,
-        "includes": {}, "excludes": {}, "root": 0, "isTree": issubclass(model, VTree)
-    }
-
-def get_align(clazz):
-    if clazz in [FloatField, IntegerField]:  #, ManyToManyRel, ManyToManyField, ManyToOneRel
-        return 'right'
-    elif clazz in [BooleanField,FileField,JSONField,DateField,DateTimeField,TimeField]:
-        return 'center'
-    return 'left'
-
-def get_default_format():
-    return {
-        # 文本
-        "maxlength": 0,
-        "type": 'text',
-
-        # 数值
-        "min": None,
-        "max": None,
-        "step": 1,
-        "precision": None,
-        "step_strictly": False,
-
-        # 日期
-        "frequency": "date",
-
-        # 文件
-        "maximum": 5,
-        "width": 800,
-        "height": 0,
-        "accept": [],
-        "file_name_field":None,
-        "locked": False,
-
-        #集合
-        "set": {}
-    }
-
-
-
-def get_format(field):
-    clazz = type(field)
-    _format = get_default_format()
-    if clazz == CharField:
-        _format['maxlength'] = field.max_length
-    if clazz == TextField:
-        _format['type'] =  "textarea"
-    elif clazz == DateTimeField:
-        _format['frequency'] = "datetime"
-    elif clazz == IntegerField:
-        _format['precision'] = 0
-        _format['step_strictly'] = True
-    elif clazz == FileField:
-        pass
-    return _format
-
-def get_field_column_width(field,clazz):
-    if clazz in [BooleanField, FileField, JSONField]:
-        return 100
-    elif clazz in [ DateField, DateTimeField, TimeField]:
-        return 120
-    return 0
-
-
-
-def load_meta_field(field, isTree):
-    clazz = type(field)
-    if clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel]:
-        prop = field.name
-        domain = clazz.__name__
-        model: VModel= field.related_model
-        label = model._meta.verbose_name
-        refer = get_refer(model, True)
-    elif clazz in [ForeignKey]:
-        prop = field.name + "_id"
-        domain = field.get_internal_type()
-        model: VModel = field.related_model
-        label = field.verbose_name
-        refer = get_refer(model)
-    elif clazz in [OneToOneRel, OneToOneField]:
-        prop = field.name + "_id"
-        domain = clazz.__name__
-        model: VModel = field.related_model
-        label = model._meta.verbose_name
-        refer = get_refer(model)
-    else:
-        prop = field.name
-        domain = field.get_internal_type()
-        label = field.verbose_name
-        refer = get_default_refer()
-    not_null = not field.null
-    align = get_align(clazz)
-    _format = get_format(field)
-    column_width = get_field_column_width(field,clazz)
-    _field =  {
-        "prop": prop,
-        "label":label,
-        "name":label,
-        "domain":domain,
-        "refer":refer,
-        "format":_format,
-        "not_null":not_null,
-        "align":align,
-        "column_width":column_width
-    }
-
-    if isTree:
-        if 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 prop in ['icon']:
-            _field['tool'] = 'icon'
-    return _field