lesscode-flask 0.0.84__tar.gz → 0.0.85__tar.gz

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.0.84
+Version: 0.0.85
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.0.84'
+__version__ = '0.0.85'
 
 import functools
 import logging

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask/app.py

@@ -63,18 +63,19 @@ class Lesscoder(Flask):
             # 获取URL 对应的id 与访问权限
             id, access = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hmget(f"upms:url_info:{url}",
                                                                                             ["id", "access"])
+            current_user = flask_login.current_user
             if not id:
                 # 如果没有进行注册的url 默认需要登录权限
                 access = app_config.get("AUTH_DEFAULT_ACCESS", "0")
             # '访问权限2：需要权限 1：需要登录 0：游客',
             if str(access) == "1":  # 需要登录
-                if flask_login.current_user.is_anonymous_user:
+                if current_user.is_anonymous_user:
                     # abort(403, "需要登录")
                     ResponseResult.fail("请登录后访问", status_code="403")
             elif str(access) == "2":  # 需要权限
-                if flask_login.current_user.is_anonymous_user:
+                if current_user.is_anonymous_user:
                     ResponseResult.fail("请登录后访问", status_code="403")
-                if not flask_login.current_user.has_permission(id):
+                if not current_user.has_permission(id):
                     ResponseResult.fail("请获取授权后访问", status_code="403")
         return super(Lesscoder, self).preprocess_request()
 

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask/log/access_log_handler.py

@@ -6,7 +6,6 @@ from logging import Handler
 from flask import request, copy_current_request_context
 
 from lesscode_flask.model.access_log import AccessLog
-from lesscode_flask.model.user import AnonymousUser, ApiUser
 from lesscode_flask.service.access_log_service import AccessLogService
 from lesscode_flask.utils.helpers import app_config
 from lesscode_flask.utils.redis.redis_helper import RedisHelper
@@ -55,16 +54,8 @@ class AccessLogHandler(Handler):
             flask_login = import_module("flask_login")
         except ImportError as e:
             raise Exception(f"flask_login is not exist,run:pip install Flask-Login==0.6.3")
-        '请求类型0:用户请求，1:API用户，2:匿名用户',
-        if isinstance(flask_login.current_user, AnonymousUser):
-            type = 2
-        elif isinstance(flask_login.current_user, ApiUser):
-            type = 1
-        else:
-            type = 0
-
         access_log = AccessLog(request_id=request_id, display_name=flask_login.current_user.display_name,
-                               obj_id=flask_login.current_user.id, type=type,
+                               obj_id=flask_login.current_user.id, type=flask_login.current_user.type,
                                resource_id=resource_id,
                                resource_label=resource_label, url=url, referrer=referrer, client_ip=client_ip,
                                user_agent=user_agent_string, start_time=start_time, end_time=end_time,

lesscode-flask-0.0.85/lesscode_flask/model/user.py

@@ -0,0 +1,218 @@
+from functools import reduce
+from importlib import import_module
+import json
+from urllib.parse import unquote
+
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+try:
+    flask_login = import_module("flask_login")
+except ImportError as e:
+    raise Exception(f"flask_login is not exist,run:pip install Flask-Login==0.6.3")
+
+
+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(flask_login.UserMixin, PermissionsCheckMixin):
+    """
+    在线用户对象类
+    """
+
+    def __init__(self, id="AnonymousUserId", username="AnonymousUser", display_name="匿名用户", phone_no: str = None,
+                 email: str = None,
+                 type: int = 0, account_status: str = None, permissions=[], permissions_url=[], client_id: str = None):
+        # '账号id',
+        self.id = id
+        # 用户名
+        self.username = username
+        # '显示名',
+        self.display_name = display_name
+        # 手机号,
+        self.phone_no = phone_no
+        #  邮箱
+        self.email = email
+        # 用户类型 0：匿名用户，1：普通用户，2：API用户，3:客户端用户
+        self.type = type
+        # # 组织机构id',
+        # self.org_id = org_id
+        # '1正常（激活）；2未激活（管理员新增，首次登录需要改密码）； 3锁定（登录错误次数超限，锁定时长可配置）； 4休眠（长期未登录（字段，时长可配置），定时） 5禁用-账号失效；
+        self.account_status = account_status
+        # 当前用户登录成功的客户端id'
+        self.client_id = client_id
+        # 权限集合(symbol)
+        self.permissions = permissions
+        # 权限集合(url)
+        self.permissions_url = permissions_url
+        # # 角色集合
+        # self.roleIds = roleIds
+
+    #
+    def is_anonymous_user(self):
+        """
+        判断是否是匿名用户
+        :return:
+        """
+        return self.type == 0
+
+    def is_user(self):
+        """
+        判断是否是普通用户
+        :return:
+        """
+        return self.type == 1
+
+    def is_api_user(self):
+        """
+        判断是否是API用户
+        :return:
+        """
+        return self.type == 2
+
+    def is_client_user(self):
+        """
+        判断是否是客户端用户
+        :return:
+        """
+        return self.type == 3
+
+    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},type={self.type},"
+                f"account_status={self.account_status},permissions={self.permissions},client_id={self.client_id})")
+
+    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},type={self.type},"
+                f"account_status={self.account_status},permissions={self.permissions},client_id={self.client_id})")
+
+    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 "",
+            "type": self.type if self.type else "",
+            "account_status": self.account_status,
+            "permissions": json.dumps(self.permissions)
+        }
+
+    @staticmethod
+    def to_user(user_data):
+        if not isinstance(user_data, dict):
+            user_data = user_data.__dict__
+        return User(id=user_data.get("id"), username=user_data.get("username", ""),
+                    display_name=user_data.get("display_name", ""), phone_no=user_data.get("phone_no", ""),
+                    email=user_data.get("email", ""), type=user_data.get("type", 0),
+                    account_status=user_data.get("account_status", 1), permissions=user_data.get("permissions", []),
+                    client_id=user_data.get("client_id", ""))
+
+    @staticmethod
+    def get_user(request):
+        # 使用token访问的用户
+        if app_config.get("GATEWAY_USER_ENABLE"):
+            user_json = request.headers.get("User", "")
+            if user_json:
+                return User.get_gateway_user(user_json)
+        # 使用token访问的用户
+        authorization = request.headers.get("Authorization", "")
+        if "Bearer " in authorization:
+            token = request.headers.get("Authorization", "").replace("Bearer ", "")
+            if token:
+                return User.get_token_user(token)
+        apikey = request.headers.get("app_key")
+        if apikey:
+            # 使用AK访问的接口用户
+            return User.get_api_user(apikey)
+        # 无任何用户信息返回 匿名用户
+        return User()
+
+    @staticmethod
+    def get_gateway_user(user_json):
+        """
+        网关传输信息中获取用户信息
+        :param apikey:
+        :return:
+        """
+        if user_json:
+            user_dict = json.loads(user_json)
+            if user_dict and isinstance(user_dict, dict):
+                if type(user_dict["roleIds"]) == str:
+                    user_dict["roleIds"] = json.loads(user_dict["roleIds"])
+                user = User(
+                    id=user_dict["id"],
+                    username=user_dict["username"],
+                    display_name=unquote(user_dict["display_name"]),
+                    phone_no=user_dict["phone_no"],
+                    permissions=user_dict.get("permissions", []),
+                    roleIds=user_dict["roleIds"],
+                    client_id=user_dict["client_id"]
+                )
+                return user
+        return User()
+
+    @staticmethod
+    def get_token_user(token):
+        """
+        根据token获取用户信息。
+
+        该函数通过Redis缓存来获取用户信息。如果在缓存中找到了对应的用户数据，
+        则会创建一个User对象并返回；如果没有找到，则返回一个AnonymousUser对象。
+
+        参数:
+        - token (str): 用户的令牌。
+
+        返回:
+        - User: 如果找到了用户信息，则返回一个User对象。
+        - AnonymousUser: 如果没有找到用户信息，则返回一个AnonymousUser对象。
+        """
+        # 生成用户缓存键
+        user_cache_key = f"oauth2:user:{token}"
+
+        # 从Redis中获取用户数据
+        user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(user_cache_key)
+
+        # 检查是否获取到了用户数据
+        if user_dict:
+            # 创建并返回User对象
+            user = User(
+                id=user_dict.get("id"),
+                username=user_dict.get("username"),
+                display_name=user_dict.get("display_name"),
+                phone_no=user_dict.get("phone_no"),
+                email=user_dict.get("email"),
+                permissions=json.loads(user_dict.get("permissions")) if user_dict.get(
+                    "permissions") is not None else [],
+                client_id=user_dict.get("client_id")
+            )
+            return user
+        return User()
+
+    @staticmethod
+    def get_api_user(apikey):
+        """
+        使用API key 获取用户信息
+        :param apikey:
+        :return:
+        """
+        cache_key = f"oauth2:user:{apikey}"
+        # 优先从缓存中获取
+        user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(cache_key)
+        if user_dict:
+            user = User.to_user(user_dict)
+            return user
+        return User()
+

lesscode-flask-0.0.85/lesscode_flask/service/authentication_service.py

@@ -0,0 +1,106 @@
+import json
+from urllib.parse import unquote
+
+
+from lesscode_flask.model.user import User
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+
+class LoadUser():
+
+    @staticmethod
+    def get_user(request):
+        # 使用token访问的用户
+        if app_config.get("GATEWAY_USER_ENABLE"):
+            user_json = request.headers.get("User", "")
+            if user_json:
+                return LoadUser.get_gateway_user(user_json)
+        # 使用token访问的用户
+        authorization = request.headers.get("Authorization", "")
+        if "Bearer " in authorization:
+            token = request.headers.get("Authorization", "").replace("Bearer ", "")
+            if token:
+                return LoadUser.get_token_user(token)
+        apikey = request.headers.get("app_key")
+        if apikey:
+            # 使用AK访问的接口用户
+            return LoadUser.get_api_user(apikey)
+        # 无任何用户信息返回 匿名用户
+        return User()
+
+    @staticmethod
+    def get_gateway_user(user_json):
+        """
+        网关传输信息中获取用户信息
+        :param apikey:
+        :return:
+        """
+        if user_json:
+            user_dict = json.loads(user_json)
+            if user_dict and isinstance(user_dict, dict):
+                if type(user_dict["roleIds"]) == str:
+                    user_dict["roleIds"] = json.loads(user_dict["roleIds"])
+                user = User(
+                    id=user_dict["id"],
+                    username=user_dict["username"],
+                    display_name=unquote(user_dict["display_name"]),
+                    phone_no=user_dict["phone_no"],
+                    permissions=user_dict.get("permissions", []),
+                    roleIds=user_dict["roleIds"],
+                    client_id=user_dict["client_id"]
+                )
+                return user
+        return User()
+
+    @staticmethod
+    def get_token_user(token):
+        """
+        根据token获取用户信息。
+
+        该函数通过Redis缓存来获取用户信息。如果在缓存中找到了对应的用户数据，
+        则会创建一个User对象并返回；如果没有找到，则返回一个AnonymousUser对象。
+
+        参数:
+        - token (str): 用户的令牌。
+
+        返回:
+        - User: 如果找到了用户信息，则返回一个User对象。
+        - AnonymousUser: 如果没有找到用户信息，则返回一个AnonymousUser对象。
+        """
+        # 生成用户缓存键
+        user_cache_key = f"oauth2:user:{token}"
+
+        # 从Redis中获取用户数据
+        user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(user_cache_key)
+
+        # 检查是否获取到了用户数据
+        if user_dict:
+            # 创建并返回User对象
+            user = User(
+                id=user_dict.get("id"),
+                username=user_dict.get("username"),
+                display_name=user_dict.get("display_name"),
+                phone_no=user_dict.get("phone_no"),
+                email=user_dict.get("email"),
+                permissions=json.loads(user_dict.get("permissions")) if user_dict.get(
+                    "permissions") is not None else [],
+                client_id=user_dict.get("client_id")
+            )
+            return user
+        return User()
+
+    @staticmethod
+    def get_api_user(apikey):
+        """
+        使用API key 获取用户信息
+        :param apikey:
+        :return:
+        """
+        cache_key = f"oauth2:user:{apikey}"
+        # 优先从缓存中获取
+        user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(cache_key)
+        if user_dict:
+            user = User.to_user(user_dict)
+            return user
+        return User()

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask/setup/__init__.py

@@ -10,8 +10,6 @@ from lesscode_flask import download_func_dict
 from lesscode_flask.db import db
 from lesscode_flask.export_data.data_download_handler import convert_page, format_to_table_download, upload_result_url
 from lesscode_flask.log.access_log_handler import AccessLogHandler
-from lesscode_flask.model.user import AnonymousUser
-from lesscode_flask.service.authentication_service import get_token_user, get_api_user, get_gateway_user
 from lesscode_flask.utils.swagger.swagger_template import split_doc
 from lesscode_flask.utils.swagger.swagger_util import generate_openapi_spec, replace_symbol, get_params_type, \
     get_sample_data
@@ -138,23 +136,7 @@ def setup_login_manager(app):
 
     @login_manager.request_loader
     def request_loader(request):
-        # 使用token访问的用户
-        if app.config.get("GATEWAY_USER_ENABLE"):
-            user_json = request.headers.get("User", "")
-            if user_json:
-                return get_gateway_user(user_json)
-        # 使用token访问的用户
-        authorization = request.headers.get("Authorization", "")
-        if "Bearer " in authorization:
-            token = request.headers.get("Authorization", "").replace("Bearer ", "")
-            if token:
-                return get_token_user(token)
-        apikey = request.headers.get("app_key")
-        if apikey:
-            # 使用AK访问的接口用户
-            return get_api_user(apikey)
-        # 无任何用户信息返回 匿名用户
-        return AnonymousUser()
+        return LoadUser.get_user(request)
 
 
 def setup_swagger(app):

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask/utils/thread/thread_utils.py

@@ -4,7 +4,7 @@ from typing import List
 from flask import copy_current_request_context
 
 
-class MyThread:
+class FlaskThread:
     def __init__(self, target, args=None, kwargs=None):
         self.target = target
         self.args = args or []
@@ -36,7 +36,7 @@ def wrapper(_func, _args, _kwargs, _result: list = None, _lock=None, _is_throw_e
     return _thread_func
 
 
-def run_in_thread(func_list: List[MyThread], is_throw_error=False, is_lock=True):
+def run_in_thread(func_list: List[FlaskThread], is_throw_error=False, is_lock=True):
     results = []
     threads = []
     result_locks = []
@@ -63,12 +63,15 @@ def run_in_thread(func_list: List[MyThread], is_throw_error=False, is_lock=True)
 
     final_results = []
     for result, lock in zip(results, result_locks):
-        with lock:
+        if is_lock:
+            with lock:
+                final_results.append(result[0])
+        else:
             final_results.append(result[0])
     return final_results
 
 
-def run_in_background(func_list: List[MyThread], is_throw_error=False, is_lock=False):
+def run_in_background(func_list: List[FlaskThread], is_throw_error=False, is_lock=False):
     thread = threading.Thread(target=wrapper(_func=run_in_thread,
                                              _args=[],
                                              _kwargs=dict(func_list=func_list, is_throw_error=is_throw_error,

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.0.84
+Version: 0.0.85
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy

{lesscode-flask-0.0.84 → lesscode-flask-0.0.85}/lesscode_flask.egg-info/SOURCES.txt

@@ -15,15 +15,11 @@ lesscode_flask/export_data/__init__.py
 lesscode_flask/export_data/data_download_handler.py
 lesscode_flask/log/access_log_handler.py
 lesscode_flask/model/access_log.py
-lesscode_flask/model/auth_client.py
-lesscode_flask/model/auth_permission.py
 lesscode_flask/model/base_model.py
 lesscode_flask/model/parameterized_query.py
 lesscode_flask/model/response_result.py
 lesscode_flask/model/user.py
 lesscode_flask/service/access_log_service.py
-lesscode_flask/service/auth_client_service.py
-lesscode_flask/service/auth_permission_service.py
 lesscode_flask/service/authentication_service.py
 lesscode_flask/service/base_service.py
 lesscode_flask/setting/__init__.py

lesscode-flask-0.0.84/lesscode_flask/model/auth_client.py

@@ -1,42 +0,0 @@
-# # coding: utf-8
-# from lesscode_flask.model.base_model import BaseModel, JSONEncodedDict, DatetimeEncodedString
-# from lesscode_flask.utils.helpers import generate_uuid
-# from sqlalchemy import Column, DateTime, Integer, JSON, text, Text, String, Float, BigInteger
-#
-#
-# class AuthClient(BaseModel):
-#     __tablename__ = 'lc_auth_client'
-#     __table_args__ = {'comment': '客户端信息表'}
-#     __bind_key__ = 'auth_db'
-#
-#     id = Column(String(36), primary_key=True, comment='主键', insert_default=generate_uuid)
-#     client_name = Column(String(255), comment='系统名称')
-#     app_key = Column(String(64), nullable=False, unique=True, comment='用于唯一标识每一个客户端')
-#     secret_key = Column(String(256), comment='用于指定客户端(client)的访问密匙')
-#     scope = Column(String(256), comment='指定客户端申请的权限范围,可选值包括read,write,trust')
-#     authorized_grant_types = Column(String(256),
-#                                     comment='指定客户端支持的grant_type,可选值包括authorization_code,password,refresh_token,implicit,client_credentials, 若支持多个grant_type用逗号(,)分隔')
-#     redirect_uris = Column(String(256), comment='客户端的重定向uri,可为空, 当grant_type为authorization_code或implicit时')
-#     logout_redirect_uri = Column(String(255), comment='客户端登出重定向uri')
-#     access_token_validity = Column(Integer,
-#                                    comment='设定客户端的access_token的有效时间值(单位:秒),可选, 若不设定值则使用默认的有效时间值(60 * 60 * 12, 12小时)')
-#     refresh_token_validity = Column(Integer,
-#                                     comment='设定客户端的refresh_token的有效时间值(单位:秒),可选, 若不设定值则使用默认的有效时间值(60 * 60 * 24 * 30, 30天)')
-#     autoapprove = Column(String(256), comment='设置用户是否自动approval操作, 默认值为 false, 可选值包括 true,false, read,write')
-#     response_types = Column(String(255))
-#     serial_index = Column(Float(11, True), comment='排序字段')
-#     client_id_issued_at = Column(BigInteger)
-#     client_secret_expires_at = Column(BigInteger)
-#     token_expires_in = Column(Integer, default=3600)
-#     description = Column(String(255), comment='描述')
-#     is_enable = Column(Integer, nullable=False, default=1, comment='1:可用，0:禁用')
-#     is_deleted = Column(Integer, nullable=False, default=0, comment='1:删除，0:未删除')
-#     create_user_id = Column(String(36), nullable=False, comment='创建人id')
-#     create_user_name = Column(String(36), nullable=False, comment='创建人用户名')
-#     modify_user_id = Column(String(36), comment='修改人id')
-#     modify_user_name = Column(String(36), comment='修改人用户名')
-#     create_time = Column(DatetimeEncodedString(), server_default=text("CURRENT_TIMESTAMP"), comment='创建时间')
-#     modify_time = Column(DatetimeEncodedString(), comment='修改时间')
-#     service_export = Column(String(255), comment='服务出口,例如：https://chanyeos.com')
-#     is_only_one = Column(Integer, default=1, comment='1：互踢，0：不互踢')
-#     metadata_ = Column('metadata', JSONEncodedDict())

lesscode-flask-0.0.84/lesscode_flask/model/auth_permission.py

@@ -1,25 +0,0 @@
-# # coding: utf-8
-# from lesscode_flask.model.base_model import BaseModel
-# from lesscode_flask.utils.helpers import generate_uuid
-# from sqlalchemy import Column, DateTime, Integer, JSON, text, Text, String, Float, BigInteger
-#
-#
-# class AuthPermission(BaseModel):
-#     __tablename__ = 'lc_auth_permissions'
-#     __table_args__ = {'comment': '权限表（用户、角色、应用-资源关系表）'}
-#     __bind_key__ = 'auth_db'
-#
-#     id = Column(String(36), primary_key=True, insert_default=generate_uuid)
-#     user_id = Column(String(36), comment='用户id')
-#     role_id = Column(String(36), comment='角色id')
-#     client_id = Column(String(36), comment='客户端id')
-#     type = Column(Integer, comment='0:角色资源，1:客户端资源，2:用户资源')
-#     resource_id = Column(String(36), comment='资源id')
-#     expires_at = Column(Integer, comment='资源失效时间')
-#     validator = Column(JSON, comment='验证数据')
-#     create_user_id = Column(String(36), nullable=False, comment='创建人id')
-#     create_user_name = Column(String(36), nullable=False, comment='创建人用户名')
-#     modify_user_id = Column(String(36), comment='修改人id')
-#     modify_user_name = Column(String(36), comment='修改人用户名')
-#     create_time = Column(DateTime, server_default=text("CURRENT_TIMESTAMP"), comment='创建时间')
-#     modify_time = Column(DateTime, comment='修改时间')

lesscode-flask-0.0.84/lesscode_flask/model/user.py

@@ -1,136 +0,0 @@
-from functools import reduce
-from importlib import import_module
-import json
-
-# from flask_login import AnonymousUserMixin, UserMixin
-try:
-    flask_login = import_module("flask_login")
-except ImportError as e:
-    raise Exception(f"flask_login is not exist,run:pip install Flask-Login==0.6.3")
-
-
-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(flask_login.UserMixin, PermissionsCheckMixin):
-    """
-    在线用户对象类
-    """
-
-    def __init__(self, id, username: str = None, display_name: str = None, phone_no: str = None, email: str = None,
-                 type: int = 0, account_status: str = None, permissions=[], client_id: str = None):
-        # '账号id',
-        self.id = id
-        # 用户名
-        self.username = username
-        # '显示名',
-        self.display_name = display_name
-        # 手机号,
-        self.phone_no = phone_no
-        #  邮箱
-        self.email = email
-        # 用户类型 0：匿名用户，1：普通用户，2：API用户，3:客户端用户
-        self.type = type
-        # # 组织机构id',
-        # self.org_id = org_id
-        # '1正常（激活）；2未激活（管理员新增，首次登录需要改密码）； 3锁定（登录错误次数超限，锁定时长可配置）； 4休眠（长期未登录（字段，时长可配置），定时） 5禁用-账号失效；
-        self.account_status = account_status
-        # 当前用户登录成功的客户端id'
-        self.client_id = client_id
-        # 权限集合
-        self.permissions = permissions
-        # # 角色集合
-        # self.roleIds = roleIds
-
-    #
-    #
-    # @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},type={self.type},"
-                f"account_status={self.account_status},permissions={self.permissions},client_id={self.client_id})")
-
-    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},type={self.type},"
-                f"account_status={self.account_status},permissions={self.permissions},client_id={self.client_id})")
-
-    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 "",
-            "type": self.type if self.type else "",
-            "account_status": self.account_status,
-            "permissions": json.dumps(self.permissions)
-        }
-    @staticmethod
-    def to_user(user_data):
-        if not isinstance(user_data, dict):
-            user_data = user_data.__dict__
-        return  User(id=user_data.get("id"), username=user_data.get("username",""), display_name=user_data.get("display_name",""),phone_no=user_data.get("phone_no",""),email=user_data.get("email",""),type=user_data.get("type",0),account_status=user_data.get("account_status",1),permissions=user_data.get("permissions",[]),client_id=user_data.get("client_id",""))
-
-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-0.0.84/lesscode_flask/service/auth_client_service.py

@@ -1,7 +0,0 @@
-# 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-0.0.84/lesscode_flask/service/auth_permission_service.py

@@ -1,7 +0,0 @@
-# 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-0.0.84/lesscode_flask/service/authentication_service.py

@@ -1,97 +0,0 @@
-import json
-from urllib.parse import unquote
-
-# from lesscode_flask.model.auth_client import AuthClient
-# from lesscode_flask.model.auth_permission import AuthPermission
-from lesscode_flask.model.user import ApiUser, User, AnonymousUser
-# 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_gateway_user(user_json):
-    """
-    网关传输信息中获取用户信息
-    :param apikey:
-    :return:
-    """
-    if user_json:
-        user_dict = json.loads(user_json)
-        if user_dict and isinstance(user_dict, dict):
-            if type(user_dict["roleIds"]) == str:
-                user_dict["roleIds"] = json.loads(user_dict["roleIds"])
-            user = User(
-                id=user_dict["id"],
-                username=user_dict["username"],
-                display_name=unquote(user_dict["display_name"]),
-                phone_no=user_dict["phone_no"],
-                permissions=user_dict.get("permissions",[]),
-                roleIds=user_dict["roleIds"],
-                client_id=user_dict["client_id"]
-            )
-            return user
-    return AnonymousUser()
-
-
-def get_token_user(token):
-    """
-    根据token获取用户信息。
-
-    该函数通过Redis缓存来获取用户信息。如果在缓存中找到了对应的用户数据，
-    则会创建一个User对象并返回；如果没有找到，则返回一个AnonymousUser对象。
-
-    参数:
-    - token (str): 用户的令牌。
-
-    返回:
-    - User: 如果找到了用户信息，则返回一个User对象。
-    - AnonymousUser: 如果没有找到用户信息，则返回一个AnonymousUser对象。
-    """
-    # 生成用户缓存键
-    user_cache_key = f"oauth2:user:{token}"
-
-    # 从Redis中获取用户数据
-    user_dict = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hgetall(user_cache_key)
-
-    # 检查是否获取到了用户数据
-    if user_dict:
-        # 创建并返回User对象
-        user = User(
-            id=user_dict.get("id"),
-            username=user_dict.get("username"),
-            display_name=user_dict.get("display_name"),
-            phone_no=user_dict.get("phone_no"),
-            email=user_dict.get("email"),
-            permissions=json.loads(user_dict.get("permissions")) if user_dict.get("permissions") is not None else [],
-            client_id=user_dict.get("client_id")
-        )
-        return user
-    # 如果没有获取到用户数据，返回AnonymousUser对象
-    return AnonymousUser()
-
-
-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 AnonymousUser()