valar 1.0.28__py3-none-any.whl → 1.1.0__py3-none-any.whl

valar/core/dao/dao_orm.py

@@ -1,96 +0,0 @@
-import datetime
-from django.core.paginator import Paginator
-from django.db.models import QuerySet
-
-from .engine import DaoEngine
-from .query_orm import OrmQuery
-from ..dao_abstract import AbstractDao
-
-
-class OrmDao(AbstractDao):
-    def __init__(self, entity):
-        self.entity = entity
-        engine = DaoEngine().orm
-        self.model = engine.get_model(entity)
-        self.objects = self.model.manager
-
-    def get_model(self):
-        return self.model
-
-    def save_one(self, item):
-        oid, simple_item, complex_item  = self.model.detach_item(item)
-        query_set = self.objects.filter(id=oid) if oid else []
-        if len(query_set):
-            simple_item['modify_time'] = datetime.datetime.now()
-            query_set.update(**simple_item)
-            bean = query_set.first()
-        else:
-            bean = self.objects.create(**simple_item)
-            bean.sort = bean.id
-            bean.save()
-        self.model.save_complex_field(complex_item, bean)
-        bean.save()
-        return bean
-
-    def delete_one(self, _id):
-        oid = self.model.object_id(_id)
-        flag = False
-        if oid:
-            query_set = self.objects.filter(id=oid)
-            self.model.remove_files(query_set)
-            query_set.delete()
-            flag = True
-        return flag
-
-    def find_one(self, _id):
-        oid = self.model.object_id(_id)
-        return self.objects.filter(id=oid).first() if oid else None
-
-
-
-    def find(self, conditions=None, orders=None,size=0, page=1):
-        query = OrmQuery(conditions, orders)
-        query_set = self.objects.filter(query.includes).exclude(query.excludes).order_by(*query.orders)
-        total = query_set.count()
-        if size:
-            paginator = Paginator(query_set, size)
-            query_set = paginator.page(page).object_list
-        return query_set, total
-
-    def update(self, template, conditions):
-        if template and len(template.keys()):
-            oid, simple_item, complex_item = self.model.detach_item(template)
-            query_set, total = self.find(conditions)
-            query_set.update(**simple_item)
-            return True
-        return False
-
-    def delete(self, conditions):
-        query_set, total = self.find(conditions)
-        self.model.remove_files(query_set)
-        query_set.delete()
-
-    def transform(self, o, code=None):
-        if isinstance(o, QuerySet):
-            return self.model.to_dict(o, code)
-        else:
-            return o.full()
-
-    def tree(self, root, conditions=None):
-        all_set, _ = self.find([])
-        query = OrmQuery(conditions)
-        if query.is_empty(conditions):
-            return all_set
-        values = all_set.values('id', 'pid')
-        mapping = {item['id']: item['pid'] for item in values}
-        results, _ = self.find(conditions)
-        id_set = {root}
-        for item in results:
-            _id = item.id
-            route = []
-            while _id is not None:
-                route.append(_id)
-                _id = mapping.get(_id)
-            if root in route:
-                id_set.update(route)
-        return all_set.filter(id__in=id_set).order_by('-sort')

valar/core/dao/engine.py

@@ -1,12 +0,0 @@
-
-from ..singleton_meta import SingletonMeta
-from .engine_mon import MonEngine
-from .engine_orm import OrmEngine
-
-
-class DaoEngine(metaclass=SingletonMeta):
-
-    def __init__(self):
-        self.mon = MonEngine()
-        self.orm = OrmEngine()
-

valar/core/dao/engine_minio.py

@@ -1,90 +0,0 @@
-
-import json
-from io import BytesIO
-
-from django.conf import settings
-from minio import Minio
-from urllib3 import  BaseHTTPResponse
-
-from ..singleton_meta import SingletonMeta
-
-class MinioEngine(metaclass=SingletonMeta):
-
-    def __int__(self):
-        self.client = Minio(**settings.MINIO_SETTINGS)
-
-    def __load_bucket__(self, bucket_name):
-        if not self.client.bucket_exists(bucket_name):
-            self.client.make_bucket(bucket_name)
-            policy = __generate_policy__(bucket_name)
-            self.client.set_bucket_policy(bucket_name, policy)
-
-    @staticmethod
-    def get_object_name(_id, prop, file_name):
-        return f"{_id}-{prop}-{file_name}"
-
-    @staticmethod
-    def get_bucket_name(entity):
-        name = f'{settings.BASE_DIR.name}.{entity}'
-        return name.replace('_', '-').lower()
-
-    def upload(self, bucket_name, object_name, _bytes):
-        self.__load_bucket__(bucket_name)
-        file_data = BytesIO(_bytes)
-        file_size = len(_bytes)  # file.siz
-        self.client.put_object(
-            bucket_name=bucket_name,
-            object_name=object_name,
-            data=file_data,
-            length=file_size
-        )
-        return f'{bucket_name}/{object_name}'
-
-    def remove_path(self, path):
-        bucket_name, object_name = path.split('/')
-        self.remove(bucket_name, object_name)
-
-    def remove(self, bucket_name, object_name):
-        self.client.remove_object(
-            bucket_name=bucket_name,
-            object_name=object_name
-        )
-
-    def read(self, bucket_name, object_name) -> BytesIO:
-        ret: BaseHTTPResponse = self.client.get_object(bucket_name=bucket_name, object_name=object_name)
-        return BytesIO(ret.read())
-
-
-def __generate_policy__(bucket_name):
-    return json.dumps({
-        "Version": "2012-10-17",
-        "Statement": [
-            {
-                "Sid": "",
-                "Effect": "Allow",
-                "Principal": {"AWS": "*"},
-                "Action": "s3:GetBucketLocation",
-                "Resource": f"arn:aws:s3:::{bucket_name}"
-            },
-            {
-                "Sid": "",
-                "Effect": "Allow",
-                "Principal": {"AWS": "*"},
-                "Action": "s3:ListBucket",
-                "Resource": f"arn:aws:s3:::{bucket_name}"
-            },
-            {
-                "Sid": "",
-                "Effect": "Allow",
-                "Principal": {"AWS": "*"},
-                "Action": "s3:GetObject",
-                "Resource": f"arn:aws:s3:::{bucket_name}/*"
-            },
-            {
-                "Sid": "",
-                "Effect": "Allow",
-                "Principal": {"AWS": "*"},
-                "Action": "s3:PutObject",
-                "Resource": f"arn:aws:s3:::{bucket_name}/*"
-            }
-        ]})

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,195 +0,0 @@
-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.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,43 +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):
-        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
-
-
-