fred-admin 1.0.0__py3-none-any.whl

fred_admin/__init__.py

@@ -0,0 +1,91 @@
+import importlib
+import os
+from pathlib import Path
+
+from flask import Flask
+from flask_cors import CORS
+
+from fred_admin.common.RuntimeHook import apply_project_hook
+from fred_admin.common.Blueprints import Blueprints
+from fred_admin.common.Extensions import Extensions
+from fred_admin.common.HandleExcetion import HandleException
+from fred_admin.common.Response import Response
+from fred_admin.common.Route import Route
+from fred_admin.common.Swagger import Swagger
+from fred_admin.common.Utils import Utils
+from fred_admin.config.Config import Config
+from fred_admin.config.Logger import Logger
+
+def create_app():
+    """
+    创建应用
+    """
+    apply_project_hook()  # 发现项目根并应用 src/modules path + iter_modules patch，便于正确加载蓝图
+    app = Flask(__name__)
+    
+    app.config.from_object(Config)
+    # 尝试加载自定义配置，支持 config/Config.py 或 common/config/Config.py
+    # 优先使用 common.config.Config，因为安装框架后 config.Config 可能解析到框架自身
+    config_paths = ['common.config.Config', 'config.Config']
+    config_loaded = False
+    framework_config_file = str(Path(__file__).parent / 'config' / 'Config.py')
+    for config_path in config_paths:
+        try:
+            config_module = importlib.import_module(config_path)
+            Custom_Config = getattr(config_module, 'Config')
+            # 检查是否是框架自身的配置文件（避免误加载）
+            module_file = getattr(config_module, '__file__', '')
+            if module_file and os.path.normpath(module_file) == os.path.normpath(framework_config_file):
+                continue  # 跳过框架自身的配置
+            app.config.from_object(Custom_Config)
+            config_msg = f"加载自定义Config ({config_path}),自定义配置会覆盖默认配置"
+            config_loaded = True
+            break
+        except (ImportError, AttributeError):
+            continue
+    if not config_loaded:
+        config_msg = "没有配置自定义Config"
+    app.config['SECRET_KEY'] = Utils.get_secret_key('session_secret_key',app)
+    if app.config['ENCRYPT_DATA']:  # 如果启用数据加密才生成fernet_key
+        app.config['FERNET_KEY'] = Utils.get_secret_key('fernet_key',app)
+    # 配置app.logger
+    Logger.set_logger(app)
+    app.logger.info(config_msg)
+    
+    # 初始化组件
+    Extensions(app).initialize_extensions()
+    
+    # 注册蓝图
+    Blueprints(app).register_blueprints()
+    
+    # Swagger（/docs、/doc 等）必须在 Route 的 SPA 通配符 /<path:path> 之前注册，
+    # 否则 /docs 会被首页路由当成前端路由并返回 index.html，而不是 Swagger UI。
+    Swagger(app)
+    
+    # 前端静态资源与 SPA 通配路由
+    Route(app).set_routes()
+    # 全局异常处理
+    if app.config.get('ENABLE_GLOBAL_EXCEPTION', True):
+        HandleException(app)
+    # 重新定义模板文件路径
+    
+    # 自定义输出格式
+    Response().custom_response(app)
+    
+    if app.debug:
+        app.logger.info("开启debug模式，并允许跨域请求")
+        CORS(app, supports_credentials=True)
+    
+    return app
+
+
+def main():
+    """
+    主函数，用于启动应用
+    """
+    app = create_app()
+    app.run()
+
+
+if __name__ == '__main__':
+    main()

fred_admin/common/AliyunSms.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""  
+@author: cyg  
+@date: 2024/7/28 下午10:35  
+"""
+# -*- coding: utf-8 -*-
+from flask import current_app
+
+
+class AliyunSms:
+	"""
+		发送短信
+	"""
+	
+	@staticmethod
+	def create_client():
+		"""
+		使用AK&SK初始化账号Client
+		@param access_key_id:
+		@param access_key_secret:
+		@return: Client
+		@throws Exception
+		"""
+		key_id = current_app.config.get("ALIBABA_KEY_ID", "")
+		if key_id == '':
+			return None
+		from alibabacloud_dysmsapi20170525.client import Client as Dysmsapi20170525Client
+		from alibabacloud_tea_openapi import models as open_api_models
+		config = open_api_models.Config(
+			access_key_id=current_app.config.get("ALIBABA_KEY_ID"),
+			access_key_secret=current_app.config.get("ALIBABA_KEY_SECRET")
+		)
+		# 访问的域名
+		config.endpoint = f'dysmsapi.aliyuncs.com'
+		return Dysmsapi20170525Client(config)
+	
+	@staticmethod
+	def send_code(phone, code):
+		"""
+		发送短信验证码
+		:param phone:手机号
+		:param code: 验证码 （4位数字）
+		:return: bool
+		"""
+		client = AliyunSms.create_client()
+		if client is None:
+			raise Exception("请先配置短信配置信息")
+		from alibabacloud_dysmsapi20170525 import models as dysmsapi_20170525_models
+		from alibabacloud_tea_util import models as util_models
+		from alibabacloud_tea_util.client import Client as UtilClient
+		send_sms_request = dysmsapi_20170525_models.SendSmsRequest(
+			sign_name=current_app.config.get("ALIBABA_SIGN_NAME"),
+			template_code=current_app.config.get("ALIBABA_TEMPLATE_CODE"),
+			phone_numbers=phone,
+			template_param='{"code":"' + code + '"}'
+		)
+		try:
+			result = client.send_sms_with_options(send_sms_request, util_models.RuntimeOptions())
+			code = result.to_map()['body']['Code']
+			if code != "OK":
+				raise Exception("发送失败！")
+			return True
+		except Exception as error:
+			UtilClient.assert_as_string(str(error))
+			return False

fred_admin/common/Blueprints.py

@@ -0,0 +1,99 @@
+"""
+ * @Author：cyg
+ * @Package：Blueprints
+ * @Project：Default (Template) Project
+ * @name：Blueprints
+ * @Date：2024/12/16 11:42
+ * @Filename：自动注册蓝图
+"""
+import importlib
+import pkgutil
+from pathlib import Path
+
+import flask_smorest
+from flask import Blueprint
+
+from fred_admin.common.Response import Response
+from fred_admin.common.Utils import Utils
+
+
+class Blueprints:
+	def __init__(self, app):
+		"""
+		初始化 BlueprintManager 类
+		:param app: Flask 应用对象
+		"""
+		self.app = app
+		self.blp = flask_smorest.Api(app)
+	
+	def register_blueprints(self):
+		"""
+		自动注册蓝图
+		"""
+		self.app.logger.info("开始自动加载蓝图...")
+		self.blp.spec.components.security_scheme("Authorization", {"type": "http", "scheme": "bearer"})
+		self.blp.spec.options["security"] = [{"Authorization": []}]
+		self.blp.spec.components.schema('Response', schema=Response)
+		registered_blueprints = set()
+		self.__method_name("", registered_blueprints)
+		# 仅仅优化swagger显示内容
+		Response().swagger_responses(self.blp.spec.to_dict(), self.blp.spec.components.schemas)
+		
+		if registered_blueprints:
+			self.app.logger.info(f"蓝图加载完成，共注册 {len(registered_blueprints)} 个蓝图:")
+			for blueprint_name in sorted(registered_blueprints):
+				self.app.logger.info(f"  - {blueprint_name}")
+		else:
+			self.app.logger.warning("未加载任何蓝图")
+		return self.blp
+	
+	def __method_name(self, app_directory, registered_blueprints):
+		new_app_directory = ""
+		if app_directory != "":
+			new_app_directory = app_directory + '.'
+		modules_found = list(pkgutil.iter_modules([app_directory]))
+		for _, module_name, is_pkg in modules_found:
+			# 跳过非Python模块文件，例如setup.py
+			if module_name in ['setup', 'pyproject']:
+				continue
+			# 动态导入模块
+			try:
+				module_path = f'{new_app_directory}{module_name}'.replace('app.', 'fred_admin.')
+				module = importlib.import_module(module_path)
+				for attr_name in dir(module):
+					if attr_name.startswith('__'):
+						continue
+					attr = getattr(module, attr_name)
+					modules = self.app.config.get('LOAD_CUSTOM_MODULES', None)
+					if isinstance(modules, list) and len(modules) == 0:
+						modules = None
+					if new_app_directory == "" and modules != None and attr_name not in modules:
+						continue
+					if isinstance(attr, Blueprint) and attr.name not in registered_blueprints:
+						# 自动导入模块的子模块（service、schema、constant等）
+						self.__auto_import_submodules(module)
+						controller_path = f'{new_app_directory}{attr.name}.controller'.replace('app.', 'fred_admin.')
+						Utils.import_controller(controller_path)
+						self.blp.register_blueprint(attr)
+						registered_blueprints.add(attr.name)
+						self.app.logger.info(f"成功注册蓝图: {attr.name} (模块: {new_app_directory}{module_name})")
+			except Exception as e:
+				self.app.logger.warning(f"加载模块 {new_app_directory}{module_name} 时出错: {str(e)}")
+
+	def __auto_import_submodules(self, module):
+		"""
+		自动导入模块的子模块（排除 controller，由框架单独加载）
+		:param module: 父模块对象
+		"""
+		try:
+			module_dir = Path(module.__file__).parent
+			for _, submodule_name, is_pkg in pkgutil.iter_modules([str(module_dir)]):
+				# 跳过 controller（由框架单独加载）和私有模块
+				if submodule_name.startswith('_') or submodule_name == 'controller':
+					continue
+				try:
+					importlib.import_module(f'.{submodule_name}', module.__package__)
+				except Exception:
+					pass  # 子模块导入失败不影响主流程
+		except Exception:
+			pass  # 获取模块路径失败不影响主流程

fred_admin/common/Email.py

@@ -0,0 +1,23 @@
+"""
+ * @Author：cyg
+ * @Package：email
+ * @Project：Default (Template) Project
+ * @name：email
+ * @Date：2024/10/22 14:32
+ * @Filename：email
+"""
+from fred_admin.common.Extensions import Extensions
+
+
+class Email:
+	
+	def send_mail(self, mail_address, title, content):
+		from flask_mail import Message
+		msg = Message(title, recipients=[mail_address])
+		msg.body = content
+		msg.html = '<b>' + content + '</b>'
+		try:
+			Extensions().mail.send(msg)
+			return 'Email sent!'
+		except Exception as e:
+			raise Exception(f'Error sending email: {str(e)}')

fred_admin/common/Extensions.py

@@ -0,0 +1,319 @@
+"""
+ * @Author：cyg
+ * @Package：Extensions
+ * @Project：Default (Template) Project
+ * @name：Extensions
+ * @Date：2024/12/16 11:35
+ * @Filename：使用的组件
+"""
+
+from flask import request
+import sys
+import importlib
+
+from fred_admin.common.Sqlacodegen import Sqlacodegen
+from fred_admin.common.Utils import Utils
+from flask_babelplus import Babel, Domain
+import os
+
+class Extensions:
+	def __init__(self, app=None):
+		self.app = app
+
+	# 加载依赖并初始化扩展
+
+	def load_requirements(self):
+		"""
+		加载依赖包列表
+
+		默认加载所有支持的依赖包，用于扩展检测。
+		"""
+		# 直接返回默认的依赖列表，不检查 requirements.txt 文件
+		default_requirements = [
+			'flask',
+			'flask_cors',
+			'flask_jwt_extended',
+			'flask_smorest',
+			'flask_swagger_ui',
+			'flask_apscheduler',
+			'flask_babelplus',
+			'flask_sqlalchemy',
+			'flask_mail',
+			'redis',
+			'pymysql',
+			'cryptography',
+			'pillow',
+			'requests',
+			'pytz'
+		]
+		return default_requirements
+
+	def _extract_package_name(self, requirement: str) -> str:
+		"""
+		从依赖字符串中提取包名
+
+		支持格式：
+		- flask>=3.1.2
+		- flask==3.1.2
+		- flask~=3.1.2
+		- flask
+		- flask-cors>=6.0.1
+		- flask[extra]>=3.1.2
+
+		Args:
+			requirement: 依赖字符串
+
+		Returns:
+			str: 提取的包名，如果无法提取则返回空字符串
+		"""
+		import re
+
+		# 移除方括号中的额外依赖，如 flask[extra] -> flask
+		package = re.sub(r'\[.*?\]', '', requirement)
+
+		# 使用正则表达式匹配版本操作符
+		# 支持 >=, ==, ~=, >, <, <=, != 等操作符
+		version_pattern = r'[><=!~]+'
+		parts = re.split(version_pattern, package)
+
+		# 取第一部分作为包名
+		package_name = parts[0].strip()
+
+		return package_name if package_name else ''
+
+	def initialize_extensions(self):
+		"""
+		初始化已加载的扩展。
+
+		根据 requirements.txt 中的依赖包自动初始化对应的扩展。
+		使用字典映射方式，提高代码可维护性和可读性。
+		"""
+		requirements = self.load_requirements()
+
+		# 扩展初始化映射表：包名 -> 初始化方法
+		extension_map = {
+			'flask_sqlalchemy': self.__initialize_db,
+			'flask_mail': self.__initialize_mail,
+			'flask_babelplus': self.__initialize_babel,
+			'flask_apscheduler': self.__initialize_scheduler,
+			'flask_jwt_extended': self.__initialize_jwt,
+			'redis': self.__initialize_redis,
+		}
+
+		# 遍历映射表，检查依赖并初始化扩展
+		for package_name, init_func in extension_map.items():
+			if package_name in requirements:
+				init_func()
+
+	def __initialize_models(self):
+		Sqlacodegen().create_models(self.app)
+
+	def __initialize_scheduler(self):
+		"""初始化定时任务扩展"""
+		from flask_apscheduler import APScheduler
+		from fred_admin.common.SchedulerLog import SchedulerLog
+
+		scheduled = APScheduler()
+		if self.app.config.get('JOBS'):
+			# 包装所有定时任务函数，添加日志记录功能
+			# 注意：必须在 scheduled.init_app() 之前完成包装，否则 APScheduler 会使用原始函数引用
+			original_jobs = self.app.config.get('JOBS', [])
+
+			# 在应用上下文中执行包装，确保能正确访问 current_app
+			# 传递 app 实例，确保定时任务执行时能正确获取应用上下文
+			with self.app.app_context():
+				wrapped_jobs = SchedulerLog.wrap_jobs_in_config(original_jobs, app=self.app)
+
+			# 更新配置中的任务列表
+			self.app.config['JOBS'] = wrapped_jobs
+
+			# 在包装完成后初始化调度器
+			# 这样 APScheduler 会使用包装后的函数
+			scheduled.init_app(self.app)
+			scheduled.start()
+
+	def __initialize_jwt(self):
+		"""初始化 JWT 扩展"""
+		from flask import jsonify
+		from flask_jwt_extended import JWTManager
+		jwt = JWTManager()
+		self.app.config['JWT_SECRET_KEY'] = Utils.get_secret_key('jwt_secret_key', self.app)
+		jwt.init_app(self.app)
+
+		@jwt.invalid_token_loader
+		def invalid_token_callback(error_string):
+			"""Token 无效（签名错误、格式错误等）→ 401"""
+			return jsonify({"message": f"Token 无效：{error_string}"}), 401
+
+		@jwt.unauthorized_loader
+		def unauthorized_callback(error_string):
+			"""未提供 Token → 401"""
+			return jsonify({"message": f"缺少访问令牌：{error_string}"}), 401
+
+		@jwt.expired_token_loader
+		def expired_token_callback(jwt_header, jwt_payload):
+			"""Token 已过期 → 401"""
+			return jsonify({"message": "Token 已过期，请重新获取"}), 401
+
+		@jwt.token_verification_failed_loader
+		def token_verification_failed_callback(jwt_header, jwt_payload):
+			"""Token 验证失败 → 401"""
+			return jsonify({"message": "Token 验证失败"}), 401
+
+		@jwt.revoked_token_loader
+		def revoked_token_callback(jwt_header, jwt_payload):
+			"""Token 已被撤销 → 401"""
+			return jsonify({"message": "Token 已被撤销"}), 401
+
+	def __initialize_babel(self):
+		"""初始化 Babel 国际化扩展"""
+
+		# 获取配置的翻译目录
+		translation_dir = self.app.config.get('BABEL_TRANSLATION_DIRECTORIES', None)
+
+		# 如果配置了翻译目录，创建自定义Domain
+		default_domain = None
+		if translation_dir:
+			# 构建绝对路径
+			if os.path.isabs(translation_dir):
+				# 已经是绝对路径
+				translation_path = translation_dir
+			else:
+				# 相对于 app.root_path
+				translation_path = os.path.join(self.app.root_path, translation_dir)
+			default_domain = Domain(dirname=translation_path)
+
+		babel = Babel()
+		# 必须配置默认语言
+		if self.app.config.get('BABEL_DEFAULT_LOCALE'):
+			babel.init_app(self.app, default_domain=default_domain)
+
+			@babel.localeselector
+			def get_locale():
+				supported_languages = self.app.config.get('SUPPORTED_LANGUAGES')
+				default_locale = self.app.config.get('BABEL_DEFAULT_LOCALE')
+				# 如果浏览器发送的是 zh，直接映射到 zh
+				locale = request.accept_languages.best_match(supported_languages, default_locale)
+				return locale or default_locale
+
+	def __initialize_db(self):
+		"""初始化数据库扩展。仅当配置了 SQLALCHEMY_DATABASE_URI 时自动生成并加载 model/model.py。"""
+		# 先确定 PROJECT_ROOT（供 Sqlacodegen 输出路径及 get_secret_key 等使用）
+		if "PROJECT_ROOT" not in self.app.config or not self.app.config.get("PROJECT_ROOT"):
+			from pathlib import Path
+			model_dir = self.app.config.get("MODEL_DIR", "common/model")
+			cwd = Path.cwd()
+			if (cwd / model_dir / "model.py").exists():
+				self.app.config["PROJECT_ROOT"] = str(cwd)
+			else:
+				potential_root = Path(self.app.root_path).parent
+				if (potential_root / model_dir / "model.py").exists():
+					self.app.config["PROJECT_ROOT"] = str(potential_root)
+				elif (Path(self.app.root_path) / model_dir / "model.py").exists():
+					self.app.config["PROJECT_ROOT"] = str(self.app.root_path)
+				else:
+					self.app.config["PROJECT_ROOT"] = str(cwd)
+
+		if not self.app.config.get("SQLALCHEMY_DATABASE_URI"):
+			return
+
+		# 有 DB URI：先自动生成 model/model.py，再加载并初始化 db
+		self.__initialize_models()
+
+		try:
+			Utils.import_project_models("db", app=self.app)
+			from model.model import db
+
+			# 确保在应用上下文中初始化 db
+			# 这样可以避免 "The current Flask app is not registered with this 'SQLAlchemy' instance" 错误
+			with self.app.app_context():
+				# 检查 db 是否已经注册到 Flask app
+				if hasattr(db, 'get_app'):
+					registered_app = db.get_app()
+					if registered_app is not None:
+						# 如果已经注册，检查是否是当前 app
+						if registered_app is not self.app:
+							# 如果注册到了其他 app，重新初始化
+							db.init_app(self.app)
+				else:
+					# 如果 db 没有 get_app 方法，直接初始化
+					db.init_app(self.app)
+
+			# 确保 db 实例被注册到 app.extensions
+			# 这样其他地方可以通过 app.extensions['sqlalchemy'] 访问
+			if 'sqlalchemy' not in self.app.extensions:
+				self.app.extensions['sqlalchemy'] = db
+			else:
+				existing_db = self.app.extensions['sqlalchemy']
+				if existing_db is not db:
+					self.app.extensions['sqlalchemy'] = db
+
+			# 确保标准的 model.model 模块使用已初始化的 db 实例
+			# 这样可以避免 "The current Flask app is not registered with this 'SQLAlchemy' instance" 错误
+			if 'model.model' in sys.modules:
+				standard_model_module = sys.modules['model.model']
+				# 如果标准模块中的 db 实例不是当前初始化的实例，则替换
+				if hasattr(standard_model_module, 'db') and standard_model_module.db is not db:
+					setattr(standard_model_module, 'db', db)
+
+			# 额外检查：确保所有可能导入 model.model 的地方都能使用已初始化的 db
+			# 遍历 sys.modules，查找所有可能包含 db 的模块
+			for module_name in list(sys.modules.keys()):
+				if 'model' in module_name.lower():
+					try:
+						module = sys.modules[module_name]
+						if hasattr(module, 'db'):
+							# 检查是否是 SQLAlchemy 实例
+							from flask_sqlalchemy import SQLAlchemy
+							if isinstance(module.db, SQLAlchemy):
+								# 如果模块中的 db 实例不是当前初始化的实例，则替换
+								if module.db is not db:
+									setattr(module, 'db', db)
+					except Exception:
+						# 静默处理异常，避免影响主流程
+						pass
+
+		except ImportError as e:
+			self.app.logger.warning(
+				"未找到 common/model/model.py，请确认已配置 SQLALCHEMY_DATABASE_URI 后至少运行一次以自动生成: %s",
+				e,
+			)
+		except Exception as e:
+			self.app.logger.exception("初始化数据库扩展失败: %s", e)
+
+	def __initialize_mail(self):
+		"""初始化邮件扩展"""
+		if self.app.config.get('MAIL_SERVER'):
+			from flask_mail import Mail
+			mail = Mail()
+			mail.init_app(self.app)
+
+	def __initialize_redis(self):
+		"""初始化 Redis 扩展"""
+		if self.app.config.get('REDIS_URL'):
+			try:
+				import redis
+				from urllib.parse import urlparse
+
+				# 解析 Redis URL
+				redis_url = self.app.config.get('REDIS_URL')
+				parsed = urlparse(redis_url)
+
+				# 创建 Redis 客户端
+				redis_client = redis.from_url(
+					redis_url,
+					decode_responses=False  # 保持字节类型，与现有代码兼容
+				)
+
+				# 测试连接
+				try:
+					redis_client.ping()
+				except Exception as e:
+					return
+
+				# 注册到 Flask extensions
+				self.app.extensions['redis'] = redis_client
+			except ImportError:
+				pass
+			except Exception as e:
+				pass