手动模式

gx_gp_monitor/notification/__init__.py

@@ -0,0 +1 @@
+"""通知模块"""

gx_gp_monitor/notification/wechat.py

@@ -0,0 +1,555 @@
+"""
+企业微信通知模块
+提供企业微信消息发送功能，支持文本和Markdown格式
+"""
+
+import requests
+import json
+import time
+import hashlib
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+try:
+    from ..core.config_manager import get_config
+    from ..core.logger import get_logger
+    from ..core.models import Announcement
+    from ..core.reliability import retry_on_exception, RetryConfig, safe_execute
+    from ..storage.md_generator import AnnouncementMarkdownFormatter
+except ImportError:
+    from core.config_manager import get_config
+    from core.logger import get_logger
+    from core.models import Announcement
+    from core.reliability import retry_on_exception, RetryConfig, safe_execute
+    from storage.md_generator import AnnouncementMarkdownFormatter
+
+
+logger = get_logger(__name__)
+
+
+class WeChatService:
+    """企业微信服务"""
+
+    def __init__(self):
+        self.config = get_config().wechat_app
+        self._access_token = None
+        self._token_expires_at = 0
+
+        logger.info("企业微信服务初始化完成")
+
+    def _get_access_token(self) -> Optional[str]:
+        """
+        获取访问令牌
+
+        Returns:
+            Optional[str]: 访问令牌
+        """
+        current_time = time.time()
+
+        # 检查令牌是否仍然有效
+        if self._access_token and current_time < self._token_expires_at:
+            return self._access_token
+
+        try:
+            # 构建请求URL
+            if self.config.use_proxy and hasattr(self.config, 'proxy_api_url'):
+                url = f"{self.config.proxy_api_url}/cgi-bin/gettoken"
+            else:
+                url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken"
+
+            params = {
+                "corpid": self.config.corp_id,
+                "corpsecret": self.config.secret
+            }
+
+            logger.debug("正在获取企业微信访问令牌")
+
+            response = requests.get(url, params=params, timeout=30)
+            result = response.json()
+
+            if result.get("errcode") == 0:
+                self._access_token = result.get("access_token")
+                # 提前5分钟过期
+                expires_in = result.get("expires_in", 7200) - 300
+                self._token_expires_at = current_time + expires_in
+
+                logger.info("成功获取企业微信访问令牌")
+                return self._access_token
+            else:
+                logger.error(f"获取访问令牌失败: {result}")
+                return None
+
+        except Exception as e:
+            logger.error(f"获取访问令牌异常: {str(e)}")
+            return None
+
+    @retry_on_exception(RetryConfig(max_retries=3))
+    def send_text_message(self, content: str,
+                         to_user: str = "@all",
+                         to_party: str = "",
+                         to_tag: str = "") -> bool:
+        """
+        发送文本消息
+
+        Args:
+            content: 消息内容
+            to_user: 接收者用户ID，多个用|分隔，@all表示全体
+            to_party: 接收者部门ID，多个用|分隔
+            to_tag: 接收者标签ID，多个用|分隔
+
+        Returns:
+            bool: 发送是否成功
+        """
+        try:
+            access_token = self._get_access_token()
+            if not access_token:
+                logger.error("无法获取访问令牌，发送失败")
+                return False
+
+            # 构建请求URL
+            if self.config.use_proxy and hasattr(self.config, 'proxy_api_url'):
+                url = f"{self.config.proxy_api_url}/cgi-bin/message/send"
+            else:
+                url = "https://qyapi.weixin.qq.com/cgi-bin/message/send"
+
+            params = {"access_token": access_token}
+
+            data = {
+                "touser": to_user,
+                "toparty": to_party,
+                "totag": to_tag,
+                "msgtype": "text",
+                "agentid": self.config.agent_id,
+                "text": {
+                    "content": content
+                }
+            }
+
+            logger.debug(f"发送文本消息: {content[:100]}...")
+
+            response = requests.post(url, params=params, json=data, timeout=30)
+            result = response.json()
+
+            if result.get("errcode") == 0:
+                logger.info("文本消息发送成功")
+                return True
+            else:
+                logger.error(f"文本消息发送失败: {result}")
+                return False
+
+        except Exception as e:
+            logger.error(f"发送文本消息异常: {str(e)}")
+            return False
+
+    @retry_on_exception(RetryConfig(max_retries=3))
+    def send_markdown_message(self, content: str,
+                             to_user: str = "@all",
+                             to_party: str = "",
+                             to_tag: str = "") -> bool:
+        """
+        发送Markdown消息
+
+        Args:
+            content: Markdown格式的消息内容
+            to_user: 接收者用户ID
+            to_party: 接收者部门ID
+            to_tag: 接收者标签ID
+
+        Returns:
+            bool: 发送是否成功
+        """
+        try:
+            access_token = self._get_access_token()
+            if not access_token:
+                logger.error("无法获取访问令牌，发送失败")
+                return False
+
+            # 构建请求URL
+            if self.config.use_proxy and hasattr(self.config, 'proxy_api_url'):
+                url = f"{self.config.proxy_api_url}/cgi-bin/message/send"
+            else:
+                url = "https://qyapi.weixin.qq.com/cgi-bin/message/send"
+
+            params = {"access_token": access_token}
+
+            data = {
+                "touser": to_user,
+                "toparty": to_party,
+                "totag": to_tag,
+                "msgtype": "markdown",
+                "agentid": self.config.agent_id,
+                "markdown": {
+                    "content": content
+                }
+            }
+
+            logger.debug("发送Markdown消息")
+
+            response = requests.post(url, params=params, json=data, timeout=30)
+            result = response.json()
+
+            if result.get("errcode") == 0:
+                logger.info("Markdown消息发送成功")
+                return True
+            else:
+                logger.error(f"Markdown消息发送失败: {result}")
+                return False
+
+        except Exception as e:
+            logger.error(f"发送Markdown消息异常: {str(e)}")
+            return False
+
+    def send_announcement_notification(self, announcements: List[Announcement],
+                                      max_count: int = 20) -> bool:
+        """
+        发送公告通知
+
+        Args:
+            announcements: 公告列表
+            max_count: 最大显示数量
+
+        Returns:
+            bool: 发送是否成功
+        """
+        if not announcements:
+            logger.info("没有新公告，跳过通知")
+            return True
+
+        try:
+            # 生成通知内容
+            notification_content = self._generate_announcement_notification(announcements, max_count)
+
+            # 发送Markdown消息
+            return self.send_markdown_message(notification_content)
+
+        except Exception as e:
+            logger.error(f"发送公告通知失败: {str(e)}")
+            return False
+
+    def _generate_announcement_notification(self, announcements: List[Announcement],
+                                           max_count: int) -> str:
+        """
+        生成公告通知内容
+
+        Args:
+            announcements: 公告列表
+            max_count: 最大显示数量
+
+        Returns:
+            str: Markdown格式的通知内容
+        """
+        # 按日期分组
+        today_announcements = []
+        other_announcements = []
+
+        today = datetime.now().date()
+
+        for announcement in announcements:
+            if announcement.publish_date and announcement.publish_date.date() == today:
+                today_announcements.append(announcement)
+            else:
+                other_announcements.append(announcement)
+
+        lines = []
+
+        # 标题
+        total_count = len(announcements)
+        lines.append(f"# 🔔 广西政府采购网公告更新")
+        lines.append("")
+        lines.append(f"**发现 {total_count} 条新公告**")
+        lines.append("")
+
+        # 今日公告
+        if today_announcements:
+            lines.append(f"## 📅 今日公告 ({len(today_announcements)}条)")
+            lines.append("")
+            display_today = today_announcements[:max_count//2]
+            for announcement in display_today:
+                title = announcement.title
+                if len(title) > 40:
+                    title = title[:40] + "..."
+                publish_time = announcement.publish_date.strftime("%H:%M") if announcement.publish_date else "N/A"
+                lines.append(f"• [{title}]({announcement.content_url}) - {publish_time}")
+
+            if len(today_announcements) > len(display_today):
+                lines.append(f"• ... 还有 {len(today_announcements) - len(display_today)} 条今日公告")
+
+            lines.append("")
+
+        # 其他公告
+        if other_announcements:
+            lines.append(f"## 📄 其他公告 ({len(other_announcements)}条)")
+            lines.append("")
+            remaining_slots = max_count - len(today_announcements) if today_announcements else max_count
+            display_other = other_announcements[:remaining_slots]
+
+            for announcement in display_other:
+                title = announcement.title
+                if len(title) > 40:
+                    title = title[:40] + "..."
+                publish_date = announcement.publish_date.strftime("%m-%d") if announcement.publish_date else "N/A"
+                lines.append(f"• [{title}]({announcement.content_url}) - {publish_date}")
+
+            if len(other_announcements) > len(display_other):
+                lines.append(f"• ... 还有 {len(other_announcements) - len(display_other)} 条公告")
+
+            lines.append("")
+
+        # 统计信息
+        source_stats = {}
+        for announcement in announcements:
+            source = announcement.source_name
+            source_stats[source] = source_stats.get(source, 0) + 1
+
+        lines.append("## 📊 统计信息")
+        lines.append("")
+        for source, count in sorted(source_stats.items()):
+            lines.append(f"• {source}: {count}条")
+
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+        lines.append(f"*更新时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*")
+        lines.append("*点击公告标题查看详情*")
+
+        return "\n".join(lines)
+
+    def send_system_notification(self, title: str, content: str,
+                                message_type: str = "text") -> bool:
+        """
+        发送系统通知
+
+        Args:
+            title: 通知标题
+            content: 通知内容
+            message_type: 消息类型 (text/markdown)
+
+        Returns:
+            bool: 发送是否成功
+        """
+        try:
+            if message_type == "markdown":
+                full_content = f"# {title}\n\n{content}"
+                return self.send_markdown_message(full_content)
+            else:
+                full_content = f"{title}\n\n{content}"
+                return self.send_text_message(full_content)
+
+        except Exception as e:
+            logger.error(f"发送系统通知失败: {str(e)}")
+            return False
+
+    def send_error_notification(self, error_message: str, error_details: Optional[str] = None) -> bool:
+        """
+        发送错误通知
+
+        Args:
+            error_message: 错误消息
+            error_details: 错误详情
+
+        Returns:
+            bool: 发送是否成功
+        """
+        content = f"## ❌ 系统错误\n\n**错误信息**: {error_message}"
+
+        if error_details:
+            content += f"\n\n**错误详情**:\n```\n{error_details}\n```"
+
+        content += f"\n\n*发生时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*"
+
+        return self.send_markdown_message(content)
+
+    def test_connection(self) -> bool:
+        """
+        测试连接
+
+        Returns:
+            bool: 连接是否正常
+        """
+        try:
+            token = self._get_access_token()
+            return token is not None
+        except Exception as e:
+            logger.error(f"企业微信连接测试失败: {str(e)}")
+            return False
+
+    def get_service_status(self) -> Dict[str, Any]:
+        """
+        获取服务状态
+
+        Returns:
+            Dict[str, Any]: 服务状态信息
+        """
+        return {
+            "service": "wechat",
+            "enabled": self.config.enabled,
+            "corp_id": self.config.corp_id[:10] + "..." if self.config.corp_id else None,
+            "agent_id": self.config.agent_id,
+            "has_token": self._access_token is not None,
+            "token_expires_at": datetime.fromtimestamp(self._token_expires_at).isoformat() if self._token_expires_at > 0 else None,
+            "use_proxy": self.config.use_proxy,
+            "connection_test": self.test_connection() if self.config.enabled else False
+        }
+
+
+class NotificationManager:
+    """通知管理器"""
+
+    def __init__(self):
+        self.wechat = WeChatService()
+        self._services = {
+            "wechat": self.wechat
+        }
+
+    def send_announcement_notification(self, announcements: List[Announcement]) -> Dict[str, bool]:
+        """
+        发送公告通知
+
+        Args:
+            announcements: 公告列表
+
+        Returns:
+            Dict[str, bool]: 各服务发送结果
+        """
+        results = {}
+
+        # 企业微信通知
+        if self.wechat.config.enabled:
+            try:
+                results["wechat"] = self.wechat.send_announcement_notification(announcements)
+            except Exception as e:
+                logger.error(f"企业微信通知失败: {str(e)}")
+                results["wechat"] = False
+        else:
+            results["wechat"] = None  # 未启用
+
+        return results
+
+    def send_system_notification(self, title: str, content: str) -> Dict[str, bool]:
+        """
+        发送系统通知
+
+        Args:
+            title: 通知标题
+            content: 通知内容
+
+        Returns:
+            Dict[str, bool]: 发送结果
+        """
+        results = {}
+
+        if self.wechat.config.enabled:
+            try:
+                results["wechat"] = self.wechat.send_system_notification(title, content, "markdown")
+            except Exception as e:
+                logger.error(f"企业微信系统通知失败: {str(e)}")
+                results["wechat"] = False
+        else:
+            results["wechat"] = None
+
+        return results
+
+    def send_error_notification(self, error_message: str, error_details: Optional[str] = None) -> Dict[str, bool]:
+        """
+        发送错误通知
+
+        Args:
+            error_message: 错误消息
+            error_details: 错误详情
+
+        Returns:
+            Dict[str, bool]: 发送结果
+        """
+        results = {}
+
+        if self.wechat.config.enabled:
+            try:
+                results["wechat"] = self.wechat.send_error_notification(error_message, error_details)
+            except Exception as e:
+                logger.error(f"企业微信错误通知失败: {str(e)}")
+                results["wechat"] = False
+        else:
+            results["wechat"] = None
+
+        return results
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        获取通知服务状态
+
+        Returns:
+            Dict[str, Any]: 服务状态
+        """
+        return {
+            "services": {
+                name: service.get_service_status() for name, service in self._services.items()
+            }
+        }
+
+
+# 全局通知管理器实例
+_notification_manager = None
+
+
+def get_notification_manager() -> NotificationManager:
+    """
+    获取通知管理器实例
+
+    Returns:
+        NotificationManager: 通知管理器实例
+    """
+    global _notification_manager
+    if _notification_manager is None:
+        _notification_manager = NotificationManager()
+    return _notification_manager
+
+
+def send_announcements_notification(announcements: List[Announcement]) -> bool:
+    """
+    发送公告通知
+
+    Args:
+        announcements: 公告列表
+
+    Returns:
+        bool: 是否至少有一个服务发送成功
+    """
+    manager = get_notification_manager()
+    results = manager.send_announcement_notification(announcements)
+
+    # 检查是否有服务发送成功
+    return any(result for result in results.values() if result is True)
+
+
+def send_system_notification(title: str, content: str) -> bool:
+    """
+    发送系统通知
+
+    Args:
+        title: 通知标题
+        content: 通知内容
+
+    Returns:
+        bool: 是否至少有一个服务发送成功
+    """
+    manager = get_notification_manager()
+    results = manager.send_system_notification(title, content)
+
+    return any(result for result in results.values() if result is True)
+
+
+def send_error_alert(error_message: str, error_details: Optional[str] = None) -> bool:
+    """
+    发送错误警报
+
+    Args:
+        error_message: 错误消息
+        error_details: 错误详情
+
+    Returns:
+        bool: 是否至少有一个服务发送成功
+    """
+    manager = get_notification_manager()
+    results = manager.send_error_notification(error_message, error_details)
+
+    return any(result for result in results.values() if result is True)