valar 1.0.17__py3-none-any.whl → 1.0.19__py3-none-any.whl

valar/data/orm/__init__.py

@@ -1,14 +1,18 @@
 import datetime
 from django.apps import apps
 from django.core.paginator import Paginator
-from django.db.models import Manager, QuerySet
+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
+from ..models import VModel, VTree
 from ..query import Query
 
 
+load_meta_frame()
+
 def load_model(entity=None):
     mapping = {}
     for mod in apps.get_models():
@@ -21,6 +25,9 @@ def load_model(entity=None):
             mapping[key] = [mod, verbose_name]
     return mapping.get(entity) if entity else mapping
 
+
+
+
 class OrmDao:
     def __init__(self, entity):
         self.entity = entity
@@ -28,17 +35,50 @@ class OrmDao:
         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)
+            _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)
@@ -46,6 +86,7 @@ class OrmDao:
         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:
@@ -56,18 +97,23 @@ class OrmDao:
         return bean
 
     def update_many(self, query: Query, template):
-        self.find_many(query).update(**template)
+        query_set, total = self.find_many(query)
+        query_set.update(**template)
 
     def delete_one(self, _id):
-        self.manager.filter(id=_id).delete()
+        query_set = self.manager.filter(id=_id)
+        self.__check_remove_file__(query_set)
+        query_set.delete()
 
     def delete_many(self, query: Query):
-        self.find_many(query)[0].delete()
+        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)->[QuerySet, int]:
+    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()
@@ -78,10 +124,12 @@ class OrmDao:
 
 
     def meta(self, code:str = 'default'):
-        omit = [ 'sort', 'create_time', 'modify_time']
+        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)
-        return load_meta(view)
+        _view = load_meta(view)
+        _view['isTree'] = self.isTree
+        return _view
 
 
 

valar/data/orm/meta.py

@@ -1,24 +1,99 @@
-mf_common = ['prop','name','domain']
+mf_common = ['prop','name']
 
-field_props = {
+meta_props = {
     'data.Meta': {
         'default': ('pick', ['entity','name']),
     },
     'data.MetaView': {
         'list': ('pick', ['meta_id','code','view_name']),
-        'control':('omit', ['name','meta_id', 'code', 'view_name', 'metafield'])
     },
     'data.MetaField': {
-        'tool': ('pick',[*mf_common,'tool','refer','format']),
-        'rest': ('pick',[*mf_common,'not_null','read_only','unit','sortable','allow_search','allow_download','allow_upload','allow_update']),
-        'table': ('pick',[*mf_common,'column_width','fixed','align','edit_on_table','hide_on_table','header_color','cell_color']),
+        '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']),
     }
 }
 
 
-field_default = {
+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

@@ -0,0 +1,49 @@
+import os
+
+from django.db import OperationalError
+
+from src.valar.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

@@ -2,16 +2,17 @@ from django.db.models import (ManyToOneRel, ForeignKey, ManyToManyRel, ManyToMan
                               OneToOneRel, IntegerField, BooleanField, FloatField, FileField, JSONField, DateField,
                               TextField,DateTimeField, TimeField)
 
-from ..orm.meta import field_props
-from ..models import Meta, MetaView, VModel, MetaField
-
-
+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()
 
 
@@ -26,8 +27,13 @@ def load_view(entity, code, name, fields):
         view = MetaView(meta=meta, code=code, view_name=code.upper())
         __save_model(view)
     if view.metafield_set.count() == 0:
-        t, p = field_props.get(entity, {}).get(code,('omit',[]))
+        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)
@@ -37,7 +43,9 @@ def load_view(entity, code, name, fields):
 def load_meta(view):
     _view = view.full
     _meta = _view['meta']
-    _fields = _view['metafield_set']
+    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']
@@ -53,13 +61,20 @@ def load_meta(view):
 def clear_item(item, *keys):
     del item['saved']
     del item['sort']
-    del item['id']
     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__
@@ -68,34 +83,72 @@ def get_refer(model, multiple = False):
         "entity": entity,
         "value": "id", "label": 'name', "display": "id",
         "strict": False, "remote": False, "multiple": multiple,
-        "includes": {}, "excludes": {}, "root": 0,
+        "includes": {}, "excludes": {}, "root": 0, "isTree": issubclass(model, VTree)
     }
 
 def get_align(clazz):
-    if clazz in [FloatField, IntegerField, ManyToManyRel, ManyToManyField, ManyToOneRel]:
+    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:
-        return {'maxlength': field.max_length, "type": "text"}
+        _format['maxlength'] = field.max_length
     if clazz == TextField:
-        return {'maxlength': None, "type": "textarea"}
-    elif clazz == FloatField:
-        return {'min': None, 'max': None, 'step': 1, 'precision': None, 'step_strictly': False}
+        _format['type'] =  "textarea"
+    elif clazz == DateTimeField:
+        _format['frequency'] = "datetime"
     elif clazz == IntegerField:
-        return {'min': None, 'max': None, 'step': 1, 'precision': 0, 'step_strictly': True}
+        _format['precision'] = 0
+        _format['step_strictly'] = True
     elif clazz == FileField:
-        return {'max': 5, 'accept': "*", "width": "800px", "height": "auto", 'locked': False}
-    else:
-        return {}
+        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):
+
+def load_meta_field(field, isTree):
     clazz = type(field)
     if clazz in [ManyToOneRel, ManyToManyField, ManyToManyRel]:
         prop = field.name
@@ -119,11 +172,12 @@ def load_meta_field(field):
         prop = field.name
         domain = field.get_internal_type()
         label = field.verbose_name
-        refer = {}
+        refer = get_default_refer()
     not_null = not field.null
     align = get_align(clazz)
     _format = get_format(field)
-    return {
+    column_width = get_field_column_width(field,clazz)
+    _field =  {
         "prop": prop,
         "label":label,
         "name":label,
@@ -132,4 +186,15 @@ def load_meta_field(field):
         "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

valar/data/orm/values.py

@@ -43,6 +43,13 @@ def get_props(model:VModel, code):
     return simple_props, referred_fields, date_props
 
 
+def __get_ref_keys__(related_model):
+    """新增功能"""
+    return [f.name for f in related_model._meta.get_fields()
+      if type(f) not in [ManyToManyField, ManyToOneRel, ManyToManyRel, ForeignKey, OneToOneField, OneToOneRel]
+      and f.name not in ['create_time', 'modify_time', 'saved', 'sort']
+    ]
+
 def to_dict(query_set: QuerySet, code=None):
     model = query_set.model
     simple_props, referred_fields, date_props = get_props(model, code)
@@ -62,8 +69,9 @@ def to_dict(query_set: QuerySet, code=None):
         keys = {'id', value, display, label}
         if clazz in [ForeignKey, OneToOneField, OneToOneRel]:
             related_model = field.related_model
+            __keys = __get_ref_keys__(related_model)
             related_pks = set([row.get(prop) for row in results if row.get(prop)])
-            related_items = related_model.objects.filter(id__in=related_pks).values(*keys)
+            related_items = related_model.objects.filter(id__in=related_pks).values(*__keys)
             mapping = {item['id']: item  for item in related_items}
             for row in results:
                 value = row.get(prop)
@@ -82,7 +90,8 @@ def to_dict(query_set: QuerySet, code=None):
                 array.append(_pk)
                 row_mapping[_id] = array
             related_model = field.related_model
-            related_items = related_model.objects.filter(id__in=_pks).values(*keys)
+            __keys = __get_ref_keys__(related_model)
+            related_items = related_model.objects.filter(id__in=_pks).values(*__keys)
             mapping = {item['id']: item  for item in related_items}
             for row in results:
                 _id = row.get('id')

valar/data/query.py

@@ -1,6 +1,4 @@
 from functools import reduce
-
-
 from django.db.models import Q
 
 
@@ -17,15 +15,18 @@ class Query:
     def __init__(self, body=None):
         if body is None:
             body = {}
-        self.template = body.get('template',{})
-        self.condition = Condition(body.get('condition',{}))
-        self.search = [ Condition(condition) for condition in body.get('search',[])]
-        self.orders = body.get('orders',{})
+        self.template = body.get('template', {})
+        self.condition = Condition(body.get('condition', {}))
+        self.search = [Condition(condition) for condition in body.get('search', [])]
+        self.orders = body.get('orders', {})
+        self.finder = body.get('finder', {})
+        self.page = body.get('page',1)
+        self.size = body.get('size', 0)
 
     def orm_orders(self):
         array = []
-        for key in self.orders :
-            value = self.orders .get(key)
+        for key in self.orders:
+            value = self.orders.get(key)
             prefix = '-' if value == -1 else ''
             array.append(f'{prefix}{key}')
         return array
@@ -33,16 +34,15 @@ class Query:
     def orm_conditions(self):
         includes, excludes = self.condition.includes, self.condition.excludes
         if len(self.search):
-            inc = [ Q(**{**includes, **sea.includes}) for sea in self.search]
-            exc = [ Q(**{**excludes, **sea.excludes}) for sea in self.search]
-            def fun(x, y):return x | y
+            inc = [Q(**{**includes, **sea.includes}) for sea in self.search]
+            exc = [Q(**{**excludes, **sea.excludes}) for sea in self.search]
+            def fun(x, y): return x | y
             return [reduce(fun, inc), reduce(fun, exc)]
         else:
             return [Q(**self.condition.includes), Q(**self.condition.excludes)]
 
     def mon_conditions(self):
-        includes, excludes = self.condition.includes, self.condition.excludes
-        return {}
-
+        from .mon.query_translator import MongoQueryTranslator
+        return MongoQueryTranslator.translate_query(self)
 
     # def _mon_conditions(self):

valar/data/urls.py

@@ -1,15 +1,24 @@
-from django.urls import path
+from django.urls import path, include
 
 from ..data import views
 
 urlpatterns = [
-    path('save_one', views.save_one),
-    path('save_many', views.save_many),
-    path('update_many', views.update_many),
-    path('delete_one', views.delete_one),
-    path('delete_many', views.delete_many),
-    path('find_one', views.find_one),
-    path('find_many', views.find_many),
-    path('meta', views.meta),
+    path('<str:db>/<str:entity>/save_one', views.save_one),
+    path('<str:db>/<str:entity>/save_many', views.save_many),
+    path('<str:db>/<str:entity>/save_file', views.save_file),
+
+    path('<str:db>/<str:entity>/update_many', views.update_many),
+    path('<str:db>/<str:entity>/delete_one', views.delete_one),
+    path('<str:db>/<str:entity>/delete_many', views.delete_many),
+    path('<str:db>/<str:entity>/find_one', views.find_one),
+    path('<str:db>/<str:entity>/find_many', views.find_many),
+    path('find_file/<str:bucket_name>/<str:object_name>', views.find_file),
+    path('<str:db>/<str:entity>/tree', views.tree),
 
+    # path('data/<str:db>/<str:entity>/', include('src.valar.data.urls')),
+
+    path('add_fields', views.add_fields),
+    path('fields', views.fields),
+    path('meta', views.meta),
+    path('metas', views.metas),
 ]