♻️ refactor(scheduler): 重构定时任务系统并增强功能 (#2009)

* ♻️ refactor(scheduler): 重构定时任务系统并增强功能

- 【模型重命名】将 `ScheduleInfo` 模型及其数据库表重命名为 `ScheduledJob`，以提高语义清晰度。
- 【触发器抽象】引入 `Trigger` 工厂类，提供类型安全的 Cron、Interval 和 Date 触发器配置。
- 【执行策略】新增 `ExecutionPolicy` 模型，允许为定时任务定义重试策略、延迟、异常类型以及成功/失败回调。
- 【任务执行】重构任务执行逻辑，支持 NoneBot 的依赖注入，并根据 `ExecutionPolicy` 处理任务的重试和回调。
- 【临时任务】增加声明式和编程式的临时任务调度能力，支持非持久化任务在运行时动态创建和执行。
- 【管理命令】更新定时任务管理命令 (`schedule_admin`)，使其适配新的 `ScheduledJob` 模型和参数验证逻辑。
- 【展示优化】改进定时任务列表和状态展示，使用新的触发器格式化逻辑和参数模型信息。
- 【重试装饰器】为 `Retry.api` 装饰器添加 `on_success` 回调，允许在任务成功执行后触发额外操作。

* 🚨 auto fix by pre-commit hooks

---------

Co-authored-by: webjoin111 <455457521@qq.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

zhenxun/utils/decorator/retry.py

@@ -130,6 +130,7 @@ class Retry:
         wait_exp_multiplier: int = 1,
         wait_exp_max: int = 10,
         log_name: str | None = None,
+        on_success: Callable[[Any], Any] | None = None,
         on_failure: Callable[[Exception], Any] | None = None,
         return_on_failure: Any = _SENTINEL,
     ):
@@ -146,6 +147,8 @@ class Retry:
             wait_exp_multiplier: 指数退避的乘数。
             wait_exp_max: 指数退避的最大等待时间。
             log_name: 用于日志记录的操作名称，方便区分不同的重试场景。
+            on_success: (可选) 当函数成功执行（且未触发重试）后，
+                        会调用此函数，并将函数的返回值作为参数传入。
             on_failure: (可选) 当所有重试都失败后，在抛出异常或返回默认值之前，
                         会调用此函数，并将最终的异常实例作为参数传入。
             return_on_failure: (可选) 如果设置了此参数，当所有重试失败后，
@@ -186,14 +189,49 @@ class Retry:
             decorated_func = tenacity_retry_decorator(func)
 
             if return_on_failure is _SENTINEL:
-                return decorated_func
+                if is_coroutine_callable(func):
+
+                    @wraps(func)
+                    async def async_success_wrapper(*args, **kwargs):
+                        result = await decorated_func(*args, **kwargs)
+                        if on_success:
+                            if is_coroutine_callable(on_success):
+                                await on_success(result)
+                            else:
+                                on_success(result)
+                        return result
+
+                    return async_success_wrapper
+                else:
+
+                    @wraps(func)
+                    def sync_success_wrapper(*args, **kwargs):
+                        result = decorated_func(*args, **kwargs)
+                        if on_success:
+                            if is_coroutine_callable(on_success):
+                                logger.error(
+                                    f"不能在同步函数 '{func.__name__}' 中调用异步的 "
+                                    f"on_success 回调。",
+                                    LOG_COMMAND,
+                                )
+                            else:
+                                on_success(result)
+                        return result
+
+                    return sync_success_wrapper
 
             if is_coroutine_callable(func):
 
                 @wraps(func)
                 async def async_wrapper(*args, **kwargs):
                     try:
-                        return await decorated_func(*args, **kwargs)
+                        result = await decorated_func(*args, **kwargs)
+                        if on_success:
+                            if is_coroutine_callable(on_success):
+                                await on_success(result)
+                            else:
+                                on_success(result)
+                        return result
                     except Exception as e:
                         if on_failure:
                             if is_coroutine_callable(on_failure):
@@ -208,7 +246,17 @@ class Retry:
                 @wraps(func)
                 def sync_wrapper(*args, **kwargs):
                     try:
-                        return decorated_func(*args, **kwargs)
+                        result = decorated_func(*args, **kwargs)
+                        if on_success:
+                            if is_coroutine_callable(on_success):
+                                logger.error(
+                                    f"不能在同步函数 '{func.__name__}' 中调用异步的 "
+                                    f"on_success 回调。",
+                                    LOG_COMMAND,
+                                )
+                            else:
+                                on_success(result)
+                        return result
                     except Exception as e:
                         if on_failure:
                             if is_coroutine_callable(on_failure):