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

valar/__init__.py

@@ -1,26 +0,0 @@
-from django.http import JsonResponse, HttpRequest
-from django.utils.deprecation import MiddlewareMixin
-
-class ValarResponse(JsonResponse):
-    def __init__(self, data, message='', code='info'):
-        self.message = message
-        self.code = code
-        super(ValarResponse, self).__init__(data, safe=False)
-
-
-class Middleware(MiddlewareMixin):
-    @staticmethod
-    def process_response(request: HttpRequest, response: ValarResponse):
-        headers = response.headers
-        if type(response)==ValarResponse:
-            message, code = response.message, response.code
-            headers['valar_message'] = message
-            headers['valar_code'] = code
-
-        keys = ['client','auth','uid']
-        for key in keys:
-            value = request.headers.get(key)
-            if value:
-                headers[key] = value
-
-        return response

valar/channels/__init__.py

@@ -1,107 +1 @@
-import json
-from datetime import datetime
-
-from asgiref.sync import async_to_sync
-from channels.layers import get_channel_layer
-
-from channels.generic.websocket import AsyncJsonWebsocketConsumer, JsonWebsocketConsumer
-from django.conf import settings
-from django.http import HttpRequest
-
-try:
-    GROUP = settings.VALAR_CHANNEL_GROUP_NAME
-except AttributeError:
-    GROUP = 'VALAR'
-
-class ValarSocketSender:
-    def __init__(self, request: HttpRequest):
-        body = json.loads(request.body)
-        client = request.headers.get('CLIENT')
-        auth = request.headers.get('AUTH')
-        uid = request.session.get('UID')
-        if auth and not uid:
-            raise Exception('Unauthorized!')
-        self.client = client
-        self.uid = uid
-        self.handlerKey = body.get('handlerKey')
-        self.channelKey = body.get('channelKey', 'default')
-        self.send = get_channel_layer().group_send
-
-
-
-    def __convert_body(self, emit, data, status ,clients = None, users = None):
-        return {
-            'type': emit,
-            'data': {
-                'status': status,
-                'handlerKey': self.handlerKey,
-                'channelKey': self.channelKey,
-                'payload': data,
-                'timestamp': datetime.now().timestamp()
-            },
-            'clients': clients or [],
-            'users': users or [],
-        }
-
-
-    def to_users(self, data,  users, status='proceed'):
-        body = self.__convert_body(emit='user.emit', data=data, status=status, users=users)
-        async_to_sync(self.send)(GROUP, body)
-
-    def to_clients(self,data, clients, status='proceed'):
-        body = self.__convert_body(emit='client.emit', data=data, status=status, clients=clients)
-        async_to_sync(self.send)(GROUP, body)
-
-
-    def broadcast(self, data, status):
-        body = self.__convert_body(emit='broadcast.emit', data=data, status=status)
-        async_to_sync(self.send)(GROUP, body)
-
-    def register(self):
-        body = self.__convert_body(emit='register.emit',  data=None, status=None,clients=[self.client], users=[self.uid])
-        async_to_sync(self.send)(GROUP, body)
-
-class ValarConsumer(AsyncJsonWebsocketConsumer):
-
-    def __init__(self):
-        self.client = None
-        self.uid = None
-        super().__init__()
-
-    async def connect(self):
-        params = self.scope['url_route']['kwargs']
-        self.client = params.get('client')
-        await self.channel_layer.group_add(GROUP, self.channel_name)
-        await self.accept()
-
-    async def disconnect(self, code):
-        await self.channel_layer.group_discard(GROUP, self.channel_name)
-        await self.close(code)
-
-    async def receive_json(self, data, *args, **kwargs):
-        pass
-
-    async def user_emit(self, event):
-        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',{})
-        if self.client in clients:
-            await self.send_json(data)
-
-    async def broadcast_emit(self, event):
-        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]
-
-
+VALAR_CHANNEL_GROUP = 'VALAR'

valar/channels/consumer.py

@@ -0,0 +1,48 @@
+
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+
+from ..channels import VALAR_CHANNEL_GROUP
+
+class ValarConsumer(AsyncJsonWebsocketConsumer):
+
+    def __init__(self):
+        self.client = None
+        self.uid = None
+        super().__init__()
+
+    async def connect(self):
+        params = self.scope['url_route']['kwargs']
+        self.client = params.get('client')
+        await self.channel_layer.group_add(VALAR_CHANNEL_GROUP, self.channel_name)
+        await self.accept()
+
+    async def disconnect(self, code):
+        await self.channel_layer.group_discard(VALAR_CHANNEL_GROUP, self.channel_name)
+        await self.close(code)
+
+    async def receive_json(self, data, *args, **kwargs):
+        pass
+
+    async def user_emit(self, event):
+        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',{})
+        if self.client in clients:
+            await self.send_json(data)
+
+    async def broadcast_emit(self, event):
+        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]
+
+

valar/channels/executer.py

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

valar/channels/mapping.py

@@ -0,0 +1,21 @@
+import importlib
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+class ChannelMapping:
+    def __init__(self):
+        root = settings.ROOT_URLCONF
+        module = importlib.import_module(root)
+        name = 'channel_mapping'
+        if hasattr(module, name):
+            self.mapping: dict = getattr(module, name)
+        else:
+            raise ImproperlyConfigured("%r has no attribute %r" % (root, name))
+
+    def get_handler(self, handler):
+        method = self.mapping.get(handler)
+        if method is None:
+            raise ImproperlyConfigured("Cannot find handler - %r" % handler)
+        return method
+

valar/channels/sender.py

@@ -0,0 +1,60 @@
+import json
+import time
+from datetime import datetime
+
+from asgiref.sync import async_to_sync
+from channels.layers import get_channel_layer
+from django.http import HttpRequest
+
+from ..channels import VALAR_CHANNEL_GROUP
+
+
+class ValarSocketSender:
+    def __init__(self, request: HttpRequest, data=None):
+        body = json.loads(request.body)
+        auth = request.headers.get('AUTH')
+        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:
+            raise Exception('Unauthorized!')
+
+
+    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 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)
+
+    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 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 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)

valar/channels/views.py

@@ -1,17 +1,12 @@
-import json
 
-from .utils import execute_channel, get_channel_handler
-from .. import ValarResponse
-from ..channels import ValarSocketSender
+from .executer import execute_channel
+from .mapping import ChannelMapping
+from .sender import ValarSocketSender
+from ..core.response import ValarResponse
 
 
 async def handel_channel(request, handler):
-    method = get_channel_handler(handler)
-    body = json.loads(request.body)
-    data = body.get('data')
     sender = ValarSocketSender(request)
-    await execute_channel(method, data, sender)
+    method = ChannelMapping().get_handler(handler)
+    await execute_channel(method, sender)
     return ValarResponse(True)
-
-
-

valar/core/counter.py

@@ -0,0 +1,9 @@
+class Counter:
+    def __init__(self, array_or_int):
+        self.length = array_or_int if isinstance(array_or_int,int) else len(array_or_int)
+        self.index = 0
+
+    def tick(self):
+        self.index += 1
+        percentage = round(self.index * 100 / self.length)
+        return {"index": self.index, "length": self.length, "percentage": percentage}

valar/core/dao/_mon_array2tree.py

@@ -0,0 +1,18 @@
+def array2tree(data, mapping):
+    mapping = mapping or {}
+    lookup = {}
+    for array in data:
+        for i in range(len(array)):
+            key = '/'.join(array[0:i+1])
+            item = mapping.get(key, {})
+            value = item.get('value', array[i])
+            label = item.get('label', value)
+            display = item.get('display')
+            item = lookup.get(key, {'value': value,'label':label,'display':display})
+            if i < len(array) -1:
+                item['children'] = item.get('children', [])
+            lookup[key] = item
+            if i > 0:
+                parent =   '/'.join(array[0:i])
+                lookup[parent]['children'].append(lookup[key])
+    return [lookup[root] for root in [*set([array[0] for array in data])]]

valar/core/dao/dao_base.py

@@ -0,0 +1,50 @@
+from .dao_mon import MonDao
+from .dao_orm import OrmDao
+from ..dao_abstract import AbstractDao
+
+
+class Dao(AbstractDao):
+
+    def __init__(self, entity, db='orm'):
+        self.entity = entity
+        self.db = db
+        self.dao: AbstractDao = OrmDao(entity) if db == 'orm' else MonDao(entity)
+
+    def get_model(self):
+        self.dao.get_model()
+
+    def save_one(self, item):
+        return self.dao.save_one(item)
+
+    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 update(self, template, conditions):
+        return self.dao.update(template, conditions)
+
+    def delete(self, conditions):
+        return self.dao.delete(conditions)
+
+    def transform(self, o, code=None):
+        return self.dao.transform(o)
+
+    def tree(self, root, conditions=None):
+        return self.dao.tree(conditions, root)
+
+
+
+    # def values(self, props, conditions, orders=None):
+    #     pass
+    #
+    # def group(self, props, conditions, orders=None):
+    #     pass
+    #
+    # def count(self, props, conditions):
+    #     pass
+

valar/core/dao/dao_mon.py

@@ -0,0 +1,76 @@
+from pymongo.results import InsertOneResult
+from pymongo.synchronous.cursor import Cursor
+
+from .engine import DaoEngine
+from .model_mon import MonModel
+from .query_mon import MonQuery
+from ..dao_abstract import AbstractDao
+
+
+class MonDao(AbstractDao):
+    def __init__(self, entity):
+        self.entity = entity
+        engine = DaoEngine().mon
+        self.model:MonModel = engine.get_model(entity)
+        self.objects = self.model.manager
+
+    def get_model(self):
+        return self.model
+
+    def save_one(self, item):
+        oid, item = self.model.detach_item(item)
+        if oid:
+            self.objects.update_one({'_id': oid}, {'$set': item})
+        else:
+            bean: InsertOneResult = self.objects.insert_one(item)
+            oid = bean.inserted_id
+            self.objects.update_one({'_id': oid}, {'$set': {'sort': str(oid)}})
+        return self.objects.find_one({'_id': oid})
+
+    def delete_one(self, _id):
+        oid = self.model.object_id(_id)
+        flag = False
+        if oid:
+            self.objects.delete_one({'_id': oid})
+            flag = True
+        return flag
+
+    def find_one(self, _id):
+        oid = self.model.object_id(_id)
+        return self.objects.find_one({'_id': oid}) if oid else None
+
+    def find(self, conditions=None, orders=None, size=0, page=1):
+        query = MonQuery(conditions, orders)
+        skip = (page - 1) * size
+        total = self.objects.count_documents(query.finder)
+        cursor = self.objects.find(query.finder, query.orders).skip(skip)
+        if size:
+            cursor = cursor.limit(size)
+        return cursor, total
+
+    def update(self, template, conditions):
+        if template and len(template.keys()):
+            oid, item = self.model.detach_item(template)
+            query = MonQuery(conditions)
+            self.objects.update_many(query.finder, {'$set': item})
+            return True
+        return False
+
+    def delete(self, conditions):
+        query = MonQuery(conditions)
+        self.objects.delete_many(query.finder)
+
+    def transform(self, o, code=None):
+        if isinstance(o, Cursor):
+            return [__to_item__(doc) for doc in o]
+        else:
+            return __to_item__(o)
+
+    def tree(self, root, conditions=None):
+        pass
+
+
+def __to_item__(o):
+    o['id'] = str(o['_id'])
+    del o['_id']
+    return o

valar/core/dao/dao_orm.py

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

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

@@ -0,0 +1,90 @@
+
+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}/*"
+            }
+        ]})