ForcomeBot 2.2.3__tar.gz → 2.2.4__tar.gz

{forcomebot-2.2.3 → forcomebot-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ForcomeBot
-Version: 2.2.3
+Version: 2.2.4
 Summary: FORCOME 康康 - 千寻微信框架Pro与LangBot的中间件
 Project-URL: Homepage, https://github.com/yourname/ForcomeBot
 Project-URL: Documentation, https://github.com/yourname/ForcomeBot#readme

{forcomebot-2.2.3 → forcomebot-2.2.4}/config.example.yaml

@@ -5,6 +5,19 @@ server:
   host: "0.0.0.0"
   port: 789
 
+# 认证配置
+auth:
+  enabled: false              # 是否启用认证（false时所有API无需登录）
+  jwt_secret: "your-jwt-secret-key-change-in-production"  # JWT密钥（生产环境请修改）
+  jwt_expire_hours: 24        # Token过期时间（小时）
+
+# 钉钉配置（启用认证时需要配置）
+dingtalk:
+  app_key: ""                 # 钉钉应用AppKey
+  app_secret: ""              # 钉钉应用AppSecret
+  corp_id: ""                 # 企业CorpId
+  agent_id: ""                # 应用AgentId（工作台应用需要）
+
 # 千寻框架配置
 qianxun:
   # 千寻框架HTTP API地址

{forcomebot-2.2.3 → forcomebot-2.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ForcomeBot"
-version = "2.2.3"
+version = "2.2.4"
 description = "FORCOME 康康 - 千寻微信框架Pro与LangBot的中间件"
 readme = "README.md"
 requires-python = ">=3.10"

{forcomebot-2.2.3 → forcomebot-2.2.4}/src/api/routes.py

@@ -696,3 +696,80 @@ async def broadcast_applet(data: BroadcastAppletRequest):
         "message_ids": message_ids,
         "message": f"已将 {len(data.targets)} 条消息加入发送队列"
     }
+
+
+# ============ 节假日API ============
+
+# 尝试导入中国节假日库
+try:
+    import chinese_calendar
+    HAS_CHINESE_CALENDAR = True
+except ImportError:
+    HAS_CHINESE_CALENDAR = False
+
+
+@router.get("/holidays/{year}")
+async def get_holidays(year: int):
+    """获取指定年份的中国法定节假日列表
+    
+    Args:
+        year: 年份，如 2026
+        
+    Returns:
+        {
+            "year": 2026,
+            "holidays": ["2026-01-01", "2026-01-28", ...],  # 节假日列表
+            "workdays": ["2026-01-25", ...],  # 调休补班日列表
+            "available": true  # 是否有节假日数据
+        }
+    """
+    if not HAS_CHINESE_CALENDAR:
+        return {
+            "year": year,
+            "holidays": [],
+            "workdays": [],
+            "available": False,
+            "error": "chinese-calendar 库未安装"
+        }
+    
+    try:
+        from datetime import date, timedelta
+        
+        holidays: List[str] = []
+        workdays: List[str] = []
+        
+        # 遍历全年每一天
+        start_date = date(year, 1, 1)
+        end_date = date(year, 12, 31)
+        current = start_date
+        
+        while current <= end_date:
+            try:
+                is_holiday = chinese_calendar.is_holiday(current)
+                is_workday = chinese_calendar.is_workday(current)
+                weekday = current.weekday()
+                
+                if is_holiday:
+                    holidays.append(current.isoformat())
+                elif is_workday and weekday >= 5:
+                    # 周末但是工作日 = 调休补班
+                    workdays.append(current.isoformat())
+            except Exception:
+                pass
+            current += timedelta(days=1)
+        
+        return {
+            "year": year,
+            "holidays": holidays,
+            "workdays": workdays,
+            "available": True
+        }
+    except Exception as e:
+        logger.error(f"获取节假日数据失败: {e}")
+        return {
+            "year": year,
+            "holidays": [],
+            "workdays": [],
+            "available": False,
+            "error": str(e)
+        }

forcomebot-2.2.4/src/auth/__init__.py

@@ -0,0 +1,33 @@
+"""认证模块"""
+from .database import Database, get_db, init_database
+from .models import User, OperationLog
+from .jwt_handler import JWTHandler
+from .dingtalk import DingTalkClient, init_dingtalk_client, get_dingtalk_client
+from .middleware import (
+    AuthMiddleware,
+    get_current_user,
+    get_optional_user,
+    init_auth,
+    is_auth_enabled,
+    log_operation
+)
+from .routes import router as auth_router
+
+__all__ = [
+    "Database",
+    "get_db",
+    "init_database",
+    "User",
+    "OperationLog",
+    "JWTHandler",
+    "DingTalkClient",
+    "init_dingtalk_client",
+    "get_dingtalk_client",
+    "AuthMiddleware",
+    "get_current_user",
+    "get_optional_user",
+    "init_auth",
+    "is_auth_enabled",
+    "log_operation",
+    "auth_router",
+]

forcomebot-2.2.4/src/auth/database.py

@@ -0,0 +1,87 @@
+"""数据库连接管理"""
+import logging
+from pathlib import Path
+from typing import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+
+logger = logging.getLogger(__name__)
+
+
+class Base(DeclarativeBase):
+    """SQLAlchemy 基类"""
+    pass
+
+
+class Database:
+    """数据库管理器"""
+
+    def __init__(self, db_path: str = "data/app.db"):
+        self.db_path = db_path
+        self.engine = None
+        self.session_factory = None
+
+    async def init(self):
+        """初始化数据库连接"""
+        # 确保目录存在
+        Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # 创建异步引擎
+        self.engine = create_async_engine(
+            f"sqlite+aiosqlite:///{self.db_path}",
+            echo=False,
+            future=True
+        )
+
+        # 创建会话工厂
+        self.session_factory = async_sessionmaker(
+            self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
+
+        # 创建表
+        async with self.engine.begin() as conn:
+            from .models import User, OperationLog  # 导入模型以注册
+            await conn.run_sync(Base.metadata.create_all)
+
+        logger.info(f"数据库初始化完成: {self.db_path}")
+
+    async def close(self):
+        """关闭数据库连接"""
+        if self.engine:
+            await self.engine.dispose()
+            logger.info("数据库连接已关闭")
+
+    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """获取数据库会话"""
+        if not self.session_factory:
+            raise RuntimeError("数据库未初始化")
+
+        async with self.session_factory() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+
+
+# 全局数据库实例
+_database: Database = None
+
+
+async def init_database(db_path: str = "data/app.db") -> Database:
+    """初始化全局数据库实例"""
+    global _database
+    _database = Database(db_path)
+    await _database.init()
+    return _database
+
+
+def get_db() -> Database:
+    """获取全局数据库实例"""
+    if _database is None:
+        raise RuntimeError("数据库未初始化，请先调用 init_database()")
+    return _database

forcomebot-2.2.4/src/auth/dingtalk.py

@@ -0,0 +1,373 @@
+"""钉钉API客户端"""
+import logging
+import time
+from typing import Optional, Dict, Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class DingTalkClient:
+    """钉钉开放平台API客户端"""
+
+    # API基础地址
+    BASE_URL = "https://oapi.dingtalk.com"
+    NEW_API_URL = "https://api.dingtalk.com"
+
+    def __init__(
+        self,
+        app_key: str,
+        app_secret: str,
+        corp_id: str = "",
+        agent_id: str = ""
+    ):
+        """
+        初始化钉钉客户端
+
+        Args:
+            app_key: 应用AppKey
+            app_secret: 应用AppSecret
+            corp_id: 企业CorpId（工作台免登需要）
+            agent_id: 应用AgentId（工作台免登需要）
+        """
+        self.app_key = app_key
+        self.app_secret = app_secret
+        self.corp_id = corp_id
+        self.agent_id = agent_id
+
+        # Access Token缓存
+        self._access_token: Optional[str] = None
+        self._token_expire_time: float = 0
+
+        # HTTP客户端
+        self._client = httpx.AsyncClient(timeout=30.0)
+
+    async def close(self):
+        """关闭HTTP客户端"""
+        await self._client.aclose()
+
+    async def get_access_token(self) -> str:
+        """
+        获取企业内部应用的Access Token
+
+        Returns:
+            Access Token字符串
+        """
+        # 检查缓存
+        if self._access_token and time.time() < self._token_expire_time - 60:
+            return self._access_token
+
+        # 请求新Token
+        url = f"{self.BASE_URL}/gettoken"
+        params = {
+            "appkey": self.app_key,
+            "appsecret": self.app_secret
+        }
+
+        try:
+            response = await self._client.get(url, params=params)
+            data = response.json()
+
+            if data.get("errcode") == 0:
+                self._access_token = data["access_token"]
+                # Token有效期7200秒
+                self._token_expire_time = time.time() + data.get("expires_in", 7200)
+                logger.info("获取钉钉Access Token成功")
+                return self._access_token
+            else:
+                logger.error(f"获取钉钉Access Token失败: {data}")
+                raise Exception(f"获取Access Token失败: {data.get('errmsg')}")
+        except Exception as e:
+            logger.error(f"请求钉钉API异常: {e}")
+            raise
+
+    async def get_user_info_by_code(self, auth_code: str) -> Dict[str, Any]:
+        """
+        通过授权码获取用户信息（新版OAuth2扫码登录）
+
+        Args:
+            auth_code: 授权码
+
+        Returns:
+            用户信息字典
+        """
+        try:
+            # 1. 通过授权码获取用户access_token（新版OAuth2 API）
+            url = f"{self.NEW_API_URL}/v1.0/oauth2/userAccessToken"
+            body = {
+                "clientId": self.app_key,
+                "clientSecret": self.app_secret,
+                "code": auth_code,
+                "grantType": "authorization_code"
+            }
+
+            response = await self._client.post(url, json=body)
+            data = response.json()
+
+            if "accessToken" not in data:
+                logger.error(f"获取用户Token失败: {data}")
+                raise Exception(f"获取用户Token失败: {data.get('message', data)}")
+
+            user_access_token = data["accessToken"]
+            logger.info("获取用户access_token成功")
+
+            # 2. 使用用户access_token获取用户信息
+            user_info_url = f"{self.NEW_API_URL}/v1.0/contact/users/me"
+            headers = {"x-acs-dingtalk-access-token": user_access_token}
+
+            user_response = await self._client.get(user_info_url, headers=headers)
+            user_data = user_response.json()
+
+            if "unionId" not in user_data:
+                logger.error(f"获取用户信息失败: {user_data}")
+                raise Exception(f"获取用户信息失败: {user_data.get('message', user_data)}")
+
+            unionid = user_data.get("unionId")
+            logger.info(f"获取用户信息成功: unionId={unionid}")
+
+            # 3. 通过unionId获取企业内用户userid
+            userid = await self.get_userid_by_unionid(unionid)
+
+            if userid:
+                # 获取企业内用户详细信息
+                user_detail = await self.get_user_detail(userid)
+                return {
+                    "userid": userid,
+                    "unionid": unionid,
+                    "name": user_detail.get("name", user_data.get("nick", "")),
+                    "avatar": user_detail.get("avatar", user_data.get("avatarUrl", "")),
+                    "mobile": user_detail.get("mobile", user_data.get("mobile", "")),
+                    "email": user_detail.get("email", user_data.get("email", "")),
+                    "department": self._format_department(user_detail.get("dept_id_list", [])),
+                    "title": user_detail.get("title", ""),
+                }
+            else:
+                # 非企业内用户，使用OAuth返回的基本信息
+                return {
+                    "userid": user_data.get("openId", unionid),
+                    "unionid": unionid,
+                    "name": user_data.get("nick", ""),
+                    "avatar": user_data.get("avatarUrl", ""),
+                    "mobile": user_data.get("mobile", ""),
+                    "email": user_data.get("email", ""),
+                    "department": "",
+                    "title": "",
+                }
+
+        except Exception as e:
+            logger.error(f"通过授权码获取用户信息异常: {e}")
+            raise
+
+    async def get_user_info_by_code_internal(self, auth_code: str) -> Dict[str, Any]:
+        """
+        通过免登授权码获取用户信息（企业内部应用/H5免登）
+
+        Args:
+            auth_code: 免登授权码（通过钉钉JSAPI获取）
+
+        Returns:
+            用户信息字典
+        """
+        access_token = await self.get_access_token()
+
+        # 通过免登授权码获取用户userid
+        url = f"{self.BASE_URL}/topapi/v2/user/getuserinfo"
+        params = {"access_token": access_token}
+        body = {"code": auth_code}
+
+        try:
+            response = await self._client.post(url, params=params, json=body)
+            data = response.json()
+
+            if data.get("errcode") != 0:
+                logger.error(f"获取用户信息失败: {data}")
+                raise Exception(f"获取用户信息失败: {data.get('errmsg')}")
+
+            result = data.get("result", {})
+            userid = result.get("userid")
+            unionid = result.get("unionid")
+
+            if not userid:
+                raise Exception("未获取到用户userid")
+
+            # 获取用户详细信息
+            user_detail = await self.get_user_detail(userid)
+
+            return {
+                "userid": userid,
+                "unionid": unionid,
+                "name": user_detail.get("name", ""),
+                "avatar": user_detail.get("avatar", ""),
+                "mobile": user_detail.get("mobile", ""),
+                "email": user_detail.get("email", ""),
+                "department": self._format_department(user_detail.get("dept_id_list", [])),
+                "title": user_detail.get("title", ""),
+            }
+
+        except Exception as e:
+            logger.error(f"通过免登授权码获取用户信息异常: {e}")
+            raise
+
+    async def get_user_detail(self, userid: str) -> Dict[str, Any]:
+        """
+        获取用户详细信息
+
+        Args:
+            userid: 用户ID
+
+        Returns:
+            用户详细信息
+        """
+        access_token = await self.get_access_token()
+
+        url = f"{self.BASE_URL}/topapi/v2/user/get"
+        params = {"access_token": access_token}
+        body = {"userid": userid}
+
+        try:
+            response = await self._client.post(url, params=params, json=body)
+            data = response.json()
+
+            if data.get("errcode") != 0:
+                logger.error(f"获取用户详情失败: {data}")
+                raise Exception(f"获取用户详情失败: {data.get('errmsg')}")
+
+            return data.get("result", {})
+
+        except Exception as e:
+            logger.error(f"获取用户详情异常: {e}")
+            raise
+
+    async def get_userid_by_unionid(self, unionid: str) -> Optional[str]:
+        """
+        通过UnionId获取UserId
+
+        Args:
+            unionid: 用户UnionId
+
+        Returns:
+            用户UserId
+        """
+        access_token = await self.get_access_token()
+
+        url = f"{self.BASE_URL}/topapi/user/getbyunionid"
+        params = {"access_token": access_token}
+        body = {"unionid": unionid}
+
+        try:
+            response = await self._client.post(url, params=params, json=body)
+            data = response.json()
+
+            if data.get("errcode") != 0:
+                logger.warning(f"通过UnionId获取UserId失败: {data}")
+                return None
+
+            return data.get("result", {}).get("userid")
+
+        except Exception as e:
+            logger.error(f"通过UnionId获取UserId异常: {e}")
+            return None
+
+    async def get_jsapi_ticket(self) -> str:
+        """
+        获取JSAPI Ticket（H5页面调用钉钉JS API需要）
+
+        Returns:
+            JSAPI Ticket
+        """
+        access_token = await self.get_access_token()
+
+        url = f"{self.BASE_URL}/get_jsapi_ticket"
+        params = {"access_token": access_token}
+
+        try:
+            response = await self._client.get(url, params=params)
+            data = response.json()
+
+            if data.get("errcode") != 0:
+                logger.error(f"获取JSAPI Ticket失败: {data}")
+                raise Exception(f"获取JSAPI Ticket失败: {data.get('errmsg')}")
+
+            return data.get("ticket", "")
+
+        except Exception as e:
+            logger.error(f"获取JSAPI Ticket异常: {e}")
+            raise
+
+    def _format_department(self, dept_ids: list) -> str:
+        """格式化部门信息"""
+        if not dept_ids:
+            return ""
+        # 简单返回部门ID列表，实际可以查询部门名称
+        return ",".join(str(d) for d in dept_ids)
+
+    def generate_qrcode_url(self, redirect_uri: str, state: str = "") -> str:
+        """
+        生成钉钉扫码登录URL（新版OAuth2）
+
+        Args:
+            redirect_uri: 回调地址
+            state: 状态参数
+
+        Returns:
+            扫码登录URL
+        """
+        import urllib.parse
+
+        params = {
+            "client_id": self.app_key,
+            "response_type": "code",
+            "scope": "openid",
+            "redirect_uri": redirect_uri,
+            "state": state or "dingtalk_login",
+            "prompt": "consent"
+        }
+
+        query = urllib.parse.urlencode(params)
+        return f"https://login.dingtalk.com/oauth2/auth?{query}"
+
+    def generate_h5_auth_url(self, redirect_uri: str, state: str = "") -> str:
+        """
+        生成H5页面授权URL（用于钉钉内H5应用）
+
+        Args:
+            redirect_uri: 回调地址
+            state: 状态参数
+
+        Returns:
+            H5授权URL
+        """
+        import urllib.parse
+
+        params = {
+            "appid": self.app_key,
+            "response_type": "code",
+            "scope": "snsapi_auth",
+            "redirect_uri": redirect_uri,
+            "state": state or "dingtalk_h5"
+        }
+
+        query = urllib.parse.urlencode(params)
+        return f"https://login.dingtalk.com/oauth2/auth?{query}"
+
+
+# 全局客户端实例
+_dingtalk_client: Optional[DingTalkClient] = None
+
+
+def init_dingtalk_client(
+    app_key: str,
+    app_secret: str,
+    corp_id: str = "",
+    agent_id: str = ""
+) -> DingTalkClient:
+    """初始化全局钉钉客户端"""
+    global _dingtalk_client
+    _dingtalk_client = DingTalkClient(app_key, app_secret, corp_id, agent_id)
+    return _dingtalk_client
+
+
+def get_dingtalk_client() -> Optional[DingTalkClient]:
+    """获取全局钉钉客户端"""
+    return _dingtalk_client