lesscode-flask 0.0.27__py3-none-any.whl

lesscode_flask/model/parameterized_query.py

@@ -0,0 +1,210 @@
+import re
+from functools import partial
+from numbers import Number
+
+import pystache
+from dateutil.parser import parse
+from funcy import distinct
+
+from lesscode_flask.utils.helpers import mustache_render
+
+
+def _pluck_name_and_value(default_column, row):
+    row = {k.lower(): v for k, v in row.items()}
+    name_column = "name" if "name" in row.keys() else default_column.lower()
+    value_column = "value" if "value" in row.keys() else default_column.lower()
+
+    return {"name": row[name_column], "value": str(row[value_column])}
+
+
+# def _load_result(query_id, org):
+#     from redash import models
+#
+#     query = models.Query.get_by_id_and_org(query_id, org)
+#
+#     if query.data_source:
+#         query_result = models.QueryResult.get_by_id_and_org(query.latest_query_data_id, org)
+#         return query_result.data
+#     else:
+#         raise QueryDetachedFromDataSourceError(query_id)
+
+
+def dropdown_values(query_id, org):
+    data = [] # load_result(query_id, org)
+    first_column = data["columns"][0]["name"]
+    pluck = partial(_pluck_name_and_value, first_column)
+    return list(map(pluck, data["rows"]))
+
+
+def join_parameter_list_values(parameters, schema):
+    updated_parameters = {}
+    for key, value in parameters.items():
+        if isinstance(value, list):
+            definition = next((definition for definition in schema if definition["name"] == key), {})
+            multi_values_options = definition.get("multiValuesOptions", {})
+            separator = str(multi_values_options.get("separator", ","))
+            prefix = str(multi_values_options.get("prefix", ""))
+            suffix = str(multi_values_options.get("suffix", ""))
+            updated_parameters[key] = separator.join([prefix + v + suffix for v in value])
+        else:
+            updated_parameters[key] = value
+    return updated_parameters
+
+
+def _collect_key_names(nodes):
+    keys = []
+    for node in nodes._parse_tree:
+        if isinstance(node, pystache.parser._EscapeNode):
+            keys.append(node.key)
+        elif isinstance(node, pystache.parser._SectionNode):
+            keys.append(node.key)
+            keys.extend(_collect_key_names(node.parsed))
+
+    return distinct(keys)
+
+
+def _collect_query_parameters(query):
+    nodes = pystache.parse(query)
+    keys = _collect_key_names(nodes)
+    return keys
+
+
+def _parameter_names(parameter_values):
+    names = []
+    for key, value in parameter_values.items():
+        if isinstance(value, dict):
+            for inner_key in value.keys():
+                names.append("{}.{}".format(key, inner_key))
+        else:
+            names.append(key)
+
+    return names
+
+
+def _is_number(string):
+    if isinstance(string, Number):
+        return True
+    else:
+        float(string)
+        return True
+
+
+def _is_regex_pattern(value, regex):
+    try:
+        if re.compile(regex).fullmatch(value):
+            return True
+        else:
+            return False
+    except re.error:
+        return False
+
+
+def _is_date(string):
+    parse(string)
+    return True
+
+
+def _is_date_range(obj):
+    return _is_date(obj["start"]) and _is_date(obj["end"])
+
+
+def _is_value_within_options(value, dropdown_options, allow_list=False):
+    if isinstance(value, list):
+        return allow_list and set(map(str, value)).issubset(set(dropdown_options))
+    return str(value) in dropdown_options
+
+
+class ParameterizedQuery:
+    def __init__(self, template, schema=None, org=None):
+        self.schema = schema or []
+        self.template = template
+        self.query = template
+        self.parameters = {}
+
+    def apply(self, parameters):
+        invalid_parameter_names = [key for (key, value) in parameters.items() if not self._valid(key, value)]
+        if invalid_parameter_names:
+            raise InvalidParameterError(invalid_parameter_names)
+        else:
+            self.parameters.update(parameters)
+            self.query = mustache_render(self.template, **join_parameter_list_values(parameters, self.schema))
+
+        return self
+
+    def _valid(self, name, value):
+        if not self.schema:
+            return True
+
+        definition = next(
+            (definition for definition in self.schema if definition["name"] == name),
+            None,
+        )
+
+        if not definition:
+            return False
+
+        enum_options = definition.get("enumOptions")
+        query_id = definition.get("queryId")
+        regex = definition.get("regex")
+        allow_multiple_values = isinstance(definition.get("multiValuesOptions"), dict)
+
+        if isinstance(enum_options, str):
+            enum_options = enum_options.split("\n")
+
+        validators = {
+            "text": lambda value: isinstance(value, str),
+            "text-pattern": lambda value: _is_regex_pattern(value, regex),
+            "number": _is_number,
+            "enum": lambda value: _is_value_within_options(value, enum_options, allow_multiple_values),
+            "query": lambda value: _is_value_within_options(
+                value,
+                [v["value"] for v in dropdown_values(query_id, self.org)],
+                allow_multiple_values,
+            ),
+            "date": _is_date,
+            "datetime-local": _is_date,
+            "datetime-with-seconds": _is_date,
+            "date-range": _is_date_range,
+            "datetime-range": _is_date_range,
+            "datetime-range-with-seconds": _is_date_range,
+        }
+
+        validate = validators.get(definition["type"], lambda x: False)
+
+        try:
+            # multiple error types can be raised here; but we want to convert
+            # all except QueryDetached to InvalidParameterError in `apply`
+            return validate(value)
+        except QueryDetachedFromDataSourceError:
+            raise
+        except Exception:
+            return False
+
+    @property
+    def is_safe(self):
+        text_parameters = [param for param in self.schema if param["type"] == "text"]
+        return not any(text_parameters)
+
+    @property
+    def missing_params(self):
+        query_parameters = set(_collect_query_parameters(self.template))
+        return set(query_parameters) - set(_parameter_names(self.parameters))
+
+    @property
+    def text(self):
+        return self.query
+
+
+class InvalidParameterError(Exception):
+    def __init__(self, parameters):
+        parameter_names = ", ".join(parameters)
+        message = "The following parameter values are incompatible with their definitions: {}".format(parameter_names)
+        super(InvalidParameterError, self).__init__(message)
+
+
+class QueryDetachedFromDataSourceError(Exception):
+    def __init__(self, query_id):
+        self.query_id = query_id
+        super(QueryDetachedFromDataSourceError, self).__init__(
+            "This query is detached from any data source. Please select a different query."
+        )

lesscode_flask/model/response_result.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+import json
+from datetime import datetime
+
+from flask import Response, abort
+
+
+class ResponseResult(dict):
+    """
+    ResponseResult 类用于统一包装数据返回格式
+    """
+
+    def __init__(self, status_code=("00000", "请求成功"), data=""):
+        """
+
+        :param status_code:
+        :param data:
+        """
+        super(ResponseResult, self).__init__()
+        # 业务请求状态编码
+        self["status"] = status_code[0]
+        # 返回状态码对应的说明信息
+        self["message"] = status_code[1]
+        # 返回数据对象 主对象 指定类型
+        self["data"] = data
+        # 时间戳
+        self["timestamp"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
+
+    @staticmethod
+    def make_response(message: str, data="", status_code="00000", http_code=200):
+        data = json.dumps(ResponseResult(status_code=(status_code, message), data=data))
+        respone = Response(data)
+        respone.content_type = "application/json"
+        respone.status_code = http_code
+        return respone
+
+    @staticmethod
+    def success(data,message: str=None):
+        """
+        成功返回结果
+        :param data:
+        :param message:
+        :return:
+        """
+        if message:
+            return ResponseResult(data=data, status_code=("00000", message))
+        return ResponseResult(data=data)
+
+    @staticmethod
+    def fail(message: str, data="", status_code="99999", http_code=200):
+        """
+        失败返回结果
+        :param message:
+        :param data:
+        :param status_code:
+        :param http_code:
+        :return:
+        """
+        respone = ResponseResult.make_response(message, data, status_code, http_code)
+        abort(respone)

lesscode_flask/model/user.py

@@ -0,0 +1,118 @@
+from functools import reduce
+
+from flask_login import AnonymousUserMixin, UserMixin
+
+
+class PermissionsCheckMixin:
+    def has_permission(self, permission):
+        return self.has_permissions((permission,))
+
+    def has_permissions(self, permissions):
+        has_permissions = reduce(
+            lambda a, b: a and b,
+            [permission in self.permissions for permission in permissions],
+            True,
+        )
+
+        return has_permissions
+
+
+class User(UserMixin, PermissionsCheckMixin):
+    """
+    用户对象类
+    """
+
+    def __init__(self, id, username: str = None, display_name: str = None, phone_no: str = None, email: str = None,
+                 org_id: str = None,
+                 account_status: str = None, permissions=None):
+        # '账号id',
+        self.id = id
+        # 用户名
+        self.username = username
+        # '显示名',
+        self.display_name = display_name
+        # 手机号,
+        self.phone_no = phone_no
+        #  邮箱
+        self.email = email
+        # 组织机构id',
+        self.org_id = org_id
+        # '1正常（激活）；2未激活（管理员新增，首次登录需要改密码）； 3锁定（登录错误次数超限，锁定时长可配置）； 4休眠（长期未登录（字段，时长可配置），定时） 5禁用-账号失效；
+        self.account_status = account_status
+        # 权限集合
+        self.permissions = permissions
+
+    @staticmethod
+    def is_api_user():
+        return False
+
+    @staticmethod
+    def is_anonymous_user():
+        return False
+
+    def __str__(self):
+        return (f"User(id={self.id},username={self.username},phone_no={self.phone_no},"
+                f"display_name={self.display_name},email={self.email},org_id={self.org_id},"
+                f"account_status={self.account_status},permissions={self.permissions})")
+
+    def __repr__(self):
+        return (f"User(id={self.id},username={self.username},phone_no={self.phone_no},"
+                f"display_name={self.display_name},email={self.email},org_id={self.org_id},"
+                f"account_status={self.account_status},permissions={self.permissions})")
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "username": self.username,
+            "display_name": self.display_name,
+            "phone_no": self.phone_no,
+            "email": self.email if self.email else "",
+            "org_id": self.org_id if self.org_id else "",
+            "account_status": self.account_status,
+            "permissions": ",".join(self.permissions)
+        }
+
+
+class AnonymousUser(User):
+    """
+    匿名用户
+    """
+
+    def __init__(self, permissions=None):
+        super(AnonymousUser, self).__init__("AnonymousUserId", "AnonymousUser", "匿名用户", "-", "-", None, 1, permissions)
+
+    @staticmethod
+    def is_api_user():
+        return False
+
+    @staticmethod
+    def is_anonymous_user():
+        return True
+
+
+class ApiUser(User):
+    def __init__(self, id, username: str = None, display_name: str = None,
+                 permissions=None):
+        super(ApiUser, self).__init__(id, username, display_name, "-", "-", None, 1, permissions)
+
+    @staticmethod
+    def is_api_user():
+        return True
+
+    @staticmethod
+    def to_obj(_user):
+        user = ApiUser(_user.get("id"))
+        for key, value in _user.items():
+            if isinstance(key, bytes):
+                key = key.decode('utf-8')
+            if isinstance(value, bytes):
+                value = value.decode('utf-8')
+            if key == "permissions":
+                user.permissions = value.split(",")
+            elif key == "org_id":
+                user.org_id = value if value else None
+            elif key == "account_status":
+                user.account_status = int(value)
+            else:
+                setattr(user, key, value)
+        return user

lesscode_flask/service/access_log_service.py

@@ -0,0 +1,8 @@
+
+from lesscode_flask.model.access_log import AccessLog
+from lesscode_flask.service.base_service import BaseService
+
+
+class AccessLogService(BaseService):
+    def __init__(self):
+        super().__init__(AccessLog)

lesscode_flask/service/auth_client_service.py

@@ -0,0 +1,7 @@
+from lesscode_flask.model.auth_client import AuthClient
+from lesscode_flask.service.base_service import BaseService
+
+
+class AuthClientService(BaseService):
+    def __init__(self):
+        super().__init__(AuthClient)

lesscode_flask/service/auth_permission_service.py

@@ -0,0 +1,7 @@
+from lesscode_flask.model.auth_permission import AuthPermission
+from lesscode_flask.service.base_service import BaseService
+
+
+class AuthPermissionService(BaseService):
+    def __init__(self):
+        super().__init__(AuthPermission)

lesscode_flask/service/authentication_service.py

@@ -0,0 +1,67 @@
+from lesscode_flask.model.auth_client import AuthClient
+from lesscode_flask.model.auth_permission import AuthPermission
+from lesscode_flask.model.user import ApiUser, User
+from lesscode_flask.service.auth_client_service import AuthClientService
+from lesscode_flask.service.auth_permission_service import AuthPermissionService
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+
+def get_token_user(token):
+    """
+    使用API key 获取用户信息
+    :param apikey:
+    :return:
+    """
+    token_cache_key = f"oauth2:token:{token}"
+    # 优先从缓存中获取
+    access_token = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(token_cache_key)
+    # {
+    #     'client_id': 'eYC0lOd1XVBBPpdDntMwFcPg',
+    #     'token_type': 'Bearer',
+    #     'access_token': 'Rsh1zS9QVzMAefB5G7be04CefK5opjiOCBtBS8BYYi',
+    #     'refresh_token': 'la5jb14acszPARoDf1KtH24JjnswSYUsjH4NbsQxOsvpO4Dl',
+    #     'scope': 'profile',
+    #     'issued_at': 1645614957,
+    #     'expires_in': 3600,
+    #     'user_id': 21,
+    #     'clientId': "",
+    #     "grant_type": "",
+    #     "is_only_one": "1",
+    #     "only_type": "pc"
+    # }
+    if access_token:
+        user_id = access_token.get("user_id")
+        clientId = access_token.get("client_id")
+        user_cache_key = f"oauth2:client_user_info:client_id:{clientId}:user_id:{user_id}"
+        user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(user_cache_key)
+        if user_dict:
+            user = User(user_id, user_dict["username"], user_dict["display_name"], user_dict["permissions"])
+            return user
+    return None
+
+
+def get_api_user(apikey):
+    """
+    使用API key 获取用户信息
+    :param apikey:
+    :return:
+    """
+    cache_key = f"oauth2:apikey_user_info:{apikey}"
+    # 优先从缓存中获取
+    user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(cache_key)
+    if user_dict:
+        user = ApiUser.to_obj(user_dict)
+        return user
+    else:
+        # 库里查询
+        authClient = AuthClientService().get_one([AuthClient.client_id == apikey])
+        if authClient:
+            authPermission = AuthPermissionService().get_items([AuthPermission.client_id == authClient.id])
+            permissions = [permission.resource_id for permission in authPermission]
+            user = ApiUser(authClient.id, authClient.client_id, authClient.client_name, permissions)
+            RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hset(cache_key,
+                                                                              mapping=user.to_dict(),
+                                                                              time=authClient.token_expires_in)
+            return user
+    return None

lesscode_flask/service/base_service.py

@@ -0,0 +1,138 @@
+import logging
+
+from flask_login import current_user
+from lesscode_flask.db import db
+from lesscode_flask.model.base_model import BaseModel
+from lesscode_flask.utils.helpers import serialize_result_to_dict, parameter_validation
+
+logger = logging.getLogger(__name__)
+
+
+class BaseService:
+
+    def __init__(self, model):
+        self.model = model
+
+    @staticmethod
+    def add_item(item: BaseModel):
+        """
+        添加数据
+        :param item: 待添加数据对象
+        :return:
+        """
+
+        # try:
+        #
+        # except AttributeError:
+        #     current_user = None
+        try:
+            if hasattr(item, "create_user_id"):
+                item.create_user_id = current_user.id
+            if hasattr(item, "create_user_name"):
+                item.create_user_name = current_user.display_name
+        except Exception as e:
+            if hasattr(item, "create_user_id"):
+                item.create_user_id = "AnonymousUserId"
+            if hasattr(item, "create_user_name"):
+                item.create_user_name = "匿名用户"
+        db.session.add(item)
+        db.session.commit()
+        return item.id
+
+    def add_items(self, items: list):
+        """
+        添加数据
+        :param items: 待添加数据对象集合
+        :return:
+        """
+        for item in items:
+            try:
+                if hasattr(item, "create_user_id"):
+                    item.create_user_id = current_user.id
+                if hasattr(item, "create_user_name"):
+                    item.create_user_name = current_user.display_name
+            except Exception as e:
+                if hasattr(item, "create_user_id"):
+                    item.create_user_id = "AnonymousUserId"
+                if hasattr(item, "create_user_name"):
+                    item.create_user_name = "匿名用户"
+        db.session.execute(
+            self.model.__table__.insert(),
+            items
+        )
+        db.session.commit()
+        return items
+
+    def update_item(self, id: str, item: dict):
+
+        try:
+            if hasattr(self.model, "modify_user_id"):
+                item["modify_user_id"] = current_user.id
+            if hasattr(self.model, "modify_user_name"):
+                item["modify_user_name"] = current_user.display_name
+        except Exception as e:
+            if hasattr(item, "modify_user_id"):
+                item.create_user_id = "AnonymousUserId"
+            if hasattr(item, "modify_user_name"):
+                item.create_user_name = "匿名用户"
+        self.model.query.filter_by(id=id).update(parameter_validation(item))
+        db.session.commit()
+        return id
+
+    def get_item(self, id: str):
+        """
+        获取单条信息
+        :param id:
+        :return:
+        """
+        item = self.model.query.get(id)
+        return item
+
+    def get_one(self, filters: list):
+        """
+        获取单条信息
+        :param filters:
+        :return:
+        """
+        query = self.model.query
+        if filters:
+            query = query.filter(*filters)
+        item = query.one()
+        return item
+
+    def get_items(self, filters: list = None):
+        """
+        获取列表信息
+        :param filters:
+        :return:
+        """
+        query = self.model.query
+        if filters:
+            query = query.filter(*filters)
+        items = query.all()
+        return items
+
+    def delete_item(self, id: str):
+        self.model.query.filter_by(id=id).delete()
+        return id
+
+    def delete_items(self, filters: list):
+        if filters and len(filters) > 0:
+            self.model.query.filter(*filters).delete()
+        return id
+
+    def page(self, columns: [], filters: list = None, page_num: int = 1, page_size: int = 10):
+        query = self.model.query
+        if filters:
+            query = query.filter(*filters)
+        pagination = query.paginate(page=page_num, per_page=page_size)
+        # 获取当前页的数据
+        items = pagination.items
+        # 获取分页信息
+        total = pagination.total
+        has_prev = pagination.has_prev
+        has_next = pagination.has_next
+        result = {"columns": columns, "dataSource": serialize_result_to_dict(items), "total": total,
+                  "has_prev": has_prev,
+                  "has_next": has_next}
+        return result