valar 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

valar/data/models.py

@@ -0,0 +1,223 @@
+from django.db import models
+from django.db.models.fields.files import FieldFile
+
+
+class VModel(models.Model):
+    sort = models.BigIntegerField(null=True, verbose_name='序号')
+    name = models.CharField(max_length=50, null=True)
+    create_time = models.DateTimeField(auto_now_add=True, null=True, verbose_name='创建时间')
+    modify_time = models.DateTimeField(auto_now=True, null=True, verbose_name='修改时间')
+    saved = models.BooleanField(default=False)
+
+    class Meta:
+        abstract = True
+
+    @property
+    def mapping(self):
+        mapping = {}
+        for field in self._meta.get_fields():
+            prop = field.name
+            domain = type(field).__name__
+            mapping[prop] = {'prop': prop, 'domain': domain, 'field': field}
+        return mapping
+
+    """
+        只序列化基础字段：能用value_from_object直接取出的字段。与values等价
+    """
+
+    def __str__(self):
+        return str(self.json)
+
+    @property
+    def json(self):
+        mapping = self.mapping
+        excludes = ['ManyToOneRel', 'OneToOneRel', 'ManyToManyRel', 'ManyToManyField', 'UUIDField']
+        mapping = {prop: mapping[prop] for prop in mapping if mapping[prop]['domain'] not in excludes}
+        data = {}
+        for prop in mapping:
+            field = mapping[prop]['field']
+            domain = mapping[prop]['domain']
+            value = field.value_from_object(self)
+            if domain in ['ForeignKey', 'OneToOneField']:
+                prop = prop + '_id'
+            elif domain in ['DateField']:
+                value = value.strftime('%Y-%m-%d') if value else None
+            elif domain in ['DateTimeField']:
+                value = value.strftime('%Y-%m-%d %H:%M:%S') if value else None
+            elif domain in ['FileField']:
+                file: FieldFile = value
+                value = file.name
+            # elif domain in ['BigAutoField']:
+            #     value = str(value)
+            data[prop] = value
+        return data
+
+    @property
+    def full(self):
+        data = self.json
+        mapping = self.mapping
+        excludes = ['ManyToManyField', 'ManyToManyRel', 'ForeignKey', 'ManyToOneRel', 'OneToOneField', 'OneToOneRel']
+        mapping = {prop: mapping[prop] for prop in mapping if mapping[prop]['domain'] in excludes}
+        for prop in mapping:
+            field = mapping[prop]['field']
+            domain = mapping[prop]['domain']
+            if domain in ['ForeignKey', 'OneToOneField', 'OneToOneRel']:
+                if hasattr(self, prop):
+                    bean: VModel = getattr(self, prop)
+                    data[prop] = bean.json if bean else None
+                    data['%s_id'%prop] = bean.id if bean else None
+            elif domain in ['ManyToManyField', 'ManyToManyRel', 'ManyToOneRel']:
+                accessor = prop if domain == 'ManyToManyField' else field.get_accessor_name()
+                try:
+                    _set = getattr(self, accessor).all()
+                    data[prop] = [item.id for item in _set]
+                    data[f'{prop}_set'] = [item.json for item in _set]
+                except Exception as e:
+                    print(e)
+                    pass
+        return data
+
+
+class VTree(VModel):
+    pid = models.IntegerField(null=False, default=0, verbose_name='父节点')
+    isLeaf = models.BooleanField( default=False, verbose_name='叶子节点')
+    icon = models.CharField(max_length=255, null=True, verbose_name='图标')
+    class Meta:
+        abstract = True
+
+
+class Meta(VModel):
+    entity = models.CharField(max_length=100, verbose_name='数据源', null=True, unique=True)
+    name = models.CharField(max_length=50, verbose_name='实体别名', null=True)
+
+    class Meta:
+        verbose_name = '数据实体'
+        # unique_together = ('domain', 'entity')
+
+
+class MetaView(VModel):
+    meta = models.ForeignKey('Meta', on_delete=models.CASCADE, verbose_name='元数据')
+
+    code = models.CharField(max_length=50, verbose_name='类视图', default='default ')
+    view_name = models.CharField(max_length=50, verbose_name='视图名称', null=True)
+
+    form_width = models.IntegerField(default=0, verbose_name='表单宽度')
+    form_height = models.IntegerField(default=0, verbose_name='表单高度')
+    table_width = models.IntegerField(default=0, verbose_name='表格宽度')
+    table_height = models.IntegerField(default=0, verbose_name='表格高度')
+
+    enable = models.BooleanField(default=True, verbose_name='是否启用')
+    show_header = models.BooleanField(default=True, verbose_name='展示头部')
+    allow_batch = models.BooleanField(default=True, verbose_name='批处理')
+    allow_search = models.BooleanField(default=True, verbose_name='检索功能')
+    allow_sort = models.BooleanField(default=True, verbose_name='排序功能')
+    allow_pop = models.BooleanField(default=True, verbose_name='移动功能')
+    allow_insert = models.BooleanField(default=True, verbose_name='新增功能')
+    allow_edit = models.BooleanField(default=True, verbose_name='编辑功能')
+    allow_remove = models.BooleanField(default=True, verbose_name='删除功能')
+    allow_download = models.BooleanField(default=True, verbose_name='下载功能')
+    allow_upload = models.BooleanField(default=True, verbose_name='上传功能')
+
+    class Meta:
+        verbose_name = '数据视图'
+        unique_together = ('meta', 'code')
+
+
+class MetaField(VModel):
+    # 标识
+    view = models.ForeignKey('MetaView', on_delete=models.CASCADE, verbose_name='数据视图')
+    prop = models.CharField(max_length=100, verbose_name='字段名称')  #
+    label = models.CharField(max_length=100, verbose_name='字段标签')  #
+    name = models.CharField(max_length=100, verbose_name='字段别名')  #
+
+    """tool"""
+    domain = models.CharField(max_length=100, verbose_name='字段类型')  #
+    tool = models.CharField(max_length=100, default='default', verbose_name='工具组件')
+    refer = models.JSONField(default=dict, verbose_name='索引')  #
+    format = models.JSONField(default=dict, verbose_name='格式')  #
+
+
+    """rest"""
+    unit = models.CharField(max_length=55, verbose_name='单位符', null=True)
+    not_null = models.BooleanField(default=False, verbose_name='不为空') #
+    read_only = models.BooleanField(default=False, verbose_name='只读')
+    sortable = models.BooleanField(default=False, verbose_name='可排序')
+    allow_search = models.BooleanField(default=True, verbose_name='可搜索')
+    allow_download = models.BooleanField(default=True, verbose_name='可下载')
+    allow_upload = models.BooleanField(default=False, verbose_name='可上传')
+    allow_update = models.BooleanField(default=False, verbose_name='可更新')
+
+    """table"""
+    column_width = models.FloatField(default=0, verbose_name='表头宽度')
+    align = models.CharField(max_length=55, default='left', verbose_name='对齐方式') #
+    fixed = models.CharField(max_length=100, verbose_name='固定位置', null=True)
+    header_color = models.CharField(max_length=55, verbose_name='表头颜色', null=True)
+    cell_color = models.CharField(max_length=55, verbose_name='单元颜色', null=True)
+    edit_on_table = models.BooleanField(default=False, verbose_name='表格编辑')
+    hide_on_table = models.BooleanField(default=False, verbose_name='表内隐藏')
+
+    """form"""
+    span = models.IntegerField(default=0, verbose_name='表单占位')
+    hide_on_form = models.BooleanField(default=False, verbose_name='表单隐藏')
+    hide_on_form_edit = models.BooleanField(default=False, verbose_name='编辑隐藏')
+    hide_on_form_insert = models.BooleanField(default=False, verbose_name='新增隐藏')
+    hide_on_form_branch = models.BooleanField(default=False, verbose_name='分支隐藏')
+    hide_on_form_leaf = models.BooleanField(default=False, verbose_name='叶子隐藏')
+
+    class Meta:
+        verbose_name = '视图字段'
+
+
+
+class MetaFieldTool(VTree):
+    name = models.CharField(max_length=255, null=True, verbose_name='名称')
+    code = models.CharField(max_length=100, unique=True, null=True, verbose_name='代码')  #
+    format = models.JSONField(default=dict, verbose_name='格式参数')  #
+
+    class Meta:
+        verbose_name = '元数据字段工具'
+#
+#
+class MetaFieldDomain(VModel):
+    name = models.CharField(max_length=255, unique=True, null=True, verbose_name='名称')
+    tools = models.ManyToManyField(to=MetaFieldTool, verbose_name='工具集')
+    default = models.ForeignKey(to=MetaFieldTool, null=True, on_delete=models.SET_NULL, related_name='+',
+                                verbose_name='默认工具')
+    search = models.ForeignKey(to=MetaFieldTool, null=True, on_delete=models.SET_NULL, related_name='+',
+                               verbose_name='搜索工具')
+    align = models.CharField(max_length=10, null=True, verbose_name='对齐方式')
+
+    class Meta:
+        verbose_name = '元数据字段类型'
+
+
+
+
+
+class Vala(VModel):
+    text_field = models.TextField(null=True, verbose_name='text')
+    boolean_field = models.BooleanField(null=True, verbose_name='boolean')
+    integer_field = models.IntegerField(null=True, verbose_name='integer')
+    float_field = models.FloatField(null=True, verbose_name='float')
+    date_field = models.DateField(null=True, verbose_name='date')
+    datetime_field = models.DateTimeField(null=True, verbose_name='datetime')
+    time_field = models.TimeField(null=True, verbose_name='time')
+    json_field = models.JSONField(null=True, verbose_name='json')
+    file = models.FileField(null=True, verbose_name='File')
+    # menus = models.ManyToManyField(to=MetaField, related_name='+')
+    # menu = models.ForeignKey(to=MetaField, null=True, on_delete=models.CASCADE, verbose_name='vala')
+
+
+class M2O(VModel):
+    vala = models.ForeignKey(to=Vala, null=True, on_delete=models.CASCADE, verbose_name='vala')
+    name = models.CharField(max_length=100, null=True, verbose_name='name')
+
+
+class O2O(VModel):
+    vala = models.OneToOneField(to=Vala, null=True, on_delete=models.CASCADE, verbose_name='vala')
+    name = models.CharField(max_length=100, null=True, verbose_name='name')
+
+
+class M2M(VModel):
+    valas = models.ManyToManyField(to=Vala, verbose_name='valas')
+    name = models.CharField(max_length=100, null=True, verbose_name='name')

valar/data/mon/__init__.py

@@ -0,0 +1,84 @@
+from bson import ObjectId
+from django.db.models import QuerySet
+from pymongo.results import InsertOneResult, UpdateResult
+
+from django.conf import settings
+import pymongo
+
+from ..query import Query
+
+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) -> [QuerySet, int]:
+        skip = (page - 1) * size
+        condition = query.mon_conditions()
+        total = self.collection.count_documents(condition)
+        cursor = self.collection.find(condition).sort(query.orders).skip(skip).limit(size)
+        return [cursor, total]
+
+
+    def meta(self):
+        one = self.collection.find_one()
+        return one

valar/data/orm/__init__.py

@@ -0,0 +1,87 @@
+import datetime
+from django.apps import apps
+from django.core.paginator import Paginator
+from django.db.models import Manager, QuerySet
+
+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 ..query import Query
+
+
+def load_model(entity=None):
+    mapping = {}
+    for mod in apps.get_models():
+        if issubclass(mod, VModel):
+            path, name = mod.__module__, mod.__name__
+            print(path)
+            app = path.replace('.models', '').replace('src.valar.','')
+            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.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)
+            prop = _field['prop']
+            self.model_fields[prop] = field
+            self.meta_fields[prop] = _field
+
+
+    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()
+            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):
+        self.find_many(query).update(**template)
+
+    def delete_one(self, _id):
+        self.manager.filter(id=_id).delete()
+
+    def delete_many(self, query: Query):
+        self.find_many(query)[0].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]:
+        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 = [ 'sort', 'create_time', 'modify_time', 'saved']
+        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)
+
+
+

valar/data/orm/detacher.py

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,24 @@
+mf_common = ['prop','name','domain']
+
+field_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']),
+        '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 = {
+    'data.MetaField':{
+
+    }
+}

valar/data/orm/meta_loader.py

@@ -0,0 +1,135 @@
+from django.db.models import (ManyToOneRel, ForeignKey, ManyToManyRel, ManyToManyField, OneToOneField, CharField,
+                              OneToOneRel, IntegerField, BooleanField, FloatField, FileField, JSONField, DateField,
+                              TextField,DateTimeField, TimeField)
+
+from ..orm.meta import field_props
+from ..models import Meta, MetaView, VModel, MetaField
+
+
+
+
+
+def __save_model(model):
+    model.save()
+    model.sort = model.id
+    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 = field_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]
+        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']
+    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['id']
+    del item['create_time']
+    del item['modify_time']
+    for key in keys:
+        del item[key]
+
+
+
+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,
+    }
+
+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_format(field):
+    clazz = type(field)
+    if clazz == CharField:
+        return {'maxlength': field.max_length, "type": "text"}
+    if clazz == TextField:
+        return {'maxlength': None, "type": "textarea"}
+    elif clazz == FloatField:
+        return {'min': None, 'max': None, 'step': 1, 'precision': None, 'step_strictly': False}
+    elif clazz == IntegerField:
+        return {'min': None, 'max': None, 'step': 1, 'precision': 0, 'step_strictly': True}
+    elif clazz == FileField:
+        return {'max': 5, 'accept': "*", "width": "800px", "height": "auto", 'locked': False}
+    else:
+        return {}
+
+
+
+def load_meta_field(field):
+    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 = {}
+    not_null = not field.null
+    align = get_align(clazz)
+    _format = get_format(field)
+    return {
+        "prop": prop,
+        "label":label,
+        "name":label,
+        "domain":domain,
+        "refer":refer,
+        "format":_format,
+        "not_null":not_null,
+        "align":align,
+    }