valar 1.1.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

valar/apps.py

@@ -1,20 +1,18 @@
 import os
 from django.apps import AppConfig
+from .classes.app_mixins.auto_migration_mixin import AutoMigrationMixin
+from .classes.app_mixins.auto_urlpatterns_mixin import AutoUrlPatternsMixin
 
-from .classes.auto_migration_mixin import AutoMigrationMixin
-from .classes.auto_urlpatterns_mixin import AutoUrlPatternsMixin
+valar_app = __package__.replace('src.', '')
 
 
-class ValarConfig(AutoMigrationMixin,AutoUrlPatternsMixin,AppConfig):
+class ValarConfig(AutoMigrationMixin, AutoUrlPatternsMixin, AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
-    name = 'valar'
+    name = __package__
+
     def ready(self):
         if os.environ.get('RUN_MAIN') == 'true':
+            from .dao.frame import MetaFrame
             getattr(super(), 'set_url', None)()
             getattr(super(), 'auto_migrate', None)()
-            print('valar')
-
-
-
-
-
+            MetaFrame()

valar/channels/consumer.py

@@ -1,8 +1,8 @@
-
 from channels.generic.websocket import AsyncJsonWebsocketConsumer
 
 VALAR_CHANNEL_GROUP = 'VALAR'
 
+
 class ValarConsumer(AsyncJsonWebsocketConsumer):
 
     def __init__(self):
@@ -24,25 +24,23 @@ class ValarConsumer(AsyncJsonWebsocketConsumer):
         pass
 
     async def user_emit(self, event):
-        users: list = event.get('users',[])
-        data = event.get('data',{})
+        users: list = event.get('users', [])
+        data = event.get('data', {})
         if self.uid in users:
             await self.send_json(data)
 
     async def client_emit(self, event):
-        clients: list = event.get('clients',[])
-        data = event.get('data',{})
+        clients: list = event.get('clients', [])
+        data = event.get('data', {})
         if self.client in clients:
             await self.send_json(data)
 
     async def broadcast_emit(self, event):
-        data = event.get('data',{})
+        data = event.get('data', {})
         await self.send_json(data)
 
     async def register_emit(self, event):
-        users: list = event.get('users', [])
-        clients: list = event.get('clients',[])
-        if self.client in clients:
-            self.uid = users[0]
-
-
+        uid = event.get('uid', )
+        client = event.get('client')
+        if self.client == client:
+            self.uid = uid

valar/channels/executer.py

@@ -1,13 +1,14 @@
 import asyncio
 
-async def execute_channel(method, sender):
+from ..channels.sender import ValarChannelSender
+
+
+async def execute_channel(method, sender: ValarChannelSender):
     thread = asyncio.to_thread(__execute__, method, sender)
     asyncio.create_task(thread)
 
 
-def __execute__(method, sender):
-    sender.to_clients(None, [sender.client], 'start')
+def __execute__(method, sender: ValarChannelSender):
+    sender.start()
     method(sender)
-    sender.to_clients(None, [sender.client], 'stop')
-
-
+    sender.stop()

valar/channels/sender.py

@@ -5,60 +5,112 @@ from datetime import datetime
 from asgiref.sync import async_to_sync
 from channels.layers import get_channel_layer
 from django.http import HttpRequest
-
+import threading
 from .consumer import VALAR_CHANNEL_GROUP
-from ..classes.counter import Counter
 
 
-class ValarSocketSender:
-    def __init__(self, request: HttpRequest, data=None):
+class Channel:
+
+    def __init__(self, request: HttpRequest):
         body = json.loads(request.body)
-        auth = request.headers.get('AUTH')
+        self.handler = body.get('handler')
+        self.url = body.get('url')
+        self.auth = body.get('auth')
+        self.broadcast = body.get('broadcast')
+        self.data = body.get('data')
+
+    def to_dict(self, status, payload):
+        data = {
+            'handler': self.handler,
+            'url': self.url,
+            'auth': self.auth,
+            'broadcast': self.broadcast,
+            'timestamp': datetime.now().timestamp()
+        }
+        if status:
+            data.update({'status': status})
+        if payload:
+            data.update({'payload': payload})
+        return data
+
+
+class Sender:
+
+    def __init__(self, request: HttpRequest):
         self.client = request.headers.get('CLIENT')
         self.uid = request.session.get('UID')
-        self.handlerKey = body.get('handlerKey')
-        self.channelKey = body.get('channelKey', 'default')
-        self.data = data or body.get('data')
-        self.send = get_channel_layer().group_send
-        self.start_time = time.time()
-        if auth and not self.uid:
+        self.group_send = async_to_sync(get_channel_layer().group_send)
+
+
+class ValarChannelSender(Sender):
+
+    def __init__(self, request: HttpRequest, interval=1):
+        super().__init__(request)
+        self.__channel__ = Channel(request)
+        self.data = self.__channel__.data
+        self.__payload__ = None
+        self.__loading__ = False
+        self.__thread__ = None
+        self.__lock__ = threading.Lock()
+        self.__interval__ = interval
+        if self.__channel__.auth and not self.uid:
             raise Exception('Unauthorized!')
 
-    @staticmethod
-    def create_counter(length:int):
-        return Counter(length)
-
-    def __convert_body(self, emit, payload, status ,clients = None, users = None):
-        return {
-            'type': emit,
-            'data': {
-                'status': status,
-                'handlerKey': self.handlerKey,
-                'channelKey': self.channelKey,
-                'payload': payload,
-                'timestamp': datetime.now().timestamp()
-            },
-            'clients': clients or [],
-            'users': users or [],
+    def _run(self):
+        while self.__loading__:
+            self.__emit__()
+            time.sleep(self.__interval__)
+
+    def start(self):
+        if self.__loading__:
+            return  # 避免重复启动
+        self.__payload__ = None
+        self.__loading__ = True
+        self.__emit__('start')
+        self.__thread__ = threading.Thread(target=self._run, daemon=True)
+        self.__thread__.start()
+
+    def stop(self):
+        self.__payload__ = None
+        self.__loading__ = False
+        self.__emit__('stop')
+        if self.__thread__:
+            self.__thread__.join()
+            self.__thread__ = None
+
+    def load(self, payload):
+        with self.__lock__:
+            self.__payload__ = payload
+
+    def done(self, payload):
+        self.__emit__('done', payload)
+
+    def __emit__(self, status='proceed', data=None):
+        scope = 'broadcast' if self.__channel__.broadcast else 'client'
+        body = {
+            'type': f'{scope}.emit',
+            'data': self.__channel__.to_dict(status, data or self.__payload__),
+            'clients': [self.client],
+            'users': []
         }
+        self.group_send(VALAR_CHANNEL_GROUP, body)
 
 
-    def to_users(self, payload,  users, status='proceed'):
-        body = self.__convert_body(emit='user.emit', payload=payload, status=status, users=users)
-        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+class ValarSocketSender(Sender):
+    def __init__(self, request: HttpRequest):
+        super().__init__(request)
+        if self.uid:
+            body = {'type': 'broadcast.emit', 'uid': self.uid, 'client': self.client}
+            self.group_send(VALAR_CHANNEL_GROUP, body)
 
-    def to_clients(self,payload, clients, status='proceed', wait=False):
-        current_time = time.time()
-        time_span = current_time - self.start_time
-        if (wait and time_span > 1 and status == 'proceed') or not wait:
-            body = self.__convert_body(emit='client.emit', payload=payload, status=status, clients=clients)
-            async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
-            self.start_time = current_time
+    def to_users(self, payload, users: list):
+        body = {'type': 'user.emit', 'data': payload, 'users': users}
+        self.group_send(VALAR_CHANNEL_GROUP, body)
 
-    def broadcast(self, payload, status):
-        body = self.__convert_body(emit='broadcast.emit', payload=payload, status=status)
-        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+    def to_clients(self, payload, clients: list):
+        body = {'type': 'client.emit', 'data': payload, 'clients': clients}
+        self.group_send(VALAR_CHANNEL_GROUP, body)
 
-    def register(self):
-        body = self.__convert_body(emit='register.emit',  payload=None, status=None,clients=[self.client], users=[self.uid])
-        async_to_sync(self.send)(VALAR_CHANNEL_GROUP, body)
+    def broadcast(self, payload):
+        body = {'type': 'broadcast.emit', 'data': payload}
+        self.group_send(VALAR_CHANNEL_GROUP, body)

valar/channels/views.py

@@ -1,12 +1,11 @@
-
 from .executer import execute_channel
 from .mapping import ChannelMapping
-from .sender import ValarSocketSender
+from .sender import ValarChannelSender
 from ..classes.valar_response import ValarResponse
 
 
 async def handel_channel(request, handler):
-    sender = ValarSocketSender(request)
+    sender = ValarChannelSender(request)
     method = ChannelMapping().get_handler(handler)
     await execute_channel(method, sender)
     return ValarResponse(True)

valar/classes/app_mixins/auto_migration_mixin.py

@@ -0,0 +1,8 @@
+class AutoMigrationMixin:
+    name = None  # 子类必须提供
+    def auto_migrate(self):
+        from django.core.management import call_command
+        app = self.name.replace('src.','')
+        call_command('makemigrations', app, interactive=False, verbosity=0)
+        call_command('migrate', app, interactive=False, verbosity=0)
+

valar/classes/{auto_urlpatterns_mixin.py → app_mixins/auto_urlpatterns_mixin.py}

@@ -3,13 +3,13 @@ import importlib
 from django.conf import settings
 from django.urls import path, include
 
+
 class AutoUrlPatternsMixin:
     name = None  # 子类必须提供
+
     def set_url(self):
         root = settings.ROOT_URLCONF
         module = importlib.import_module(root)
         urlpatterns: list = getattr(module, 'urlpatterns')
         url = f'{self.name}.urls'
-        urlpatterns.append(path('data/', include(url)))
-
-
+        urlpatterns.append(path('valar/', include(url)))

valar/classes/valar_minio.py

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

valar/classes/valar_response.py

@@ -1,7 +1,8 @@
 from django.http import JsonResponse
 
+
 class ValarResponse(JsonResponse):
-    def __init__(self, data, message='', code='info'):
+    def __init__(self, data=True, message='', code='info'):
         self.message = message
         self.code = code
         super(ValarResponse, self).__init__(data, safe=False)

valar/dao/__init__.py

@@ -0,0 +1,45 @@
+from ..dao.abstract import AbstractDao
+from ..dao.mon_dao import MonDao
+from ..dao.orm_dao import OrmDao
+
+
+class Dao(AbstractDao):
+
+    def __init__(self, entity, db='orm'):
+        self.dao = OrmDao(entity) if db == 'orm' else MonDao(entity)
+        self.db = db
+        self.entity = entity
+        self.name = self.dao.name
+        self.is_tree = self.dao.is_tree
+        self.fields = self.dao.fields
+        self.manager = self.dao.manager
+
+    def save_many(self, array: list):
+        self.dao.save_many(array)
+
+    def save_one(self, item, with_id=False):
+        return self.dao.save_one(item, with_id)
+
+    def delete_one(self, _id):
+        return self.dao.delete_one(_id)
+
+    def find_one(self, _id):
+        return self.dao.find_one(_id)
+
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        return self.dao.find(conditions, orders, size, page)
+
+    def values(self, conditions, props):
+        return self.dao.values(conditions, props)
+
+    def update(self, template, conditions):
+        return self.dao.update(template, conditions)
+
+    def delete(self, conditions=None) -> list:
+        return self.dao.delete(conditions)
+
+    def serialize(self, o, code=None):
+        return self.dao.serialize(o, code)
+
+    def tree(self, root, conditions=None):
+        return self.dao.tree(root, conditions)

valar/dao/abstract.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+
+from bson import ObjectId
+
+from ..dao.engine import ValarEngine
+
+
+class AbstractField(ABC):
+    db = None
+    entity = None
+    prop = None
+    label = None
+    domain = None
+    refer = None
+
+    @abstractmethod
+    def to_dict(self):
+        pass
+
+
+class AbstractDao(ABC):
+    engine = ValarEngine()
+    db = None
+    entity = None
+    name = None
+    is_tree = False
+    fields = {}
+
+    def props(self, domain=None):
+        return [prop for prop, field in self.fields.items() if field.domain == domain or domain is None]
+
+    def full_props(self):
+        return {
+            prop: {
+                "prop": prop,
+                "domain": field.domain,
+                "label": field.label,
+            }
+            for prop, field in self.fields.items()
+        }
+
+    def get_meta_field(self, prop) -> AbstractField:
+        return self.fields[prop]
+
+    @abstractmethod
+    def save_one(self, item, with_id=False):
+        pass
+
+    @abstractmethod
+    def save_many(self, array: list):
+        pass
+
+    @abstractmethod
+    def values(self, conditions, props):
+        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=None) -> list:
+        pass
+
+    @abstractmethod
+    def serialize(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 {}}]
+        results, _ = self.find(conditions, orders)
+        return results
+
+    def object_id(self, _id):
+        try:
+            return int(_id) if self.db == 'orm' else ObjectId(_id)
+        except Exception:
+            return None
+
+    # @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/dao/defaults/field_keys_default.py

@@ -0,0 +1,48 @@
+meta_field_key_defaults = {
+    'valar.Meta': {
+        'default': ('pick', ['db', 'entity', 'name', 'tree']),
+    },
+    'valar.MetaView': {
+        'list': ('pick', ['code', 'name']),
+        'core': ('pick', ['name', 'enable', 'lock', 'property']),
+        'style': ('pick', ['form_width', 'form_height', 'table_width', 'table_height']),
+        'rest': ('pick',
+                 ['allow_search', 'allow_order', 'allow_insert', 'allow_remove', 'allow_download', 'allow_upload']),
+        'edit': ('pick', ['allow_edit', 'allow_edit_on_form', 'allow_edit_on_cell', 'allow_edit_on_sort']),
+    },
+    'valar.MetaField': {
+        'tool': (
+            'pick',
+            [
+                'name', 'domain', 'tool', 'refer', 'format'
+            ]
+        ),
+        'rest': (
+            'pick',
+            [
+                'name', 'not_null',
+                'allow_edit', 'allow_sort', 'allow_search', 'allow_download', 'allow_upload', 'allow_update'
+            ]
+        ),
+        'table': (
+            'pick',
+            [
+                'name', 'unit', 'column_width', 'fixed', 'align', 'edit_on_table', 'hide_on_table',
+                'header_color', 'cell_color'
+            ]
+        ),
+        'form': (
+            'pick',
+            [
+                'name', 'span',
+                'hide_on_form', 'hide_on_form_insert', 'hide_on_form_edit', 'hide_on_form_branch', 'hide_on_form_leaf'
+            ]
+        ),
+    },
+    'vtest.Vala': {
+        'simple': ('pick', ['id', 'name', 'text_field', 'boolean_field', 'integer_field', 'float_field']),
+        'date': ('pick', ['id', 'name', 'date_field', 'datetime_field', 'time_field']),
+        'special': ('pick', ['id', 'name', 'text_field', 'json_field', 'file', 'm2m']),
+        'ref': ('pick', ['id', 'name', 'm2o', 'm2m', 'o2o_id']),
+    },
+}