valar 1.0.29__py3-none-any.whl → 1.1.1__py3-none-any.whl

valar/core/dao/engine_mon.py

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

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

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

@@ -1,198 +0,0 @@
-import copy
-
-from bson import ObjectId
-from bson.errors import InvalidId
-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 ..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):
-        try:
-            return int(_id)
-        except TypeError:
-            return 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 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)
-
-        values = MetaFieldDomain.objects.all().values('name', 'default__code', 'align')
-        meta_frame = {
-            vs['name']: {
-                "tool": vs['default__code'],
-                "align": vs['align'],
-            }
-            for vs in values
-        }
-        fields = []
-        for prop in props:
-            field = self.get_field(prop)
-            field_json = field.json()
-            frame = copy.deepcopy(meta_frame.get(field.domain, {}))
-            refer = field_json['refer']
-            if refer['isTree'] and frame.get('tool') == 'select' :
-                frame['tool'] = 'tree'
-            elif self.is_tree and prop =='icon':
-                frame['tool'] = 'icon'
-            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.filter().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]
-        pks = mapping.keys()
-        for field in referred_fields:
-            manager: Manager = query_set.model.objects
-            qs = manager.filter(id__in=pks)
-            utils.linkage(field, qs, mapping)
-        return results
-

valar/core/dao/query_mon.py

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

@@ -1,44 +0,0 @@
-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):
-        conditions = conditions or []
-        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

@@ -1,87 +0,0 @@
-from django.db.models import QuerySet
-
-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: QuerySet, 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

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

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

@@ -1,85 +0,0 @@
-
-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','display':'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
-            },
-        }
-    }
-}