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

valar/core/dao/engine_mon.py

@@ -0,0 +1,34 @@
+import pymongo
+from django.conf import settings
+
+from .model_mon import MonModel
+
+
+class MonEngine:
+
+    def __init__(self):
+        uri = f'mongodb://localhost:27017/'
+        mongo = settings.MONGO
+        if mongo:
+            param = ['host', 'port', 'username', 'password']
+            host, port, username, password = [mongo.get(p) for p in param]
+            uri = f'mongodb://{username}:{password}@{host}:{port}/'
+
+        client = pymongo.MongoClient(uri, **{
+            'maxPoolSize': 10,
+            'minPoolSize': 0,
+            'maxIdleTimeMS': 10000,
+            'connectTimeoutMS': 10000,
+            'socketTimeoutMS': 10000,
+            'serverSelectionTimeoutMS': 10000,
+        })
+        database =  client[settings.BASE_APP]
+        self.uri = uri
+        self.client = client
+        self.database = database
+
+    def get_mapping(self):
+        return  {col['name']: self.database[col['name']] for col in self.database.list_collections()}
+
+    def get_model(self,entity)->MonModel:
+        return MonModel(self.database, entity)

valar/core/dao/engine_orm.py

@@ -0,0 +1,25 @@
+from django.apps import apps
+
+from .model_orm import OrmModel
+from ..valar_models import VModel
+
+
+class OrmEngine:
+
+    def __init__(self):
+        mapping = {}
+        for model in apps.get_models():
+            if issubclass(model, VModel):
+                path, name = model.__module__, model.__name__
+                prefix = 'src.valar.' if path.startswith('src') else 'valar.'
+                app = path.replace('.models', '').replace(prefix, '')
+                entity = '%s.%s' % (app, name)
+                mapping[entity] = model
+        self.mapping = mapping
+
+    def get_mapping(self)->dict:
+        return self.mapping
+
+    def get_model(self,entity)->OrmModel:
+        mod = self.mapping.get(entity)
+        return OrmModel(mod, entity)

valar/core/dao/model_mon.py

@@ -0,0 +1,24 @@
+from bson import ObjectId
+from bson.errors import InvalidId
+from pymongo.synchronous.collection import Collection
+
+
+class MonModel:
+
+    def __init__(self, database, entity):
+        self.entity = entity
+        self.name = entity.replace('.', '_')
+        self.manager: Collection = database[self.name]
+
+    @staticmethod
+    def object_id(_id):
+        try:
+            return ObjectId(_id)
+        except(InvalidId, TypeError):
+            return None
+
+    def detach_item(self, item):
+        _id = item.get('id')
+        if _id:
+            del item['id']
+        return self.object_id(_id), item

valar/core/dao/model_orm.py

@@ -0,0 +1,192 @@
+from deepmerge import always_merger
+from django.db.models import ManyToOneRel, ForeignKey, ManyToManyRel, ManyToManyField, OneToOneField, OneToOneRel
+from django.db.models import QuerySet
+from django.db.models import Manager
+from django.db.models.fields.files import FieldFile
+from django.forms import FileField
+
+from .engine_minio import MinioEngine
+from .utils_orm import OrmUtils
+from ..meta.defaults.field_keys_default import meta_field_key_defaults
+from ..meta.defaults.field_values_default import meta_field_value_defaults
+from ..meta.field_orm import OrmField
+from ..meta.init_meta_frame import init_meta_frame
+from ..valar_models import VModel, VTree
+from ...data.models import  MetaFieldDomain
+
+
+class OrmModel:
+
+    def __init__(self, mod, entity):
+        self.entity = entity
+        self.model = mod
+        meta = getattr(mod, '_meta')
+        self.name = meta.verbose_name
+        self.is_tree = issubclass(mod, VTree)
+        self.manager: Manager = mod.objects
+        fields = meta.get_fields()
+        mapping = {}
+        for f in fields:
+            field = OrmField(entity, f, self.is_tree)
+            mapping[field.prop] = field
+        self.mapping = mapping
+        self.minio = MinioEngine()
+        self.bucket_name = self.minio.get_bucket_name(entity)
+
+    @staticmethod
+    def object_id(_id):
+        return _id if isinstance(_id, int) and _id else None
+
+    def props(self, domain=None):
+        array = []
+        for prop in self.mapping:
+            field: OrmField = self.mapping[prop]
+            if field.domain == domain or domain is None:
+                array.append(prop)
+        return array
+
+
+    def meta_frame(self):
+        query_set = MetaFieldDomain.objects.all()
+        if query_set.count() == 0:
+            query_set = init_meta_frame()
+        values = query_set.values('name', 'default__code', 'align')
+        return {
+            vs['name']: {
+                "tool": vs['default__code'],
+                "align": vs['align'],
+            }
+            for vs in values
+        }
+
+
+
+
+    def initial_fields(self, code):
+        props = self.props()
+        default_keys = meta_field_key_defaults.get(self.entity,{})
+        method, array = default_keys.get(code, ('omit',[]))
+        def fun(prop): return prop not in array if method == 'omit' else prop in array
+        props = [prop for prop in props if fun(prop)]
+
+        default_values = meta_field_value_defaults.get(self.entity, {})
+        init_values = default_values.get('__init__', {})
+        code_values = default_values.get(code, {})
+        default_fields = always_merger.merge(init_values, code_values)
+
+        meta_frame = self.meta_frame()
+        fields = []
+        for prop in props:
+            field = self.get_field(prop)
+            field_json = field.json()
+            frame = meta_frame.get(field.domain, {})
+            field_json.update(frame)
+            default_field = default_fields.get(prop, {})
+            always_merger.merge(field_json, default_field)
+            fields.append(field_json)
+
+        fields.reverse()
+        return fields
+
+    def get_field(self, prop)->OrmField:
+        return self.mapping[prop]
+
+    def detach_item(self, item):
+        _id = item.get('id')
+        if _id:
+            del item['id']
+        simple_item = {}
+        complex_item = {}
+        for prop in item:
+            field = self.get_field(prop)
+            value = item.get(prop)
+            if field.domain in ['ManyToOneRel', 'ManyToManyField', 'ManyToManyRel', 'OneToOneRel', 'OneToOneField','FileField']:
+                complex_item[prop] = value
+            else:
+                simple_item[prop] = value
+        return self.object_id(_id), simple_item, complex_item
+
+    def get_file_paths(self, query_set: QuerySet):
+        props = self.props('FileField')
+        items = query_set.values(*props)
+        array = []
+        for item in items:
+            array += [i for i in item.values() if i]
+        return array
+
+    def remove_files(self, query_set: QuerySet):
+        paths = self.get_file_paths(query_set)
+        for path in paths:
+            self.minio.remove_path(path)
+
+    def save_complex_field(self, complex_item, bean):
+        for prop in complex_item:
+            value = complex_item[prop]
+            field = self.get_field(prop).model_field
+            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)
+            elif clazz == FileField:
+                file_name, _bytes = value
+                field_file: FieldFile = getattr(bean, prop)
+                if field_file:
+                    path = field_file.name
+                    self.minio.remove_path(path)
+                object_name = self.minio.get_object_name(bean.id, prop, file_name)
+                path = self.minio.upload(self.bucket_name, object_name, _bytes) if _bytes else None
+                setattr(bean, prop, path)
+
+
+
+
+    def to_dict(self, query_set: QuerySet, code=None):
+        # query_set = query_set.filter(saved=True)
+        utils = OrmUtils()
+        orm_fields = self.mapping.values()
+        # 简单字段取值
+        simple_props = [field.prop for field in orm_fields if field.domain not in utils.referred_domains]
+        custom_props = utils.custom_props(self.entity, code)
+        results = list(query_set.values(*[*simple_props, *custom_props]))
+        utils.date_values(orm_fields, results)
+        # 关系型字段取值
+        mapping = { row['id']: row for row in results}
+        referred_fields = [field for field in orm_fields if field.domain in utils.referred_domains]
+        for field in referred_fields:
+            utils.linkage(field, query_set, mapping)
+        return results
+

valar/core/dao/query_mon.py

@@ -0,0 +1,12 @@
+
+def __translate_finder__(conditions):
+    return {}
+
+
+class MonQuery:
+
+    def __init__(self, conditions: list, orders = None):
+        self.orders = orders or {'sort': -1}
+        conditions = conditions if len(conditions) else [{'includes':{},'excludes':{}}]
+        self.finder = __translate_finder__(conditions)
+

valar/core/dao/query_orm.py

@@ -0,0 +1,43 @@
+from django.db.models import Q
+from functools import reduce
+
+
+
+def __fun__(x, y): return x | y
+def __translate_orders__(orders):
+    array = []
+    for key in orders:
+        value = orders.get(key)
+        prefix = '-' if value == -1 else ''
+        array.append(f'{prefix}{key}')
+    return array
+def __translate_condition__(conditions, _type):
+    
+
+
+    return reduce(__fun__,  [Q(**cond[_type]) for cond in conditions])
+
+
+class OrmQuery:
+
+    def __init__(self, conditions: list, orders = None):
+        self.orders =  __translate_orders__(orders or {'sort': -1})
+        conditions = conditions if len(conditions) else [{'includes':{},'excludes':{}}]
+        self.includes = __translate_condition__(conditions,'includes')
+        self.excludes = __translate_condition__(conditions, 'excludes')
+
+    @staticmethod
+    def is_empty(conditions):
+        if conditions and len(conditions):
+            temp = {}
+            for cond in conditions:
+                temp.update(cond)
+            return len(temp.keys()) >0
+        else:
+            return True
+
+
+
+
+
+

valar/core/dao/utils_orm.py

@@ -0,0 +1,85 @@
+from ..valar_models import VModel
+from ...core.meta.field_orm import OrmField
+from ...data.models import MetaField
+
+
+class OrmUtils:
+    def __init__(self):
+        self.multiple_domains = ['ManyToOneRel', 'ManyToManyField', 'ManyToManyRel']
+        self.referred_domains = [*self.multiple_domains, 'OneToOneRel', 'OneToOneField', 'ForeignKey']
+        self.omit_field_props = ['create_time', 'modify_time', 'saved', 'sort']
+        self.data_props_formatting = {'DateField': '%Y-%m-%d', 'DateTimeField': '%Y-%m-%d %H:%M:%S', 'TimeField': '%H:%M:%S'}
+
+
+    @staticmethod
+    def json(bean: VModel):
+        pass
+
+    @staticmethod
+    def custom_props(entity, code='default'):
+        field_set = MetaField.objects.filter(view__code=code, view__meta__entity=entity, domain='Custom').values('prop')
+        return [item['prop'] for item in field_set if item['prop']]
+
+
+    def linkage(self, field, query_set, mapping):
+        model_field = field.model_field
+        prop = model_field.name
+        multiple = field.domain in self.multiple_domains
+
+        # 获取级联关系的键索引
+        ref_prop = f'{prop}__id'
+        edges = query_set.exclude(**{f'{ref_prop}__isnull': True}).values('id', ref_prop)
+        if multiple:
+            related_primary_keys = set()
+            results_mapping = {}
+            for edge in edges:
+                _id, rid = edge['id'], edge[ref_prop]
+                related_primary_keys.add(rid)
+                array = results_mapping.get(_id, [])
+                array.append(rid)
+                results_mapping[_id] = array
+        else:
+            results_mapping = {row['id']: row[ref_prop] for row in edges if row[ref_prop]}
+            related_primary_keys = set(results_mapping.values())
+
+        # 获取级联关系从属方的数据
+        related_model = model_field.related_model
+        related_fields = related_model._meta.get_fields()
+        related_props = self.__get_related_props__(related_fields)
+        related_values = list(related_model.objects.filter(id__in=related_primary_keys).values(*related_props))
+        self.date_values(related_fields, related_values)
+        related_mapping = {item['id']: item for item in related_values}
+
+        # 将从属方的数据绑定在主数据上
+        for _id in mapping:
+            row = mapping[_id]
+            if multiple:
+                keys = results_mapping.get(_id, [])
+                items = [related_mapping[pid] for pid in keys]
+                row[prop] = keys
+                row[f'{prop}_set'] = items
+            else:
+                key = results_mapping.get(_id)
+                item = related_mapping.get(key) if key else None
+                row[prop] = item
+                row[f'{prop}_id'] = key
+
+    def __get_related_props__(self,fields):
+        def fun(field): return type(field).__name__ not in self.referred_domains and field.name not in self.omit_field_props
+        return [field.name for field in fields if fun(field)]
+
+    def date_values(self, fields, values):
+        date_props_mapping = {}
+        for field in fields:
+            if isinstance(field, OrmField):
+                prop = field.prop
+                domain = field.domain
+            else:
+                prop = field.name
+                domain = type(field).__name__
+            if domain in self.data_props_formatting.keys():
+                date_props_mapping[prop] = self.data_props_formatting[domain]
+        for row in values:
+            for prop, formating in date_props_mapping.items():
+                if row.get(prop):
+                    row[prop] = row[prop].strftime(formating)

valar/core/dao_abstract.py

@@ -0,0 +1,63 @@
+from abc import ABC, abstractmethod
+
+class AbstractDao(ABC):
+
+
+    @abstractmethod
+    def get_model(self):
+        pass
+
+    @abstractmethod
+    def save_one(self, item):
+        pass
+
+    @abstractmethod
+    def delete_one(self, _id):
+        pass
+
+    @abstractmethod
+    def find_one(self, _id):
+        pass
+
+    @abstractmethod
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        pass
+
+    @abstractmethod
+    def update(self, template, conditions):
+        pass
+
+    @abstractmethod
+    def delete(self, conditions):
+        pass
+
+    @abstractmethod
+    def transform(self, o, code=None):
+        pass
+
+    @abstractmethod
+    def tree(self, root, conditions=None):
+        pass
+
+    def search(self, includes=None, excludes=None, orders=None):
+        conditions = [{
+            "includes": includes or {},
+            "excludes": excludes or {}
+        }]
+        query_set, _ = self.find(conditions, orders)
+        return query_set
+
+    # @abstractmethod
+    # def values(self, props, conditions, orders=None):
+    #     pass
+    #
+    # @abstractmethod
+    # def group(self, props, conditions, orders=None):
+    #     pass
+    #
+    # @abstractmethod
+    # def count(self, props, conditions):
+    #     pass
+
+
+

valar/core/meta/defaults/field_keys_default.py

@@ -0,0 +1,17 @@
+__mf_common__ = ['prop','name']
+
+meta_field_key_defaults = {
+    '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']),
+    }
+}

valar/core/meta/defaults/field_values_default.py

@@ -0,0 +1,85 @@
+
+meta_field_value_defaults = {
+    'data.MetaFieldDomain':{
+        "__init__":{
+            "default_id":{
+                "tool":"tree"
+            },
+            "search_id":{
+                "tool":"tree"
+            },
+            "tools":{
+                "tool":"tree",
+                "refer": {
+                    "display":"code"
+                }
+            },
+            "align":{
+                "tool":"set",
+                "format":{
+                    "set": {
+                        'left':'左对齐',
+                        'right':'右对齐',
+                        'center':'剧中对齐',
+                    }
+                }
+            }
+        }
+    },
+    'data.MetaField':{
+        "__init__":{
+            "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
+            },
+        }
+    }
+}