From 0f6593789f81098b5f4f35ce5abf8bb86e470018 Mon Sep 17 00:00:00 2001 From: XiaoGe-LiBai <60430782+XiaoGe-LiBai@users.noreply.github.com> Date: Wed, 10 Dec 2025 17:49:11 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 小程序打卡/多账号打卡/accounts.json.example | 22 + 小程序打卡/多账号打卡/auto_checkin_multi.py | 932 ++++++++++++++++++ .../多账号打卡/auto_checkin_multi_opt.py | 819 +++++++++++++++ 小程序打卡/小程序打卡/auto_checkin.py | 800 +++++++++++++++ 小程序打卡/小程序打卡/auto_login.py | 172 ++++ 小程序打卡/小程序打卡/notify.py | 541 ++++++++++ 小程序打卡/小程序打卡/photo.txt | 1 + 小程序打卡/小程序打卡/sendNotify.py | 462 +++++++++ 小程序打卡/小程序打卡/test_info.py | 300 ++++++ 9 files changed, 4049 insertions(+) create mode 100644 小程序打卡/多账号打卡/accounts.json.example create mode 100644 小程序打卡/多账号打卡/auto_checkin_multi.py create mode 100644 小程序打卡/多账号打卡/auto_checkin_multi_opt.py create mode 100644 小程序打卡/小程序打卡/auto_checkin.py create mode 100644 小程序打卡/小程序打卡/auto_login.py create mode 100644 小程序打卡/小程序打卡/notify.py create mode 100644 小程序打卡/小程序打卡/photo.txt create mode 100644 小程序打卡/小程序打卡/sendNotify.py create mode 100644 小程序打卡/小程序打卡/test_info.py diff --git a/小程序打卡/多账号打卡/accounts.json.example b/小程序打卡/多账号打卡/accounts.json.example new file mode 100644 index 0000000..6773497 --- /dev/null +++ b/小程序打卡/多账号打卡/accounts.json.example @@ -0,0 +1,22 @@ +{ + "accounts": [ + { + "name": "账号1", + "token": "", + "photo": "photo.txt", + "enabled": true + }, + { + "name": "账号2", + "token": "", + "photo": "photo_account2.txt", + "enabled": true + }, + { + "name": "账号3", + "token": "", + "photo": "photo_account3.txt", + "enabled": false + } + ] +} diff --git a/小程序打卡/多账号打卡/auto_checkin_multi.py b/小程序打卡/多账号打卡/auto_checkin_multi.py new file mode 100644 index 0000000..ed712b0 --- /dev/null +++ b/小程序打卡/多账号打卡/auto_checkin_multi.py @@ -0,0 +1,932 @@ +""" +小程序自动打卡脚本 - 多账号版本 + +=== 配置说明 === + +方式一：配置文件（推荐） +在 accounts.json 中配置多个账号： +{ + "accounts": [ + { + "name": "张三", + "token": "eyJhbGc...xyz", + "photo": "photo.txt", + "enabled": true + }, + { + "name": "李四", + "token": "eyJhbGc...abc", + "photo": "photo_lisi.txt", + "enabled": true + } + ] +} + +方式二：环境变量 +变量名: hxza_dk + +格式1（推荐）: 备注名#token#photo文件名 +示例: 张三##photo.txt&侯利##photo_houli.txt +说明: token留空时会自动使用photo文件登录获取token + +格式2（完整）: 备注名#token#photo文件名 +示例: 张三#eyJhbGc...xyz#photo.txt&侯利#eyJhbGc...abc#photo_houli.txt + +格式3（兼容旧版）: token#备注名 +示例: eyJhbGc...xyz#张三&eyJhbGc...abc#侯利 +说明: 使用默认photo.txt文件 + +说明: +- name: 账号备注名称（用于日志标识） +- token: 登录凭证（可留空，留空时自动登录） +- photo: 打卡照片文件路径（相对于脚本目录，默认photo.txt） +- enabled: 是否启用该账号（环境变量模式下默认全部启用） +- 多个账号用 & 分隔 +- 配置文件优先级高于环境变量 + +""" + +import requests +import time +import os +import sys +import logging +import json +from datetime import datetime +from typing import Dict, Optional, Tuple, List +from requests.adapters import HTTPAdapter +from urllib3.util.retry import Retry + +# 添加父目录到路径，以便导入通知模块 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +# 导入通知模块 +try: + from notify import send as notify_send + NOTIFY_ENABLED = True +except ImportError: + try: + from sendNotify import send as notify_send + NOTIFY_ENABLED = True + except ImportError: + NOTIFY_ENABLED = False + def notify_send(title, content): + pass + +# 配置日志（青龙面板只输出到控制台） +logging.basicConfig( + level=logging.INFO, + format='%(message)s', + handlers=[logging.StreamHandler()] +) + +logger = logging.getLogger(__name__) + + +class AccountConfig: + """账号配置类""" + + def __init__(self, name: str, token: str, photo: str = "photo.txt", enabled: bool = True): + self.name = name + self.token = token + self.photo = photo + self.enabled = enabled + + @classmethod + def from_dict(cls, data: Dict) -> 'AccountConfig': + """从字典创建配置""" + return cls( + name=data.get('name', ''), + token=data.get('token', ''), + photo=data.get('photo', 'photo.txt'), + enabled=data.get('enabled', True) + ) + + @classmethod + def from_env_string(cls, env_str: str) -> 'AccountConfig': + """从环境变量字符串创建配置 + + 支持两种格式： + 1. 旧格式: token#备注名 + 2. 新格式: 备注名#token#photo文件名 + """ + parts = env_str.split('#') + + if len(parts) >= 3: + # 新格式: 备注名#token#photo文件名 + name = parts[0].strip() + token = parts[1].strip() + photo = parts[2].strip() + return cls(name=name, token=token, photo=photo) + elif len(parts) == 2: + # 旧格式: token#备注名 + token = parts[0].strip() + name = parts[1].strip() + return cls(name=name, token=token) + else: + # 只有token + token = parts[0].strip() + return cls(name="", token=token) + + +class ConfigLoader: + """配置加载器""" + + @staticmethod + def load_from_file(file_path: str = "accounts.json") -> List[AccountConfig]: + """从配置文件加载账号""" + try: + if not os.path.exists(file_path): + return [] + + with open(file_path, 'r', encoding='utf-8') as f: + data = json.load(f) + + accounts = [] + for account_data in data.get('accounts', []): + account = AccountConfig.from_dict(account_data) + # 只要账号启用就加载，token 可以为空（会自动登录） + if account.enabled: + accounts.append(account) + + return accounts + except Exception as e: + logger.error(f"❌ 加载配置文件失败: {str(e)}") + return [] + + @staticmethod + def load_from_env() -> List[AccountConfig]: + """从环境变量加载账号""" + env_value = os.getenv('hxza_dk', '') + if not env_value: + return [] + + accounts = [] + # 支持 & 分隔多个账号 + for account_str in env_value.split('&'): + account_str = account_str.strip() + if account_str: + accounts.append(AccountConfig.from_env_string(account_str)) + + return accounts + + @staticmethod + def load_accounts() -> List[AccountConfig]: + """加载所有账号配置（配置文件优先）""" + # 优先从配置文件加载 + accounts = ConfigLoader.load_from_file() + + # 如果配置文件为空，尝试从环境变量加载 + if not accounts: + accounts = ConfigLoader.load_from_env() + + return accounts + + +class AutoCheckIn: + """自动打卡类""" + + def __init__(self, account: AccountConfig): + self.account = account + self.base_url = "https://erp.baian.tech/baian-admin" + self.token = account.token + self.remark = account.name + self.photo_file = account.photo + + # 配置带重试的 session + self.session = self._create_session() + + # 动态获取的用户信息 + self.user_name = None + self.user_mobile = None + + # 动态获取的班次时间 + self.start_time = None + self.end_time = None + self.is_cross_day = False + + # 打卡状态信息（从接口获取） + self.is_card_time = False # 是否在打卡时间内 + self.checkin_status = None # 上班打卡状态 (0=未打卡, 1=已打卡) + self.checkin_time = None # 上班实际打卡时间 + self.checkout_status = None # 下班打卡状态 (0=未打卡, 1=已打卡) + self.checkout_time = None # 下班实际打卡时间 + + # 固定参数 + self.app_id = "wxa81d5d83880ea6b6" + + # 动态参数（从班次信息接口获取） + self.item_id = None + self.job_date_id = None + self.job_id = None + self.address_name = None + self.longitude = None + self.latitude = None + + self.headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': self.token, + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + def _create_session(self) -> requests.Session: + """创建带重试机制的 session""" + session = requests.Session() + retry = Retry( + total=3, + backoff_factor=1, + status_forcelist=[500, 502, 503, 504], + allowed_methods=["POST", "GET"] + ) + adapter = HTTPAdapter(max_retries=retry) + session.mount('https://', adapter) + session.mount('http://', adapter) + return session + + def _check_token_valid(self) -> bool: + """检查 token 是否有效""" + try: + # 尝试获取用户信息来验证 token + url = f"{self.base_url}/userH5/getMyDetails" + response = self.session.get(url, headers=self.headers, timeout=15) + + if response.status_code != 200: + return False + + result = response.json() + return result.get('code') == 200 + + except Exception: + return False + + def _update_accounts_json(self, new_token: str, config_file: str = "accounts.json") -> bool: + """ + 更新 accounts.json 配置文件中的 token + + Args: + new_token: 新的 token + config_file: 配置文件路径 + + Returns: + 成功返回 True，失败返回 False + """ + try: + if not os.path.exists(config_file): + logger.warning(f"⚠️ 配置文件不存在: {config_file}") + return False + + logger.info(f"\n📝 正在更新配置文件...") + logger.info(f" 📄 文件: {config_file}") + + # 读取配置文件 + with open(config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + + # 查找并更新当前账号的 token + updated = False + for account in config.get('accounts', []): + if account.get('name') == self.account.name: + account['token'] = new_token + updated = True + break + + if not updated: + logger.warning(f"⚠️ 未找到账号 [{self.account.name}] 的配置") + return False + + # 写回配置文件 + with open(config_file, 'w', encoding='utf-8') as f: + json.dump(config, f, ensure_ascii=False, indent=2) + + logger.info(f"✅ 配置文件已更新") + logger.info(f" 账号: {self.account.name}") + logger.info(f" Token: {new_token[:20]}...{new_token[-10:]}") + + return True + + except PermissionError: + logger.warning("⚠️ 没有权限写入配置文件") + return False + except Exception as e: + logger.warning(f"⚠️ 更新配置文件失败: {str(e)}") + return False + + def _auto_login(self) -> bool: + """ + 使用照片自动登录获取新 token + + Returns: + 成功返回 True，失败返回 False + """ + try: + logger.info("🔍 正在读取照片文件...") + + # 读取照片文件 + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在: {self.photo_file}") + return False + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + if not image_data: + logger.error(f"❌ 照片文件为空") + return False + + logger.info(f"✅ 照片文件读取成功") + + # 发送登录请求 + logger.info("🔐 正在发送登录请求...") + url = f"{self.base_url}/recognition/faceSearch" + data = {"image": image_data} + + headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': '', # 登录时不需要 token + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI Language/zh_CN', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + response = self.session.post( + url, + json=data, + headers=headers, + timeout=30 + ) + + if response.status_code != 200: + logger.error(f"❌ 登录请求失败: HTTP {response.status_code}") + return False + + result = response.json() + + if result.get('code') != 200: + logger.error(f"❌ 登录失败: {result.get('msg')}") + return False + + # 解析返回数据 + data = result.get('data', {}) + token = data.get('token') + expire = data.get('expire') # 秒数，1296000 = 15天 + + if not token: + logger.error(f"❌ 未获取到 token") + return False + + # 更新 token + self.token = token + self.account.token = token + self.headers['token'] = token + + # 计算过期时间 + from datetime import timedelta + expire_date = datetime.now() + timedelta(seconds=expire) + expire_str = expire_date.strftime('%Y-%m-%d %H:%M:%S') + + logger.info(f"✅ 自动登录成功！") + logger.info(f" 🎫 Token: {token[:20]}...{token[-10:]}") + logger.info(f" ⏰ 有效期: {expire // 86400} 天") + logger.info(f" 📅 过期时间: {expire_str}") + + # 尝试更新配置文件 + self._update_accounts_json(token) + + return True + + except Exception as e: + logger.error(f"❌ 自动登录异常: {str(e)}") + return False + + def _fetch_user_info(self) -> bool: + """获取用户信息（姓名、手机号等）""" + try: + url = f"{self.base_url}/userH5/getMyDetails" + response = self.session.get(url, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取用户信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取用户信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + self.user_name = data.get('name', '') + self.user_mobile = data.get('mobile', '') + + return True + + except Exception as e: + logger.error(f"❌ 获取用户信息异常: {str(e)}") + return False + + def _fetch_job_details(self) -> bool: + """获取班次信息（itemId、jobDateId、经纬度、班次时间等）""" + try: + url = f"{self.base_url}/Management/getJobUserDetails" + params = {"userId": ""} + + response = self.session.get(url, params=params, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取班次信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取班次信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + + # 提取 itemId 和 jobId + self.item_id = data.get('itemId') + self.job_id = data.get('jobId') + + # 提取是否在打卡时间内 + self.is_card_time = data.get('isCardTime', False) + + # 提取班次时段信息 + job_date_dtos = data.get('jobDateDTOS', []) + if job_date_dtos: + job_date = job_date_dtos[0] + self.job_date_id = job_date.get('jobDateId') + self.start_time = job_date.get('startDate') + self.end_time = job_date.get('endDate') + self.is_cross_day = job_date.get('ismorrow') == 1 + + # 提取打卡状态信息 + self.checkin_status = job_date.get('status') # 上班打卡状态 + self.checkin_time = job_date.get('date') # 上班打卡时间 + self.checkout_status = job_date.get('statusOff') # 下班打卡状态 + self.checkout_time = job_date.get('dateOff') # 下班打卡时间 + + # 提取地址信息（经纬度） + address_dtos = data.get('addressDTOS', []) + if address_dtos: + address = address_dtos[0] + self.address_name = address.get('addressName') + self.longitude = float(address.get('longitude')) + self.latitude = float(address.get('latitude')) + + # 验证必需参数 + if not all([self.item_id, self.job_date_id, self.address_name, + self.longitude, self.latitude, self.start_time, self.end_time]): + logger.error(f"❌ 班次信息不完整") + return False + + return True + + except Exception as e: + logger.error(f"❌ 获取班次信息异常: {str(e)}") + return False + + def initialize(self) -> bool: + """初始化账号信息""" + display_name = self.remark if self.remark else "未命名" + logger.info(f"\n{'='*50}") + logger.info(f"🔄 正在初始化账号: {display_name}") + logger.info(f"{'='*50}") + + # 检查 Token 有效性 + if not self.token or not self._check_token_valid(): + if not self.token: + logger.warning("⚠️ Token 为空") + else: + logger.warning("⚠️ Token 无效或已过期") + + logger.info("🔐 尝试自动登录...") + + # 尝试自动登录 + if not self._auto_login(): + logger.error("❌ 自动登录失败") + return False + + if not self._fetch_user_info(): + return False + + if not self._fetch_job_details(): + return False + + # 显示账号信息 + display_name = self.remark if self.remark else self.user_name + logger.info(f"\n✅ 账号初始化成功") + logger.info(f" 👤 姓名: {display_name}") + logger.info(f" 📱 手机: {self.user_mobile}") + logger.info(f" 📍 地点: {self.address_name}") + logger.info(f" ⏰ 班次: {self.start_time} - {self.end_time}{' (跨天)' if self.is_cross_day else ''}") + + self._show_checkin_windows() + return True + + def _request_with_retry(self, url: str, data: Dict, checkin_type: str, max_retries: int = 3) -> Optional[Dict]: + """带重试的网络请求""" + for attempt in range(1, max_retries + 1): + try: + response = self.session.post(url, json=data, headers=self.headers, timeout=15) + + if response.status_code == 200: + result = response.json() + if result.get('code') == 200: + return result + else: + logger.error(f"❌ {result.get('msg')}") + return None + else: + if attempt < max_retries: + logger.warning(f"⚠️ HTTP {response.status_code}, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + + except requests.exceptions.Timeout: + if attempt < max_retries: + logger.warning(f"⏱️ 超时, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + except requests.exceptions.RequestException as e: + if attempt < max_retries: + logger.warning(f"⚠️ {str(e)}, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + + logger.error(f"❌ 请求失败") + return None + + def _time_to_minutes(self, time_str: str) -> int: + """时间字符串转为分钟数""" + h, m = map(int, time_str.split(':')) + return h * 60 + m + + def _minutes_to_time(self, minutes: int) -> str: + """分钟数转时间字符串""" + h, m = divmod(minutes % 1440, 60) + return f"{h:02d}:{m:02d}" + + def _get_checkin_windows(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: + """根据班次时间，自动计算打卡时间窗口""" + start_minutes = self._time_to_minutes(self.start_time) + end_minutes = self._time_to_minutes(self.end_time) + + first_start = (start_minutes - 120) % 1440 + first_end = start_minutes + + second_start = (end_minutes + 1) % 1440 + second_end = (start_minutes - 121) % 1440 + + return (first_start, first_end), (second_start, second_end) + + def _is_in_window(self, current_minutes: int, start: int, end: int) -> bool: + """检查当前时间是否在窗口内""" + if start <= end: + return start <= current_minutes <= end + else: + return current_minutes >= start or current_minutes <= end + + def _get_current_checkin_type(self) -> Optional[str]: + """ + 智能判断应该执行哪种打卡 + + 判断逻辑： + 1. 必须在打卡时间内 (isCardTime == true) + 2. 检查当前时间是否在对应的打卡窗口内 + 3. 如果 status == 0 或 date == null 且在上班窗口 → 执行上班打卡 + 4. 如果 status == 1 且 (statusOff == 0 或 dateOff == null) 且在下班窗口 → 执行下班打卡 + 5. 如果两次都已打卡 → 返回 'already_done' + + Returns: + 'first' - 需要上班打卡 + 'second' - 需要下班打卡 + 'already_done' - 已完成所有打卡 + None - 不在打卡时间内或不在对应窗口内 + """ + # 检查是否在打卡时间内 + if not self.is_card_time: + return None + + # 获取当前时间（分钟数） + now = datetime.now() + current_minutes = now.hour * 60 + now.minute + + # 获取打卡时间窗口 + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + # 判断上班打卡状态 + need_checkin = (self.checkin_status == 0 or + self.checkin_status is None or + self.checkin_time is None) + + # 判断下班打卡状态 + need_checkout = (self.checkout_status == 0 or + self.checkout_status is None or + self.checkout_time is None) + + # 检查是否在上班打卡窗口内 + in_first_window = self._is_in_window(current_minutes, first_start, first_end) + + # 检查是否在下班打卡窗口内 + in_second_window = self._is_in_window(current_minutes, second_start, second_end) + + # 如果需要上班打卡且在上班窗口内 + if need_checkin and in_first_window: + return 'first' + + # 如果上班已打卡，需要下班打卡，且在下班窗口内 + if not need_checkin and need_checkout and in_second_window: + return 'second' + + # 两次都已打卡 + if not need_checkin and not need_checkout: + return 'already_done' + + # 不在对应的打卡窗口内 + return None + + def _show_checkin_windows(self): + """显示打卡时间窗口和打卡状态信息""" + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + first_start_str = self._minutes_to_time(first_start) + first_end_str = self._minutes_to_time(first_end) + second_start_str = self._minutes_to_time(second_start) + second_end_str = self._minutes_to_time(second_end) + + logger.info(f"\n📅 打卡时间窗口:") + logger.info(f" 🌅 上班: {first_start_str} - {first_end_str}") + logger.info(f" 🌆 下班: {second_start_str} - {second_end_str}") + + # 显示打卡状态 + logger.info(f"\n📊 打卡状态:") + + # 上班打卡状态 + if self.checkin_status == 1 and self.checkin_time: + logger.info(f" ✅ 上班打卡: 已完成 ({self.checkin_time})") + else: + logger.info(f" ⏰ 上班打卡: 未完成") + + # 下班打卡状态 + if self.checkout_status == 1 and self.checkout_time: + logger.info(f" ✅ 下班打卡: 已完成 ({self.checkout_time})") + else: + logger.info(f" ⏰ 下班打卡: 未完成") + + # 显示当前时间和状态 + now = datetime.now() + current_time_str = now.strftime('%H:%M:%S') + logger.info(f"\n🕐 当前时间: {current_time_str}") + + if self.is_card_time: + logger.info(f" ✅ 当前在打卡时间内") + else: + logger.info(f" ⏰ 当前不在打卡时间内") + + def face_detect(self, checkin_type: str) -> Optional[Dict]: + """人脸识别验证""" + try: + url = f"{self.base_url}/recognition/faceDetect" + + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在: {self.photo_file}") + return None + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + data = {"image": image_data} + return self._request_with_retry(url, data, checkin_type) + + except Exception as e: + logger.error(f"❌ 人脸识别异常: {str(e)}") + return None + + def save_attendance(self, checkin_type: str) -> bool: + """保存打卡记录""" + try: + url = f"{self.base_url}/Management/saveAttendanceManagement" + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + is_off = 0 if checkin_type == 'first' else 1 + update_card = 0 if checkin_type == 'first' else 1 + + data = { + "itemId": self.item_id, + "jobDateId": self.job_date_id, + "addressName": self.address_name, + "isLegwork": 0, + "legworkState": "", + "isOff": is_off, + "imageId": "", + "updateCard": update_card, + "image": image_data, + "longitude": self.longitude, + "latitude": self.latitude, + "userId": "" + } + + result = self._request_with_retry(url, data, checkin_type) + return bool(result) + + except Exception as e: + logger.error(f"❌ 保存记录异常: {str(e)}") + return False + + def do_checkin(self, checkin_type: str) -> Tuple[bool, str]: + """执行打卡流程，返回(成功与否, 结果消息)""" + checkin_name = '上班' if checkin_type == 'first' else '下班' + checkin_emoji = '🌅' if checkin_type == 'first' else '🌆' + current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + + display_name = self.remark if self.remark else self.user_name + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + first_window = f"{self._minutes_to_time(first_start)} - {self._minutes_to_time(first_end)}" + second_window = f"{self._minutes_to_time(second_start)} - {self._minutes_to_time(second_end)}" + + msg_header = f"👤 {display_name}\n📱 {self.user_mobile}\n📍 {self.address_name}\n⏰ {self.start_time}-{self.end_time}{' (跨天)' if self.is_cross_day else ''}\n\n🌅 上班: {first_window}\n🌆 下班: {second_window}\n\n" + + logger.info(f"\n{checkin_emoji} [{display_name}] {checkin_name}打卡中...") + + face_result = self.face_detect(checkin_type) + if not face_result: + logger.error(f"❌ [{display_name}] {checkin_name}打卡失败") + return False, f"{msg_header}⏰ {current_time}\n❌ {checkin_name}失败" + + time.sleep(1) + + success = self.save_attendance(checkin_type) + + if success: + logger.info(f"✅ [{display_name}] {checkin_name}打卡成功") + return True, f"{msg_header}⏰ {current_time}\n✅ {checkin_name}成功" + else: + logger.error(f"❌ [{display_name}] {checkin_name}打卡失败") + return False, f"{msg_header}⏰ {current_time}\n❌ {checkin_name}失败" + + +def main(): + """主函数""" + import argparse + + parser = argparse.ArgumentParser(description='小程序自动打卡脚本 - 多账号版本') + parser.add_argument('--type', choices=['first', 'second'], help='立即执行指定类型的打卡') + parser.add_argument('--config', default='accounts.json', help='配置文件路径') + + args = parser.parse_args() + + try: + # 加载所有账号配置 + accounts = ConfigLoader.load_accounts() + + if not accounts: + error_msg = "❌ 未找到任何账号配置，请检查 accounts.json 或环境变量 hxza_dk" + logger.error(error_msg) + if NOTIFY_ENABLED: + notify_send("❌ 小程序打卡配置错误", error_msg) + exit(1) + + logger.info(f"\n📋 共加载 {len(accounts)} 个账号") + + # 统计结果 + total_count = len(accounts) + success_count = 0 + fail_count = 0 + skip_count = 0 + all_messages = [] + + # 循环处理每个账号 + for i, account in enumerate(accounts, 1): + try: + logger.info(f"\n{'='*60}") + logger.info(f"📌 处理账号 {i}/{total_count}") + logger.info(f"{'='*60}") + + checkin = AutoCheckIn(account) + + if not checkin.initialize(): + fail_count += 1 + display_name = account.name if account.name else "未命名" + all_messages.append(f"❌ [{display_name}] 初始化失败") + continue + + success = False + msg = "" + + if args.type: + # 强制执行指定类型的打卡（忽略智能判断） + logger.info(f"\n⚠️ 强制执行 {'上班' if args.type == 'first' else '下班'} 打卡") + success, msg = checkin.do_checkin(args.type) + else: + # 智能判断打卡类型 + checkin_type = checkin._get_current_checkin_type() + + if checkin_type == 'first': + # 需要上班打卡 + logger.info(f"\n🎯 智能判断: 需要执行上班打卡") + success, msg = checkin.do_checkin('first') + elif checkin_type == 'second': + # 需要下班打卡 + logger.info(f"\n🎯 智能判断: 需要执行下班打卡") + success, msg = checkin.do_checkin('second') + elif checkin_type == 'already_done': + # 已完成所有打卡 - 只记录日志，不生成通知消息 + skip_count += 1 + display_name = account.name if account.name else checkin.user_name + + logger.info(f"\n✅ [{display_name}] 今日打卡已全部完成") + logger.info(f" 上班打卡: {checkin.checkin_time}") + logger.info(f" 下班打卡: {checkin.checkout_time}") + # 不设置 msg，跳过的账号不加入通知消息 + else: + # 不在打卡时间内 - 只记录日志，不生成通知消息 + skip_count += 1 + display_name = account.name if account.name else checkin.user_name + + logger.info(f"\n⏰ [{display_name}] 当前不在打卡时间内") + # 不设置 msg，跳过的账号不加入通知消息 + + if success: + success_count += 1 + # 只有成功和失败的消息才加入通知列表 + if msg: + all_messages.append(msg) + elif msg: + # 打卡失败 + fail_count += 1 + all_messages.append(msg) + + # 账号之间间隔，避免请求过快 + if i < total_count: + time.sleep(2) + + except Exception as e: + fail_count += 1 + display_name = account.name if account.name else "未命名" + error_msg = f"❌ [{display_name}] 处理异常: {str(e)}" + logger.error(error_msg) + all_messages.append(error_msg) + + # 汇总结果 + logger.info(f"\n{'='*60}") + logger.info(f"📊 执行结果汇总") + logger.info(f"{'='*60}") + logger.info(f" 总账号数: {total_count}") + logger.info(f" ✅ 成功: {success_count}") + logger.info(f" ❌ 失败: {fail_count}") + logger.info(f" ⏰ 跳过: {skip_count}") + + # 发送汇总通知 + if NOTIFY_ENABLED: + # 构建统计摘要 + summary = f"📊 总计: {total_count} | ✅ 成功: {success_count} | ❌ 失败: {fail_count} | ⏰ 跳过: {skip_count}" + + # 如果有详细消息，追加到摘要后面 + if all_messages: + summary += "\n\n" + "\n\n".join(all_messages) + + # 根据结果确定通知标题 + if fail_count > 0: + title = f"⚠️ 小程序打卡完成 (有失败)" + elif success_count > 0: + title = f"✅ 小程序打卡完成" + elif skip_count == total_count: + title = f"⏰ 小程序打卡提醒 (全部跳过)" + else: + title = f"📊 小程序打卡执行完成" + + notify_send(title, summary) + logger.info(f"\n📢 通知已发送: {title}") + else: + logger.warning("\n⚠️ 通知模块未启用，跳过通知推送") + + # 如果有失败的账号，返回失败状态 + exit(0 if fail_count == 0 else 1) + + except KeyboardInterrupt: + logger.info("\n⚠️ 用户中断程序") + exit(1) + except Exception as e: + error_msg = f"❌ 程序异常: {str(e)}" + logger.error(error_msg) + if NOTIFY_ENABLED: + notify_send("❌ 小程序打卡异常", error_msg) + exit(1) + + +if __name__ == '__main__': + main() diff --git a/小程序打卡/多账号打卡/auto_checkin_multi_opt.py b/小程序打卡/多账号打卡/auto_checkin_multi_opt.py new file mode 100644 index 0000000..acb156b --- /dev/null +++ b/小程序打卡/多账号打卡/auto_checkin_multi_opt.py @@ -0,0 +1,819 @@ +""" +小程序自动打卡脚本 - 多账号版本（优化版） + +主要改动： +- 支持自定义配置文件路径，全程使用同一配置文件（含自动登录后 token 回写） +- 避免重复请求用户详情接口，只请求一次同时做 token 校验和用户信息获取 +- 照片文件只读取一次并缓存，减少磁盘 IO +- 精简并统一网络重试逻辑，重试次数和间隔可配置 +- 日志信息更清晰，关键异常使用 logger.exception 方便排查 +""" + +import argparse +import json +import logging +import os +import sys +import time +from dataclasses import dataclass +from datetime import datetime, timedelta +from typing import Dict, List, Optional, Tuple + +import requests + +# ========= 常量与全局配置 ========= + +BASE_URL = "https://erp.baian.tech/baian-admin" +APP_ID = "wxa81d5d83880ea6b6" + +DEFAULT_USER_AGENT = ( + "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) " + "AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 " + "MicroMessenger/8.0.65(0x1800412e) NetType/WIFI" +) + +ENV_VAR_NAME = "hxza_dk" +DEFAULT_CONFIG_FILE = "accounts.json" +DEFAULT_PHOTO_FILE = "" + +REQUEST_TIMEOUT = 15 +MAX_RETRIES = 3 +ACCOUNT_DELAY_SECONDS = 2 + + +# 为了兼容青龙，尝试导入通知模块 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +try: + from notify import send as notify_send # type: ignore + + NOTIFY_ENABLED = True +except ImportError: + try: + from sendNotify import send as notify_send # type: ignore + + NOTIFY_ENABLED = True + except ImportError: + NOTIFY_ENABLED = False + + def notify_send(title: str, content: str) -> None: + pass + + +logging.basicConfig( + level=logging.INFO, + format="%(message)s", + handlers=[logging.StreamHandler()], +) +logger = logging.getLogger(__name__) + + +# ========= 配置相关 ========= + + +@dataclass +class AccountConfig: + """账号配置""" + + name: str + token: str + photo: Optional[str] = None + enabled: bool = True + + @classmethod + def from_dict(cls, data: Dict) -> "AccountConfig": + return cls( + name=data.get("name", "") or "", + token=data.get("token", "") or "", + photo=data.get("photo"), + enabled=bool(data.get("enabled", True)), + ) + + @classmethod + def from_env_string(cls, env_str: str) -> "AccountConfig": + """ + 从环境变量字符串创建配置 + + 支持格式： + 1) 备注名#token#photo文件名 + 示例：张三##photo.txt （token 为空时自动登录） + 2) token#备注名（兼容旧版） + 示例：eyJhbGc...xyz#张三 + 3) 只有 token（无备注名） + """ + parts = [p.strip() for p in env_str.split("#")] + + if len(parts) >= 3: + # 新格式: 备注名#token#photo文件名 + name, token, photo = parts[0], parts[1], parts[2] + photo = photo or None + return cls(name=name, token=token, photo=photo) + + if len(parts) == 2: + # 旧格式: token#备注名 + token, name = parts[0], parts[1] + return cls(name=name, token=token, photo=None) + + # 只有 token + token = parts[0] if parts else "" + return cls(name="", token=token, photo=None) + + +def load_accounts_from_file(config_path: str) -> List[AccountConfig]: + """从配置文件加载账号""" + if not os.path.exists(config_path): + return [] + + try: + with open(config_path, "r", encoding="utf-8") as f: + data = json.load(f) + + accounts: List[AccountConfig] = [] + for account_data in data.get("accounts", []): + account = AccountConfig.from_dict(account_data) + if account.enabled: + accounts.append(account) + + return accounts + except Exception as e: + logger.exception(f"❌ 加载配置文件失败: {config_path} - {e}") + return [] + + +def load_accounts_from_env() -> List[AccountConfig]: + """从环境变量加载账号""" + env_value = os.getenv(ENV_VAR_NAME, "") or "" + if not env_value.strip(): + return [] + + accounts: List[AccountConfig] = [] + for account_str in env_value.split("&"): + account_str = account_str.strip() + if not account_str: + continue + accounts.append(AccountConfig.from_env_string(account_str)) + + return accounts + + +def load_all_accounts(config_path: str) -> List[AccountConfig]: + """加载所有账号配置（配置文件优先）""" + accounts = load_accounts_from_file(config_path) + if accounts: + logger.info(f"✅ 从配置文件加载账号: {config_path}") + return accounts + + accounts = load_accounts_from_env() + if accounts: + logger.info(f"✅ 从环境变量 {ENV_VAR_NAME} 加载账号") + return accounts + + +# ========= 打卡逻辑 ========= + + +class AutoCheckIn: + """单账号自动打卡""" + + def __init__(self, account: AccountConfig, config_path: str): + self.account = account + self.config_path = config_path + + self.base_url = BASE_URL + self.app_id = APP_ID + + self.token: str = account.token or "" + self.remark: str = account.name + self.photo_file: Optional[str] = account.photo + + self.session = requests.Session() + + # 用户信息 + self.user_name: Optional[str] = None + self.user_mobile: Optional[str] = None + + # 班次信息 + self.start_time: Optional[str] = None + self.end_time: Optional[str] = None + self.is_cross_day: bool = False + + # 打卡状态 + self.is_card_time: bool = False + self.checkin_status: Optional[int] = None + self.checkin_time: Optional[str] = None + self.checkout_status: Optional[int] = None + self.checkout_time: Optional[str] = None + + # 其他参数（接口返回） + self.item_id: Optional[str] = None + self.job_date_id: Optional[str] = None + self.job_id: Optional[str] = None + self.address_name: Optional[str] = None + self.longitude: Optional[float] = None + self.latitude: Optional[float] = None + + # 照片数据缓存 + self._image_data: Optional[str] = None + + # ---- HTTP & 工具方法 ---- + + @property + def headers(self) -> Dict[str, str]: + return { + "Host": "erp.baian.tech", + "Connection": "keep-alive", + "appId": self.app_id, + "content-type": "application/json", + "wxAppKeyCompanyId": self.app_id, + "token": self.token, + "Accept-Encoding": "gzip,compress,br,deflate", + "User-Agent": DEFAULT_USER_AGENT, + "Referer": f"https://servicewechat.com/{self.app_id}/102/page-frame.html", + } + + def _post_with_retry(self, url: str, data: Dict, max_retries: int = MAX_RETRIES) -> Optional[Dict]: + """带重试的 POST 请求（自己控制重试，不依赖 HTTPAdapter）""" + for attempt in range(1, max_retries + 1): + try: + resp = self.session.post(url, json=data, headers=self.headers, timeout=REQUEST_TIMEOUT) + if resp.status_code != 200: + if attempt < max_retries: + logger.warning(f"⚠️ HTTP {resp.status_code}, 重试 {attempt}/{max_retries}") + time.sleep(2**attempt) + continue + logger.error(f"❌ 请求失败: HTTP {resp.status_code}") + return None + + result = resp.json() + if result.get("code") != 200: + logger.error(f"❌ 接口返回错误: {result.get('msg')}") + return None + return result + except requests.exceptions.Timeout: + if attempt < max_retries: + logger.warning(f"⚠️ 请求超时, 重试 {attempt}/{max_retries}") + time.sleep(2**attempt) + continue + logger.error("❌ 请求超时") + return None + except requests.exceptions.RequestException as e: + if attempt < max_retries: + logger.warning(f"⚠️ 请求异常 {e}, 重试 {attempt}/{max_retries}") + time.sleep(2**attempt) + continue + logger.exception(f"❌ 请求异常: {e}") + return None + except Exception as e: + logger.exception(f"❌ 未知异常: {e}") + return None + return None + + def _load_image_data(self) -> bool: + """读取并缓存照片文件内容""" + if self._image_data is not None: + return True + + try: + if not self.photo_file: + logger.error("❌ 未配置照片文件，请在配置中指定 photo") + return False + + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在: {self.photo_file}") + return False + + with open(self.photo_file, "r", encoding="utf-8") as f: + image_data = f.read().strip() + + if not image_data: + logger.error("❌ 照片文件内容为空") + return False + + self._image_data = image_data + logger.info("✅ 照片文件读取成功") + return True + except Exception as e: + logger.exception(f"❌ 读取照片文件异常: {e}") + return False + + # ---- 账号初始化相关 ---- + + def _update_token_in_config(self, new_token: str) -> None: + """自动登录后回写 token 到配置文件""" + if not self.config_path or not os.path.exists(self.config_path): + # 环境变量模式或无配置文件时忽略 + return + + try: + logger.info(f"\n🔄 更新配置文件中的 token: {self.config_path}") + + with open(self.config_path, "r", encoding="utf-8") as f: + config = json.load(f) + + updated = False + for account in config.get("accounts", []): + if account.get("name", "") == self.account.name: + account["token"] = new_token + updated = True + break + + if not updated: + logger.warning(f"⚠️ 配置文件中未找到账号 [{self.account.name}]，未更新 token") + return + + with open(self.config_path, "w", encoding="utf-8") as f: + json.dump(config, f, ensure_ascii=False, indent=2) + + logger.info("✅ 配置文件 token 已更新") + except PermissionError: + logger.warning("⚠️ 没有权限写入配置文件，跳过 token 回写") + except Exception as e: + logger.exception(f"❌ 更新配置文件失败: {e}") + + def _auto_login(self) -> bool: + """使用人脸识别接口自动登录获取新 token""" + logger.info("🔐 Token 无效，尝试自动登录...") + + if not self._load_image_data(): + return False + + url = f"{self.base_url}/recognition/faceSearch" + data = {"image": self._image_data} + + # 登录时不携带 token + headers = self.headers.copy() + headers["token"] = "" + + try: + resp = self.session.post(url, json=data, headers=headers, timeout=REQUEST_TIMEOUT) + if resp.status_code != 200: + logger.error(f"❌ 自动登录请求失败: HTTP {resp.status_code}") + return False + + result = resp.json() + if result.get("code") != 200: + logger.error(f"❌ 自动登录失败: {result.get('msg')}") + return False + + data = result.get("data", {}) or {} + token = data.get("token") + expire = data.get("expire", 0) + + if not token: + logger.error("❌ 自动登录未返回 token") + return False + + self.token = token + self.account.token = token + + expire_days = expire // 86400 if expire else 0 + expire_dt = datetime.now() + timedelta(seconds=expire or 0) + logger.info("✅ 自动登录成功") + logger.info(f" 🔑 Token: {token[:20]}...{token[-10:]}") + logger.info(f" ⏰ 有效期: {expire_days} 天, 过期时间: {expire_dt:%Y-%m-%d %H:%M:%S}") + + self._update_token_in_config(token) + return True + except Exception as e: + logger.exception(f"❌ 自动登录异常: {e}") + return False + + def _fetch_user_info(self, allow_auto_login: bool = True) -> bool: + """获取用户信息；若 token 失效可选择自动登录一次""" + url = f"{self.base_url}/userH5/getMyDetails" + try: + resp = self.session.get(url, headers=self.headers, timeout=REQUEST_TIMEOUT) + if resp.status_code != 200: + logger.warning(f"⚠️ 获取用户信息失败 HTTP {resp.status_code}") + if allow_auto_login and self._auto_login(): + return self._fetch_user_info(allow_auto_login=False) + return False + + result = resp.json() + if result.get("code") != 200: + logger.warning(f"⚠️ 获取用户信息失败: {result.get('msg')}") + if allow_auto_login and self._auto_login(): + return self._fetch_user_info(allow_auto_login=False) + return False + + data = result.get("data", {}) or {} + self.user_name = data.get("name", "") + self.user_mobile = data.get("mobile", "") + return True + except Exception as e: + logger.exception(f"❌ 获取用户信息异常: {e}") + if allow_auto_login and self._auto_login(): + return self._fetch_user_info(allow_auto_login=False) + return False + + def _fetch_job_details(self) -> bool: + """获取班次信息（itemId/jobDateId/经纬度/班次时间/打卡状态等）""" + url = f"{self.base_url}/Management/getJobUserDetails" + try: + resp = self.session.get(url, params={"userId": ""}, headers=self.headers, timeout=REQUEST_TIMEOUT) + if resp.status_code != 200: + logger.error(f"❌ 获取班次信息失败: HTTP {resp.status_code}") + return False + + result = resp.json() + if result.get("code") != 200: + logger.error(f"❌ 获取班次信息失败: {result.get('msg')}") + return False + + data = result.get("data", {}) or {} + + self.item_id = data.get("itemId") + self.job_id = data.get("jobId") + self.is_card_time = bool(data.get("isCardTime", False)) + + job_date_dtos = data.get("jobDateDTOS", []) or [] + if job_date_dtos: + job_date = job_date_dtos[0] or {} + self.job_date_id = job_date.get("jobDateId") + self.start_time = job_date.get("startDate") + self.end_time = job_date.get("endDate") + self.is_cross_day = job_date.get("ismorrow") == 1 + + self.checkin_status = job_date.get("status") + self.checkin_time = job_date.get("date") + self.checkout_status = job_date.get("statusOff") + self.checkout_time = job_date.get("dateOff") + + address_dtos = data.get("addressDTOS", []) or [] + if address_dtos: + address = address_dtos[0] or {} + self.address_name = address.get("addressName") + try: + self.longitude = float(address.get("longitude")) + self.latitude = float(address.get("latitude")) + except (TypeError, ValueError): + self.longitude = None + self.latitude = None + + required = [ + self.item_id, + self.job_date_id, + self.address_name, + self.longitude, + self.latitude, + self.start_time, + self.end_time, + ] + if not all(required): + logger.error("❌ 班次信息不完整，无法打卡") + return False + + return True + except Exception as e: + logger.exception(f"❌ 获取班次信息异常: {e}") + return False + + # ---- 时间窗口与判断 ---- + + @staticmethod + def _time_to_minutes(time_str: str) -> int: + h, m = map(int, time_str.split(":")) + return h * 60 + m + + @staticmethod + def _minutes_to_time(minutes: int) -> str: + h, m = divmod(minutes % 1440, 60) + return f"{h:02d}:{m:02d}" + + def _get_checkin_windows(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: + """ + 根据班次时间计算打卡时间窗口（单位：分钟，0-1439） + - 上班窗口：上班时间前 120 分钟内 + - 下班窗口：下班后到下一次上班前 121 分钟以内 + """ + if not self.start_time or not self.end_time: + raise ValueError("尚未加载班次时间") + + start_minutes = self._time_to_minutes(self.start_time) + end_minutes = self._time_to_minutes(self.end_time) + + first_start = (start_minutes - 120) % 1440 + first_end = start_minutes + + second_start = (end_minutes + 1) % 1440 + second_end = (start_minutes - 121) % 1440 + + return (first_start, first_end), (second_start, second_end) + + @staticmethod + def _is_in_window(current_minutes: int, start: int, end: int) -> bool: + """检查当前时间是否在窗口内（考虑跨午夜情况）""" + if start <= end: + return start <= current_minutes <= end + return current_minutes >= start or current_minutes <= end + + def _get_current_checkin_type(self) -> Optional[str]: + """ + 智能判断应该执行哪种打卡 + + Returns: + 'first' - 需要上班打卡 + 'second' - 需要下班打卡 + 'already_done' - 已完成所有打卡 + None - 不在打卡时间内或不在对应窗口内 + """ + if not self.is_card_time: + return None + + now = datetime.now() + current_minutes = now.hour * 60 + now.minute + + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + need_checkin = ( + self.checkin_status == 0 + or self.checkin_status is None + or self.checkin_time is None + ) + need_checkout = ( + self.checkout_status == 0 + or self.checkout_status is None + or self.checkout_time is None + ) + + in_first_window = self._is_in_window(current_minutes, first_start, first_end) + in_second_window = self._is_in_window(current_minutes, second_start, second_end) + + if need_checkin and in_first_window: + return "first" + + if (not need_checkin) and need_checkout and in_second_window: + return "second" + + if (not need_checkin) and (not need_checkout): + return "already_done" + + return None + + def _show_checkin_windows(self) -> None: + """显示打卡时间窗口和状态""" + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + first_start_str = self._minutes_to_time(first_start) + first_end_str = self._minutes_to_time(first_end) + second_start_str = self._minutes_to_time(second_start) + second_end_str = self._minutes_to_time(second_end) + + logger.info("\n🕒 打卡时间窗口:") + logger.info(f" ⏰ 上班: {first_start_str} - {first_end_str}") + logger.info(f" ⏰ 下班: {second_start_str} - {second_end_str}") + + logger.info("\n📌 打卡状态:") + if self.checkin_status == 1 and self.checkin_time: + logger.info(f" ✅ 上班打卡: 已完成 ({self.checkin_time})") + else: + logger.info(" ❗ 上班打卡: 未完成") + + if self.checkout_status == 1 and self.checkout_time: + logger.info(f" ✅ 下班打卡: 已完成 ({self.checkout_time})") + else: + logger.info(" ❗ 下班打卡: 未完成") + + now = datetime.now().strftime("%H:%M:%S") + logger.info(f"\n⏱ 当前时间: {now}") + if self.is_card_time: + logger.info(" ✅ 当前在打卡时间内") + else: + logger.info(" ⛔ 当前不在打卡时间内") + + # ---- 核心动作 ---- + + def initialize(self) -> bool: + """初始化账号信息（token 检查/自动登录 + 用户信息 + 班次信息）""" + display_name = self.remark or "未命名" + logger.info("\n" + "=" * 50) + logger.info(f"👤 正在初始化账号: {display_name}") + logger.info("=" * 50) + + # token 为空或无效，将在 _fetch_user_info 内自动尝试登录一次 + if not self.token: + logger.warning("⚠️ Token 为空，将尝试自动登录") + + if not self._fetch_user_info(allow_auto_login=True): + logger.error("❌ 初始化失败：获取用户信息失败") + return False + + if not self._fetch_job_details(): + logger.error("❌ 初始化失败：获取班次信息失败") + return False + + display_name = self.remark or self.user_name or "未命名" + logger.info("\n✅ 账号初始化成功") + logger.info(f" 👤 姓名: {display_name}") + logger.info(f" 📱 手机: {self.user_mobile}") + logger.info(f" 📍 地点: {self.address_name}") + logger.info( + f" 🗓 班次: {self.start_time} - {self.end_time}{' (跨天)' if self.is_cross_day else ''}" + ) + + self._show_checkin_windows() + return True + + def face_detect(self, checkin_type: str) -> Optional[Dict]: + """人脸识别验证""" + if not self._load_image_data(): + return None + + url = f"{self.base_url}/recognition/faceDetect" + data = {"image": self._image_data} + return self._post_with_retry(url, data) + + def save_attendance(self, checkin_type: str) -> bool: + """保存打卡记录""" + if not self._load_image_data(): + return False + + url = f"{self.base_url}/Management/saveAttendanceManagement" + is_off = 0 if checkin_type == "first" else 1 + update_card = 0 if checkin_type == "first" else 1 + + data = { + "itemId": self.item_id, + "jobDateId": self.job_date_id, + "addressName": self.address_name, + "isLegwork": 0, + "legworkState": "", + "isOff": is_off, + "imageId": "", + "updateCard": update_card, + "image": self._image_data, + "longitude": self.longitude, + "latitude": self.latitude, + "userId": "", + } + + result = self._post_with_retry(url, data) + return bool(result) + + def do_checkin(self, checkin_type: str) -> Tuple[bool, str]: + """执行打卡流程，返回 (成功与否, 结果消息)""" + checkin_name = "上班" if checkin_type == "first" else "下班" + emoji = "🌞" if checkin_type == "first" else "🌙" + current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + display_name = self.remark or self.user_name or "未命名" + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + first_window = f"{self._minutes_to_time(first_start)} - {self._minutes_to_time(first_end)}" + second_window = f"{self._minutes_to_time(second_start)} - {self._minutes_to_time(second_end)}" + + msg_header = ( + f"👤 {display_name}\n" + f"📱 {self.user_mobile}\n" + f"📍 {self.address_name}\n" + f"🗓 {self.start_time}-{self.end_time}{' (跨天)' if self.is_cross_day else ''}\n\n" + f"⏰ 上班: {first_window}\n" + f"⏰ 下班: {second_window}\n\n" + ) + + logger.info(f"\n{emoji} [{display_name}] {checkin_name}打卡中...") + + face_result = self.face_detect(checkin_type) + if not face_result: + logger.error(f"❌ [{display_name}] {checkin_name}打卡失败（人脸识别失败）") + return False, f"{msg_header}🕒 {current_time}\n❌ {checkin_name}失败" + + time.sleep(1) + + success = self.save_attendance(checkin_type) + if success: + logger.info(f"✅ [{display_name}] {checkin_name}打卡成功") + return True, f"{msg_header}🕒 {current_time}\n✅ {checkin_name}成功" + + logger.error(f"❌ [{display_name}] {checkin_name}打卡失败（保存记录失败）") + return False, f"{msg_header}🕒 {current_time}\n❌ {checkin_name}失败" + + +# ========= 主流程 ========= + + +def run() -> int: + parser = argparse.ArgumentParser(description="小程序自动打卡脚本 - 多账号版本（优化版）") + parser.add_argument("--type", choices=["first", "second"], help="立即执行指定类型的打卡") + parser.add_argument( + "--config", + default=DEFAULT_CONFIG_FILE, + help="配置文件路径（默认 accounts.json）", + ) + + args = parser.parse_args() + + try: + accounts = load_all_accounts(args.config) + if not accounts: + msg = f"❌ 未找到任何账号配置，请检查 {args.config} 或环境变量 {ENV_VAR_NAME}" + logger.error(msg) + if NOTIFY_ENABLED: + notify_send("❌ 小程序打卡配置错误", msg) + return 1 + + total = len(accounts) + logger.info(f"\n✅ 共加载 {total} 个账号") + + success_count = 0 + fail_count = 0 + skip_count = 0 + all_messages: List[str] = [] + + for i, account in enumerate(accounts, 1): + display_name = account.name or "未命名" + logger.info("\n" + "=" * 60) + logger.info(f"👤 处理账号 {i}/{total}: {display_name}") + logger.info("=" * 60) + + try: + checker = AutoCheckIn(account, config_path=args.config) + if not checker.initialize(): + fail_count += 1 + all_messages.append(f"❌ [{display_name}] 初始化失败") + continue + + success = False + msg = "" + + if args.type: + logger.info( + f"\n🎯 强制执行 {'上班' if args.type == 'first' else '下班'} 打卡" + ) + success, msg = checker.do_checkin(args.type) + else: + ctype = checker._get_current_checkin_type() + if ctype == "first": + logger.info("\n🤖 智能判断: 需要执行上班打卡") + success, msg = checker.do_checkin("first") + elif ctype == "second": + logger.info("\n🤖 智能判断: 需要执行下班打卡") + success, msg = checker.do_checkin("second") + elif ctype == "already_done": + skip_count += 1 + logger.info(f"\n✅ [{display_name}] 今日打卡已全部完成") + logger.info(f" 上班打卡: {checker.checkin_time}") + logger.info(f" 下班打卡: {checker.checkout_time}") + else: + skip_count += 1 + logger.info(f"\nℹ️ [{display_name}] 当前不在打卡时间内") + + if success: + success_count += 1 + if msg: + all_messages.append(msg) + elif msg: + fail_count += 1 + all_messages.append(msg) + + if i < total: + time.sleep(ACCOUNT_DELAY_SECONDS) + except Exception as e: + fail_count += 1 + logger.exception(f"❌ 处理账号 [{display_name}] 异常: {e}") + all_messages.append(f"❌ [{display_name}] 处理异常: {e}") + + logger.info("\n" + "=" * 60) + logger.info("📊 执行结果汇总") + logger.info("=" * 60) + logger.info(f" 总账号数: {total}") + logger.info(f" ✅ 成功: {success_count}") + logger.info(f" ❌ 失败: {fail_count}") + logger.info(f" ⏭ 跳过: {skip_count}") + + if NOTIFY_ENABLED: + # 全部账号都被跳过时不发送任何通知 + if success_count == 0 and fail_count == 0 and skip_count == total: + logger.info("\nℹ️ 所有账号均被跳过，不发送通知") + else: + summary = ( + f"📊 总计: {total} | ✅ 成功: {success_count} | " + f"❌ 失败: {fail_count} | ⏭ 跳过: {skip_count}" + ) + if all_messages: + summary += "\n\n" + "\n\n".join(all_messages) + + if fail_count > 0: + title = "⚠️ 小程序打卡完成（有失败）" + elif success_count > 0: + title = "✅ 小程序打卡完成" + else: + title = "📊 小程序打卡执行完成" + + notify_send(title, summary) + logger.info(f"\n📣 通知已发送: {title}") + else: + logger.warning("\n⚠️ 通知模块未启用，跳过通知推送") + + return 0 if fail_count == 0 else 1 + except KeyboardInterrupt: + logger.info("\n⛔ 用户中断程序") + return 1 + except Exception as e: + logger.exception(f"❌ 程序异常: {e}") + if NOTIFY_ENABLED: + notify_send("❌ 小程序打卡异常", str(e)) + return 1 + + +if __name__ == "__main__": + raise SystemExit(run()) diff --git a/小程序打卡/小程序打卡/auto_checkin.py b/小程序打卡/小程序打卡/auto_checkin.py new file mode 100644 index 0000000..f4bf0d5 --- /dev/null +++ b/小程序打卡/小程序打卡/auto_checkin.py @@ -0,0 +1,800 @@ +""" +小程序自动打卡脚本（支持自动登录） + +=== 配置说明 === + +环境变量配置（青龙面板在"环境变量"中添加）： +变量名: hxza_dk +变量值: token 或 token#备注 或 空（自动登录） +示例: eyJhbGc...xyz 或 eyJhbGc...xyz#张三 或 留空 + +说明: +- token: 登录凭证（可选，如果为空或失效会自动登录） +- 备注: 可选，用于日志标识（如果不提供，则显示从接口获取的姓名） +- 用户信息（姓名、手机号）会自动从接口获取 +- 班次信息（上下班时间、打卡地点、经纬度）会自动从接口获取 +- 打卡时间窗口会根据班次时间自动计算 +- Token 失效时会自动使用照片登录获取新 token + +文件配置: +- photo.txt : 打卡照片的 base64 数据（必须与脚本同目录） + +""" + +import requests +import time +import os +import sys +import logging +from datetime import datetime +from typing import Dict, Optional, Tuple +from requests.adapters import HTTPAdapter +from urllib3.util.retry import Retry + +# 添加父目录到路径，以便导入通知模块 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +# 导入通知模块 +try: + from notify import send as notify_send + NOTIFY_ENABLED = True +except ImportError: + try: + from sendNotify import send as notify_send + NOTIFY_ENABLED = True + except ImportError: + NOTIFY_ENABLED = False + def notify_send(title, content): + pass + +# 配置日志（青龙面板只输出到控制台） +logging.basicConfig( + level=logging.INFO, + format='%(message)s', + handlers=[logging.StreamHandler()] +) + +logger = logging.getLogger(__name__) + + +class AutoCheckIn: + """自动打卡类""" + + def __init__(self): + self.base_url = "https://erp.baian.tech/baian-admin" + + # 固定参数（必须在最前面定义，因为自动登录需要用到） + self.app_id = "wxa81d5d83880ea6b6" + self.photo_file = "photo.txt" + + # 解析环境变量 + config = os.getenv('hxza_dk', '') + + parts = config.split('#') if config else [''] + self.token = parts[0].strip() + self.remark = parts[1].strip() if len(parts) > 1 else "" + + # 配置带重试的 session + self.session = self._create_session() + + # 如果 token 为空或失效，自动登录获取新 token + if not self.token or not self._check_token_valid(): + logger.info("\n🔐 Token 无效或为空，尝试自动登录...") + if not self._auto_login(): + error_msg = "❌ 自动登录失败" + logger.error(error_msg) + raise ValueError(error_msg) + + # 动态获取的用户信息 + self.user_name = None + self.user_mobile = None + + # 动态获取的班次时间 + self.start_time = None # 上班时间（如 "23:00"） + self.end_time = None # 下班时间（如 "07:00"） + self.is_cross_day = False # 是否跨天 + + # 动态参数（从班次信息接口获取） + self.item_id = None + self.job_date_id = None + self.job_id = None + self.address_name = None + self.longitude = None + self.latitude = None + + # 更新 headers（使用最新的 token） + self.headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': self.token, + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + # 初始化时获取用户信息 + if not self._fetch_user_info(): + raise ValueError("❌ 获取用户信息失败") + + # 初始化时获取班次信息 + if not self._fetch_job_details(): + raise ValueError("❌ 获取班次信息失败") + + # 显示打卡时间窗口 + self._show_checkin_windows() + + def _create_session(self) -> requests.Session: + """创建带重试机制的 session""" + session = requests.Session() + retry = Retry( + total=3, + backoff_factor=1, + status_forcelist=[500, 502, 503, 504], + allowed_methods=["POST", "GET"] + ) + adapter = HTTPAdapter(max_retries=retry) + session.mount('https://', adapter) + session.mount('http://', adapter) + return session + + def _check_token_valid(self) -> bool: + """检查 token 是否有效""" + try: + # 尝试获取用户信息来验证 token + url = f"{self.base_url}/userH5/getMyDetails" + headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': self.token, + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + response = self.session.get(url, headers=headers, timeout=15) + + if response.status_code != 200: + return False + + result = response.json() + return result.get('code') == 200 + + except Exception: + return False + + def _update_ql_env(self, token: str) -> bool: + """ + 更新青龙面板环境变量配置文件 + + Args: + token: 新的 token + + Returns: + 成功返回 True，失败返回 False + """ + try: + # 青龙面板环境变量配置文件路径 + ql_env_paths = [ + '/ql/data/config/config.sh', # 青龙面板默认路径 + # '/ql/config/env.sh', # 旧版青龙面板路径 + os.path.expanduser('~/ql/data/config/env.sh'), # 用户目录 + ] + + env_file = None + for path in ql_env_paths: + if os.path.exists(path): + env_file = path + break + + if not env_file: + logger.warning("⚠️ 未找到青龙面板环境变量配置文件，跳过自动更新") + logger.info("💡 请手动更新环境变量 hxza_dk") + return False + + logger.info(f"\n📝 正在更新青龙面板环境变量...") + logger.info(f" 📄 配置文件: {env_file}") + + # 读取配置文件 + with open(env_file, 'r', encoding='utf-8') as f: + lines = f.readlines() + + # 构建新的环境变量值 + new_value = f'{token}#{self.remark}' if self.remark else token + + # 查找并更新 hxza_dk 变量 + updated = False + for i, line in enumerate(lines): + # 匹配 export hxza_dk="..." 或 export hxza_dk='...' + if line.strip().startswith('export hxza_dk=') or line.strip().startswith('hxza_dk='): + lines[i] = f'export hxza_dk="{new_value}"\n' + updated = True + break + + # 如果没有找到，则添加到文件末尾 + if not updated: + # 确保文件末尾有换行符 + if lines and not lines[-1].endswith('\n'): + lines[-1] += '\n' + lines.append(f'export hxza_dk="{new_value}"\n') + + # 写回配置文件 + with open(env_file, 'w', encoding='utf-8') as f: + f.writelines(lines) + + logger.info(f"✅ 环境变量已更新") + logger.info(f" 变量名: hxza_dk") + logger.info(f" 变量值: {token[:20]}...{token[-10:]}{('#' + self.remark) if self.remark else ''}") + + return True + + except PermissionError: + logger.warning("⚠️ 没有权限写入配置文件，跳过自动更新") + logger.info("💡 请手动更新环境变量 hxza_dk 或使用 root 权限运行") + return False + except Exception as e: + logger.warning(f"⚠️ 更新环境变量失败: {str(e)}") + logger.info("💡 请手动更新环境变量 hxza_dk") + return False + + def _auto_login(self) -> bool: + """ + 使用照片自动登录获取新 token + + Returns: + 成功返回 True，失败返回 False + """ + try: + logger.info("🔍 正在读取照片文件...") + + # 读取照片文件 + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在: {self.photo_file}") + return False + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + if not image_data: + logger.error(f"❌ 照片文件为空") + return False + + logger.info(f"✅ 照片文件读取成功") + + # 发送登录请求 + logger.info("🔐 正在发送登录请求...") + url = f"{self.base_url}/recognition/faceSearch" + data = {"image": image_data} + + headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': '', # 登录时不需要 token + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI Language/zh_CN', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + response = self.session.post( + url, + json=data, + headers=headers, + timeout=30 + ) + + if response.status_code != 200: + logger.error(f"❌ 登录请求失败: HTTP {response.status_code}") + return False + + result = response.json() + + if result.get('code') != 200: + logger.error(f"❌ 登录失败: {result.get('msg')}") + return False + + # 解析返回数据 + data = result.get('data', {}) + token = data.get('token') + expire = data.get('expire') # 秒数，1296000 = 15天 + + if not token: + logger.error(f"❌ 未获取到 token") + return False + + # 更新 token + self.token = token + + # 计算过期时间 + from datetime import timedelta + expire_date = datetime.now() + timedelta(seconds=expire) + expire_str = expire_date.strftime('%Y-%m-%d %H:%M:%S') + + logger.info(f"✅ 自动登录成功！") + logger.info(f" 🎫 Token: {token[:20]}...{token[-10:]}") + logger.info(f" ⏰ 有效期: {expire // 86400} 天") + logger.info(f" 📅 过期时间: {expire_str}") + + # 尝试更新青龙面板环境变量配置文件 + self._update_ql_env(token) + + return True + + except Exception as e: + logger.error(f"❌ 自动登录异常: {str(e)}") + return False + + def _fetch_user_info(self) -> bool: + """获取用户信息（姓名、手机号等）""" + try: + logger.info("\n🔍 正在获取用户信息...") + url = f"{self.base_url}/userH5/getMyDetails" + + response = self.session.get(url, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取用户信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取用户信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + self.user_name = data.get('name', '') + self.user_mobile = data.get('mobile', '') + + # 显示备注或姓名 + display_name = self.remark if self.remark else self.user_name + logger.info(f"✅ 用户信息获取成功") + logger.info(f" 👤 姓名: {display_name}") + logger.info(f" 📱 手机: {self.user_mobile}") + + return True + + except Exception as e: + logger.error(f"❌ 获取用户信息异常: {str(e)}") + return False + + def _fetch_job_details(self) -> bool: + """获取班次信息（itemId、jobDateId、经纬度、班次时间等）""" + try: + logger.info("\n🔍 正在获取班次信息...") + url = f"{self.base_url}/Management/getJobUserDetails" + params = {"userId": ""} + + response = self.session.get(url, params=params, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取班次信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取班次信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + + # 提取 itemId 和 jobId + self.item_id = data.get('itemId') + self.job_id = data.get('jobId') + + # 提取班次时段信息 + job_date_dtos = data.get('jobDateDTOS', []) + if job_date_dtos: + job_date = job_date_dtos[0] + self.job_date_id = job_date.get('jobDateId') + self.start_time = job_date.get('startDate') # 如 "23:00" + self.end_time = job_date.get('endDate') # 如 "07:00" + self.is_cross_day = job_date.get('ismorrow') == 1 # 是否跨天 + + # 提取地址信息（经纬度） + address_dtos = data.get('addressDTOS', []) + if address_dtos: + address = address_dtos[0] + self.address_name = address.get('addressName') + self.longitude = float(address.get('longitude')) + self.latitude = float(address.get('latitude')) + + # 验证必需参数 + if not all([self.item_id, self.job_date_id, self.address_name, self.longitude, self.latitude, self.start_time, self.end_time]): + logger.error(f"❌ 班次信息不完整") + return False + + logger.info(f"✅ 班次信息获取成功") + logger.info(f" 📍 打卡地点: {self.address_name}") + logger.info(f" 🌐 经纬度: {self.longitude}, {self.latitude}") + logger.info(f" ⏰ 班次时间: {self.start_time} - {self.end_time}{' (跨天)' if self.is_cross_day else ''}") + # logger.info(f" 🆔 项目ID: {self.item_id}") + # logger.info(f" 🆔 班次ID: {self.job_id}") + # logger.info(f" 🆔 时段ID: {self.job_date_id}") + return True + + except Exception as e: + logger.error(f"❌ 获取班次信息异常: {str(e)}") + return False + + def _request_with_retry(self, url: str, data: Dict, checkin_type: str, max_retries: int = 3) -> Optional[Dict]: + """带重试的网络请求""" + for attempt in range(1, max_retries + 1): + try: + response = self.session.post(url, json=data, headers=self.headers, timeout=15) + + if response.status_code == 200: + result = response.json() + if result.get('code') == 200: + return result + else: + logger.error(f"❌ {result.get('msg')}") + return None + else: + if attempt < max_retries: + logger.warning(f"⚠️ HTTP {response.status_code}, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + + except requests.exceptions.Timeout: + if attempt < max_retries: + logger.warning(f"⏱️ 超时, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + except requests.exceptions.RequestException as e: + if attempt < max_retries: + logger.warning(f"⚠️ {str(e)}, 重试 {attempt}/{max_retries}") + time.sleep(2 ** attempt) + continue + return None + + logger.error(f"❌ 请求失败") + return None + + def _time_to_minutes(self, time_str: str) -> int: + """时间字符串转为分钟数""" + h, m = map(int, time_str.split(':')) + return h * 60 + m + + def _minutes_to_time(self, minutes: int) -> str: + """分钟数转时间字符串""" + h, m = divmod(minutes % 1440, 60) + return f"{h:02d}:{m:02d}" + + def _get_checkin_windows(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: + """ + 根据班次时间，自动计算打卡时间窗口 + + 规则： + - 第一次打卡（上班）：start_time 前2小时 到 start_time + - 第二次打卡（下班）：end_time+1分钟 到 (start_time - 2小时 - 1分钟) + + Returns: + ((first_start, first_end), (second_start, second_end)) 分钟数 + """ + start_minutes = self._time_to_minutes(self.start_time) + end_minutes = self._time_to_minutes(self.end_time) + + # 第一次打卡窗口：start_time - 120分钟 到 start_time + first_start = (start_minutes - 120) % 1440 # 1440 = 24*60 + first_end = start_minutes + + # 第二次打卡窗口：end_time + 1分钟 到 (start_time - 121分钟) + second_start = (end_minutes + 1) % 1440 + second_end = (start_minutes - 121) % 1440 + + return (first_start, first_end), (second_start, second_end) + + def _is_in_window(self, current_minutes: int, start: int, end: int) -> bool: + """检查当前时间是否在窗口内""" + if start <= end: + # 同一天内的窗口（如 21:00-23:00） + return start <= current_minutes <= end + else: + # 跨天的窗口（如 07:01-20:59，实际不跨天；或 23:00-05:59 跨天） + return current_minutes >= start or current_minutes <= end + + def _get_current_checkin_type(self) -> Optional[str]: + """ + 根据当前时间判断应该执行哪种打卡 + + Returns: + 'first' / 'second' / None + """ + now = datetime.now() + current_minutes = now.hour * 60 + now.minute + + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + # 检查是否在第一次打卡窗口 + if self._is_in_window(current_minutes, first_start, first_end): + return 'first' + + # 检查是否在第二次打卡窗口 + if self._is_in_window(current_minutes, second_start, second_end): + return 'second' + + return None + + def _get_window_str(self, start: int, end: int) -> str: + """分钟数转时间字符串""" + start_h, start_m = divmod(start, 60) + end_h, end_m = divmod(end, 60) + return f"{start_h:02d}:{start_m:02d}-{end_h:02d}:{end_m:02d}" + + def _show_checkin_windows(self): + """显示打卡时间窗口信息""" + logger.info("\n📅 打卡时间窗口:") + + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + first_start_str = self._minutes_to_time(first_start) + first_end_str = self._minutes_to_time(first_end) + second_start_str = self._minutes_to_time(second_start) + second_end_str = self._minutes_to_time(second_end) + + logger.info(f" 🌅 上班打卡窗口: {first_start_str} - {first_end_str}") + logger.info(f" 🌆 下班打卡窗口: {second_start_str} - {second_end_str}") + + # 检查当前时间 + now = datetime.now() + current_minutes = now.hour * 60 + now.minute + current_time_str = now.strftime('%H:%M:%S') + + logger.info(f"\n🕐 当前时间: {current_time_str}") + + if self._is_in_window(current_minutes, first_start, first_end): + logger.info(f" ✅ 当前在【上班打卡】窗口内") + elif self._is_in_window(current_minutes, second_start, second_end): + logger.info(f" ✅ 当前在【下班打卡】窗口内") + else: + logger.info(f" ⏰ 当前不在任何打卡窗口内") + + def face_detect(self, checkin_type: str) -> Optional[Dict]: + """人脸识别验证""" + try: + url = f"{self.base_url}/recognition/faceDetect" + + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在") + return None + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + data = {"image": image_data} + return self._request_with_retry(url, data, checkin_type) + + except Exception as e: + logger.error(f"❌ 人脸识别异常: {str(e)}") + return None + + def save_attendance(self, checkin_type: str) -> bool: + """保存打卡记录""" + try: + url = f"{self.base_url}/Management/saveAttendanceManagement" + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + # 第一次打卡：isOff=0, updateCard=0 + # 第二次打卡：isOff=1, updateCard=1 + is_off = 0 if checkin_type == 'first' else 1 + update_card = 0 if checkin_type == 'first' else 1 + + data = { + "itemId": self.item_id, + "jobDateId": self.job_date_id, + "addressName": self.address_name, + "isLegwork": 0, + "legworkState": "", + "isOff": is_off, + "imageId": "", + "updateCard": update_card, + "image": image_data, + "longitude": self.longitude, + "latitude": self.latitude, + "userId": "" + } + + result = self._request_with_retry(url, data, checkin_type) + return bool(result) + + except Exception as e: + logger.error(f"❌ 保存记录异常: {str(e)}") + return False + + def do_checkin(self, checkin_type: str) -> Tuple[bool, str]: + """执行打卡流程，返回(成功与否, 结果消息)""" + checkin_name = '上班' if checkin_type == 'first' else '下班' + checkin_emoji = '🌅' if checkin_type == 'first' else '🌆' + current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + prefix = f"[{self.user_name}] " if self.user_name else "" + + # 构建详细的通知消息 + display_name = self.remark if self.remark else self.user_name + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + first_window = f"{self._minutes_to_time(first_start)} - {self._minutes_to_time(first_end)}" + second_window = f"{self._minutes_to_time(second_start)} - {self._minutes_to_time(second_end)}" + + msg_header = f"👤 {display_name}\n📱 {self.user_mobile}\n📍 {self.address_name}\n🌐 {self.longitude}, {self.latitude}\n⏰ {self.start_time}-{self.end_time}{' (跨天)' if self.is_cross_day else ''}\n\n🌅 上班: {first_window}\n🌆 下班: {second_window}\n\n" + + logger.info(f"{prefix}{checkin_emoji} {checkin_name}打卡中...") + + face_result = self.face_detect(checkin_type) + if not face_result: + logger.error(f"{prefix}❌ {checkin_name}打卡失败") + return False, f"{msg_header}⏰ {current_time}\n❌ {checkin_name}失败" + + time.sleep(1) + + success = self.save_attendance(checkin_type) + + if success: + logger.info(f"{prefix}✅ {checkin_name}打卡成功") + return True, f"{msg_header}⏰ {current_time}\n✅ {checkin_name}成功" + else: + logger.error(f"{prefix}❌ {checkin_name}打卡失败") + return False, f"{msg_header}⏰ {current_time}\n❌ {checkin_name}失败" + + +def get_all_accounts() -> list: + """ + 获取所有配置的账号 + + 支持两种配置方式： + 1. 单账号：hxza_dk="token" 或 hxza_dk="token#备注" + 2. 多账号：hxza_dk_1="token1#备注1" hxza_dk_2="token2#备注2" ... + + Returns: + 账号配置列表，每个元素为 (env_var_name, config_value) + """ + accounts = [] + + # 检查单账号配置 + single_config = os.getenv('hxza_dk', '') + if single_config: + accounts.append(('hxza_dk', single_config)) + return accounts + + # 检查多账号配置 + i = 1 + while True: + env_var = f'hxza_dk_{i}' + config = os.getenv(env_var, '') + if not config: + break + accounts.append((env_var, config)) + i += 1 + + return accounts + + +def process_account(env_var_name: str, config: str, checkin_type_arg: Optional[str] = None) -> Tuple[bool, str]: + """ + 处理单个账号的打卡 + + Args: + env_var_name: 环境变量名称 + config: 配置值 + checkin_type_arg: 指定的打卡类型（'first' 或 'second'），None 表示自动判断 + + Returns: + (成功与否, 结果消息) + """ + try: + # 临时设置环境变量 + os.environ['hxza_dk'] = config + + logger.info("\n" + "=" * 60) + logger.info(f"📱 处理账号: {env_var_name}") + logger.info("=" * 60) + + checkin = AutoCheckIn() + success = False + msg = "" + + if checkin_type_arg: + success, msg = checkin.do_checkin(checkin_type_arg) + else: + checkin_type = checkin._get_current_checkin_type() + if checkin_type: + type_emoji = '🌅' if checkin_type == 'first' else '🌆' + logger.info(f"{type_emoji} 当前时间在{'第一次' if checkin_type == 'first' else '第二次'}打卡窗口内") + success, msg = checkin.do_checkin(checkin_type) + else: + logger.info(f"⏰ 当前时间不在任何打卡窗口内") + (first_start, first_end), (second_start, second_end) = checkin._get_checkin_windows() + logger.info(f"🌅 第一次打卡窗口: {checkin._get_window_str(first_start, first_end)}") + logger.info(f"🌆 第二次打卡窗口: {checkin._get_window_str(second_start, second_end)}") + + # 构建详细的通知消息 + display_name = checkin.remark if checkin.remark else checkin.user_name + first_window = f"{checkin._minutes_to_time(first_start)} - {checkin._minutes_to_time(first_end)}" + second_window = f"{checkin._minutes_to_time(second_start)} - {checkin._minutes_to_time(second_end)}" + current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + + msg = f"👤 {display_name}\n📱 {checkin.user_mobile}\n📍 {checkin.address_name}\n🌐 {checkin.longitude}, {checkin.latitude}\n⏰ {checkin.start_time}-{checkin.end_time}{' (跨天)' if checkin.is_cross_day else ''}\n\n🌅 上班: {first_window}\n🌆 下班: {second_window}\n\n🕐 {current_time}\n⏰ 当前时间不在打卡窗口内" + + return success, msg + + except Exception as e: + error_msg = f"账号 {env_var_name} 处理异常: {str(e)}" + logger.error(error_msg) + return False, error_msg + + +def main(): + """主函数""" + import argparse + + parser = argparse.ArgumentParser(description='小程序自动打卡脚本') + parser.add_argument('--type', choices=['first', 'second'], help='立即执行指定类型的打卡') + + args = parser.parse_args() + + try: + checkin = AutoCheckIn() + success = False + msg = "" + + if args.type: + success, msg = checkin.do_checkin(args.type) + else: + checkin_type = checkin._get_current_checkin_type() + if checkin_type: + type_emoji = '🌅' if checkin_type == 'first' else '🌆' + logger.info(f"{type_emoji} 当前时间在{'第一次' if checkin_type == 'first' else '第二次'}打卡窗口内") + success, msg = checkin.do_checkin(checkin_type) + else: + logger.info(f"⏰ 当前时间不在任何打卡窗口内") + (first_start, first_end), (second_start, second_end) = checkin._get_checkin_windows() + logger.info(f"🌅 第一次打卡窗口: {checkin._get_window_str(first_start, first_end)}") + logger.info(f"🌆 第二次打卡窗口: {checkin._get_window_str(second_start, second_end)}") + + # 构建详细的通知消息 + display_name = checkin.remark if checkin.remark else checkin.user_name + first_window = f"{checkin._minutes_to_time(first_start)} - {checkin._minutes_to_time(first_end)}" + second_window = f"{checkin._minutes_to_time(second_start)} - {checkin._minutes_to_time(second_end)}" + current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + + msg = f"👤 {display_name}\n📱 {checkin.user_mobile}\n📍 {checkin.address_name}\n🌐 {checkin.longitude}, {checkin.latitude}\n⏰ {checkin.start_time}-{checkin.end_time}{' (跨天)' if checkin.is_cross_day else ''}\n\n🌅 上班: {first_window}\n🌆 下班: {second_window}\n\n🕐 {current_time}\n⏰ 当前时间不在打卡窗口内" + + # 发送通知 + if NOTIFY_ENABLED and msg: + title = "📱 小程序打卡通知" + if success: + title = "✅ 小程序打卡成功" + elif "不在打卡窗口" in msg: + title = "⏰ 小程序打卡提醒" + else: + title = "❌ 小程序打卡失败" + + notify_send(title, msg) + logger.info(f"📢 通知已发送: {title}") + elif not NOTIFY_ENABLED: + logger.warning("⚠️ 通知模块未启用，跳过通知推送") + + exit(0 if success else 1) + + except KeyboardInterrupt: + logger.info("\n用户中断程序") + except Exception as e: + error_msg = f"程序异常: {str(e)}" + logger.error(error_msg) + # 异常时也发送通知 + if NOTIFY_ENABLED: + notify_send("❌ 小程序打卡异常", error_msg) + exit(1) + + +if __name__ == '__main__': + main() diff --git a/小程序打卡/小程序打卡/auto_login.py b/小程序打卡/小程序打卡/auto_login.py new file mode 100644 index 0000000..27acd76 --- /dev/null +++ b/小程序打卡/小程序打卡/auto_login.py @@ -0,0 +1,172 @@ +""" +小程序自动登录脚本（照片登录） + +=== 功能说明 === +- 使用照片自动登录获取新的 token +- token 有效期 15 天（1296000 秒） +- 无需验证码，直接通过人脸识别登录 + +=== 使用方法 === +1. 确保 photo.txt 文件存在且包含 Base64 编码的照片 +2. 运行脚本：python auto_login.py +3. 脚本会输出新的 token，有效期 15 天 + +""" + +import requests +import os +import logging +from datetime import datetime, timedelta +from typing import Optional + +# 配置日志 +logging.basicConfig( + level=logging.INFO, + format='%(message)s', + handlers=[logging.StreamHandler()] +) + +logger = logging.getLogger(__name__) + + +class AutoLogin: + """自动登录类""" + + def __init__(self): + self.base_url = "https://erp.baian.tech/baian-admin" + self.app_id = "wxa81d5d83880ea6b6" + self.photo_file = "photo.txt" + + self.headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': '', # 登录时不需要 token + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.65(0x1800412e) NetType/WIFI Language/zh_CN', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + logger.info("=" * 60) + logger.info("🔐 小程序自动登录（照片登录）") + logger.info("=" * 60) + + def login(self) -> Optional[dict]: + """ + 使用照片登录获取 token + + Returns: + 成功返回 {"token": "xxx", "expire": 1296000}，失败返回 None + """ + try: + logger.info("\n🔍 正在读取照片文件...") + + # 读取照片文件 + if not os.path.exists(self.photo_file): + logger.error(f"❌ 照片文件不存在: {self.photo_file}") + return None + + with open(self.photo_file, 'r', encoding='utf-8') as f: + image_data = f.read().strip() + + if not image_data: + logger.error(f"❌ 照片文件为空") + return None + + logger.info(f"✅ 照片文件读取成功") + logger.info(f" 📄 文件大小: {len(image_data)} 字符") + + # 发送登录请求 + logger.info("\n🔐 正在发送登录请求...") + url = f"{self.base_url}/recognition/faceSearch" + data = {"image": image_data} + + response = requests.post( + url, + json=data, + headers=self.headers, + timeout=30 + ) + + if response.status_code != 200: + logger.error(f"❌ 登录请求失败: HTTP {response.status_code}") + return None + + result = response.json() + + if result.get('code') != 200: + logger.error(f"❌ 登录失败: {result.get('msg')}") + return None + + # 解析返回数据 + data = result.get('data', {}) + token = data.get('token') + expire = data.get('expire') # 秒数，1296000 = 15天 + + if not token: + logger.error(f"❌ 未获取到 token") + return None + + # 计算过期时间 + expire_date = datetime.now() + timedelta(seconds=expire) + expire_str = expire_date.strftime('%Y-%m-%d %H:%M:%S') + + logger.info(f"✅ 登录成功！") + logger.info(f"\n" + "=" * 60) + logger.info(f"🎫 Token 信息:") + logger.info(f"=" * 60) + logger.info(f"Token: {token}") + logger.info(f"有效期: {expire} 秒 ({expire // 86400} 天)") + logger.info(f"过期时间: {expire_str}") + logger.info(f"=" * 60) + + logger.info(f"\n💡 提示:") + logger.info(f" 请将以下 token 配置到环境变量 hxza_dk 中") + logger.info(f" 格式: hxza_dk=\"{token}\"") + logger.info(f" 或者: hxza_dk=\"{token}#备注\"") + + return { + 'token': token, + 'expire': expire, + 'expire_date': expire_str + } + + except Exception as e: + logger.error(f"❌ 登录异常: {str(e)}") + return None + + +def main(): + """主函数""" + try: + logger.info("\n🚀 开始自动登录...\n") + + login = AutoLogin() + result = login.login() + + if result: + logger.info("\n✅ 自动登录成功！") + logger.info("\n💡 下一步操作:") + logger.info(" 1. 复制上面的 token") + logger.info(" 2. 更新环境变量 hxza_dk") + logger.info(" 3. 运行 auto_checkin.py 进行打卡") + else: + logger.error("\n❌ 自动登录失败！") + logger.error("\n💡 请检查:") + logger.error(" 1. photo.txt 文件是否存在") + logger.error(" 2. 照片内容是否正确") + logger.error(" 3. 网络连接是否正常") + exit(1) + + except KeyboardInterrupt: + logger.info("\n⚠️ 用户中断程序") + except Exception as e: + error_msg = f"\n❌ 程序异常: {str(e)}" + logger.error(error_msg) + exit(1) + + +if __name__ == '__main__': + main() diff --git a/小程序打卡/小程序打卡/notify.py b/小程序打卡/小程序打卡/notify.py new file mode 100644 index 0000000..a5ac2b7 --- /dev/null +++ b/小程序打卡/小程序打卡/notify.py @@ -0,0 +1,541 @@ +#!/usr/bin/env python3 +# _*_ coding:utf-8 _*_ +import base64 +import hashlib +import hmac +import json +import os +import re +import threading +import time +import urllib.parse + +import requests + +# 原先的 print 函数和主线程的锁 +_print = print +mutex = threading.Lock() + + +# 定义新的 print 函数 +def print(text, *args, **kw): + """ + 使输出有序进行，不出现多线程同一时间输出导致错乱的问题。 + """ + with mutex: + _print(text, *args, **kw) + + +# 通知服务 +# fmt: off +push_config = { + 'HITOKOTO': False, # 启用一言（随机句子） + + 'BARK_PUSH': '', # bark IP 或设备码，例：https://api.day.app/DxHcxxxxxRxxxxxxcm/ + 'BARK_ARCHIVE': '', # bark 推送是否存档 + 'BARK_GROUP': '', # bark 推送分组 + 'BARK_SOUND': '', # bark 推送声音 + + 'CONSOLE': True, # 控制台输出 + + 'DD_BOT_SECRET': '', # 钉钉机器人的 DD_BOT_SECRET + 'DD_BOT_TOKEN': '', # 钉钉机器人的 DD_BOT_TOKEN + + 'FSKEY': '', # 飞书机器人的 FSKEY + + 'GOBOT_URL': '', # go-cqhttp + # 推送到个人QQ：http://127.0.0.1/send_private_msg + # 群：http://127.0.0.1/send_group_msg + 'GOBOT_QQ': '', # go-cqhttp 的推送群或用户 + # GOBOT_URL 设置 /send_private_msg 时填入 user_id=个人QQ + # /send_group_msg 时填入 group_id=QQ群 + 'GOBOT_TOKEN': '', # go-cqhttp 的 access_token + + 'GOTIFY_URL': '', # gotify地址,如https://push.example.de:8080 + 'GOTIFY_TOKEN': '', # gotify的消息应用token + 'GOTIFY_PRIORITY': 0, # 推送消息优先级,默认为0 + + 'IGOT_PUSH_KEY': '', # iGot 聚合推送的 IGOT_PUSH_KEY + + 'PUSH_KEY': '', # server 酱的 PUSH_KEY，兼容旧版与 Turbo 版 + + 'PUSH_PLUS_TOKEN': '', # push+ 微信推送的用户令牌 + 'PUSH_PLUS_USER': '', # push+ 微信推送的群组编码 + + 'QMSG_KEY': '', # qmsg 酱的 QMSG_KEY + 'QMSG_TYPE': '', # qmsg 酱的 QMSG_TYPE + + 'QYWX_AM': '', # 企业微信应用 + + 'QYWX_KEY': '', # 企业微信机器人 + + 'TG_BOT_TOKEN': '', # tg 机器人的 TG_BOT_TOKEN，例：1407203283:AAG9rt-6RDaaX0HBLZQq0laNOh898iFYaRQ + 'TG_USER_ID': '', # tg 机器人的 TG_USER_ID，例：1434078534 + 'TG_API_HOST': '', # tg 代理 api + 'TG_PROXY_AUTH': '', # tg 代理认证参数 + 'TG_PROXY_HOST': '', # tg 机器人的 TG_PROXY_HOST + 'TG_PROXY_PORT': '', # tg 机器人的 TG_PROXY_PORT +} +notify_function = [] +# fmt: on + +# 首先读取 面板变量 或者 github action 运行变量 +for k in push_config: + if os.getenv(k): + v = os.getenv(k) + push_config[k] = v + + +def bark(title: str, content: str) -> None: + """ + 使用 bark 推送消息。 + """ + if not push_config.get("BARK_PUSH"): + print("bark 服务的 BARK_PUSH 未设置!!\n取消推送") + return + print("bark 服务启动") + + if push_config.get("BARK_PUSH").startswith("http"): + url = f'{push_config.get("BARK_PUSH")}/{urllib.parse.quote_plus(title)}/{urllib.parse.quote_plus(content)}' + else: + url = f'https://api.day.app/{push_config.get("BARK_PUSH")}/{urllib.parse.quote_plus(title)}/{urllib.parse.quote_plus(content)}' + + bark_params = { + "BARK_ARCHIVE": "isArchive", + "BARK_GROUP": "group", + "BARK_SOUND": "sound", + } + params = "" + for pair in filter( + lambda pairs: pairs[0].startswith("BARK_") + and pairs[0] != "BARK_PUSH" + and pairs[1] + and bark_params.get(pairs[0]), + push_config.items(), + ): + params += f"{bark_params.get(pair[0])}={pair[1]}&" + if params: + url = url + "?" + params.rstrip("&") + response = requests.get(url).json() + + if response["code"] == 200: + print("bark 推送成功！") + else: + print("bark 推送失败！") + + +def console(title: str, content: str) -> None: + """ + 使用 控制台 推送消息。 + """ + print(f"{title}\n\n{content}") + + +def dingding_bot(title: str, content: str) -> None: + """ + 使用 钉钉机器人 推送消息。 + """ + if not push_config.get("DD_BOT_SECRET") or not push_config.get("DD_BOT_TOKEN"): + print("钉钉机器人 服务的 DD_BOT_SECRET 或者 DD_BOT_TOKEN 未设置!!\n取消推送") + return + print("钉钉机器人 服务启动") + + timestamp = str(round(time.time() * 1000)) + secret_enc = push_config.get("DD_BOT_SECRET").encode("utf-8") + string_to_sign = "{}\n{}".format(timestamp, push_config.get("DD_BOT_SECRET")) + string_to_sign_enc = string_to_sign.encode("utf-8") + hmac_code = hmac.new( + secret_enc, string_to_sign_enc, digestmod=hashlib.sha256 + ).digest() + sign = urllib.parse.quote_plus(base64.b64encode(hmac_code)) + url = f'https://oapi.dingtalk.com/robot/send?access_token={push_config.get("DD_BOT_TOKEN")}×tamp={timestamp}&sign={sign}' + headers = {"Content-Type": "application/json;charset=utf-8"} + data = {"msgtype": "text", "text": {"content": f"{title}\n\n{content}"}} + response = requests.post( + url=url, data=json.dumps(data), headers=headers, timeout=15 + ).json() + + if not response["errcode"]: + print("钉钉机器人 推送成功！") + else: + print("钉钉机器人 推送失败！") + + +def feishu_bot(title: str, content: str) -> None: + """ + 使用 飞书机器人 推送消息。 + """ + if not push_config.get("FSKEY"): + print("飞书 服务的 FSKEY 未设置!!\n取消推送") + return + print("飞书 服务启动") + + url = f'https://open.feishu.cn/open-apis/bot/v2/hook/{push_config.get("FSKEY")}' + data = {"msg_type": "text", "content": {"text": f"{title}\n\n{content}"}} + response = requests.post(url, data=json.dumps(data)).json() + + if response.get("StatusCode") == 0: + print("飞书 推送成功！") + else: + print("飞书 推送失败！错误信息如下：\n", response) + + +def go_cqhttp(title: str, content: str) -> None: + """ + 使用 go_cqhttp 推送消息。 + """ + if not push_config.get("GOBOT_URL") or not push_config.get("GOBOT_QQ"): + print("go-cqhttp 服务的 GOBOT_URL 或 GOBOT_QQ 未设置!!\n取消推送") + return + print("go-cqhttp 服务启动") + + url = f'{push_config.get("GOBOT_URL")}?access_token={push_config.get("GOBOT_TOKEN")}&{push_config.get("GOBOT_QQ")}&message=标题:{title}\n内容:{content}' + response = requests.get(url).json() + + if response["status"] == "ok": + print("go-cqhttp 推送成功！") + else: + print("go-cqhttp 推送失败！") + + +def gotify(title:str,content:str) -> None: + """ + 使用 gotify 推送消息。 + """ + if not push_config.get("GOTIFY_URL") or not push_config.get("GOTIFY_TOKEN"): + print("gotify 服务的 GOTIFY_URL 或 GOTIFY_TOKEN 未设置!!\n取消推送") + return + print("gotify 服务启动") + + url = f'{push_config.get("GOTIFY_URL")}/message?token={push_config.get("GOTIFY_TOKEN")}' + data = {"title": title,"message": content,"priority": push_config.get("GOTIFY_PRIORITY")} + response = requests.post(url,data=data).json() + + if response.get("id"): + print("gotify 推送成功！") + else: + print("gotify 推送失败！") + + +def iGot(title: str, content: str) -> None: + """ + 使用 iGot 推送消息。 + """ + if not push_config.get("IGOT_PUSH_KEY"): + print("iGot 服务的 IGOT_PUSH_KEY 未设置!!\n取消推送") + return + print("iGot 服务启动") + + url = f'https://push.hellyw.com/{push_config.get("IGOT_PUSH_KEY")}' + data = {"title": title, "content": content} + headers = {"Content-Type": "application/x-www-form-urlencoded"} + response = requests.post(url, data=data, headers=headers).json() + + if response["ret"] == 0: + print("iGot 推送成功！") + else: + print(f'iGot 推送失败！{response["errMsg"]}') + + +def serverJ(title: str, content: str) -> None: + """ + 通过 serverJ 推送消息。 + """ + if not push_config.get("PUSH_KEY"): + print("serverJ 服务的 PUSH_KEY 未设置!!\n取消推送") + return + print("serverJ 服务启动") + + data = {"text": title, "desp": content.replace("\n", "\n\n")} + if push_config.get("PUSH_KEY").index("SCT") != -1: + url = f'https://sctapi.ftqq.com/{push_config.get("PUSH_KEY")}.send' + else: + url = f'https://sc.ftqq.com/${push_config.get("PUSH_KEY")}.send' + response = requests.post(url, data=data).json() + + if response.get("errno") == 0 or response.get("code") == 0: + print("serverJ 推送成功！") + else: + print(f'serverJ 推送失败！错误码：{response["message"]}') + + +def pushplus_bot(title: str, content: str) -> None: + """ + 通过 push+ 推送消息。 + """ + if not push_config.get("PUSH_PLUS_TOKEN"): + print("PUSHPLUS 服务的 PUSH_PLUS_TOKEN 未设置!!\n取消推送") + return + print("PUSHPLUS 服务启动") + + url = "http://www.pushplus.plus/send" + data = { + "token": push_config.get("PUSH_PLUS_TOKEN"), + "title": title, + "content": content, + "topic": push_config.get("PUSH_PLUS_USER"), + } + body = json.dumps(data).encode(encoding="utf-8") + headers = {"Content-Type": "application/json"} + response = requests.post(url=url, data=body, headers=headers).json() + + if response["code"] == 200: + print("PUSHPLUS 推送成功！") + + else: + + url_old = "http://pushplus.hxtrip.com/send" + headers["Accept"] = "application/json" + response = requests.post(url=url_old, data=body, headers=headers).json() + + if response["code"] == 200: + print("PUSHPLUS(hxtrip) 推送成功！") + + else: + print("PUSHPLUS 推送失败！") + + +def qmsg_bot(title: str, content: str) -> None: + """ + 使用 qmsg 推送消息。 + """ + if not push_config.get("QMSG_KEY") or not push_config.get("QMSG_TYPE"): + print("qmsg 的 QMSG_KEY 或者 QMSG_TYPE 未设置!!\n取消推送") + return + print("qmsg 服务启动") + + url = f'https://qmsg.zendee.cn/{push_config.get("QMSG_TYPE")}/{push_config.get("QMSG_KEY")}' + payload = {"msg": f'{title}\n\n{content.replace("----", "-")}'.encode("utf-8")} + response = requests.post(url=url, params=payload).json() + + if response["code"] == 0: + print("qmsg 推送成功！") + else: + print(f'qmsg 推送失败！{response["reason"]}') + + +def wecom_app(title: str, content: str) -> None: + """ + 通过 企业微信 APP 推送消息。 + """ + if not push_config.get("QYWX_AM"): + print("QYWX_AM 未设置!!\n取消推送") + return + QYWX_AM_AY = re.split(",", push_config.get("QYWX_AM")) + if 4 < len(QYWX_AM_AY) > 5: + print("QYWX_AM 设置错误!!\n取消推送") + return + print("企业微信 APP 服务启动") + + corpid = QYWX_AM_AY[0] + corpsecret = QYWX_AM_AY[1] + touser = QYWX_AM_AY[2] + agentid = QYWX_AM_AY[3] + try: + media_id = QYWX_AM_AY[4] + except IndexError: + media_id = "" + wx = WeCom(corpid, corpsecret, agentid) + # 如果没有配置 media_id 默认就以 text 方式发送 + if not media_id: + message = title + "\n\n" + content + response = wx.send_text(message, touser) + else: + response = wx.send_mpnews(title, content, media_id, touser) + + if response == "ok": + print("企业微信推送成功！") + else: + print("企业微信推送失败！错误信息如下：\n", response) + + +class WeCom: + def __init__(self, corpid, corpsecret, agentid): + self.CORPID = corpid + self.CORPSECRET = corpsecret + self.AGENTID = agentid + + def get_access_token(self): + url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken" + values = { + "corpid": self.CORPID, + "corpsecret": self.CORPSECRET, + } + req = requests.post(url, params=values) + data = json.loads(req.text) + return data["access_token"] + + def send_text(self, message, touser="@all"): + send_url = ( + "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=" + + self.get_access_token() + ) + send_values = { + "touser": touser, + "msgtype": "text", + "agentid": self.AGENTID, + "text": {"content": message}, + "safe": "0", + } + send_msges = bytes(json.dumps(send_values), "utf-8") + respone = requests.post(send_url, send_msges) + respone = respone.json() + return respone["errmsg"] + + def send_mpnews(self, title, message, media_id, touser="@all"): + send_url = ( + "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=" + + self.get_access_token() + ) + send_values = { + "touser": touser, + "msgtype": "mpnews", + "agentid": self.AGENTID, + "mpnews": { + "articles": [ + { + "title": title, + "thumb_media_id": media_id, + "author": "Author", + "content_source_url": "", + "content": message.replace("\n", "
"), + "digest": message, + } + ] + }, + } + send_msges = bytes(json.dumps(send_values), "utf-8") + respone = requests.post(send_url, send_msges) + respone = respone.json() + return respone["errmsg"] + + +def wecom_bot(title: str, content: str) -> None: + """ + 通过 企业微信机器人 推送消息。 + """ + if not push_config.get("QYWX_KEY"): + print("企业微信机器人 服务的 QYWX_KEY 未设置!!\n取消推送") + return + print("企业微信机器人服务启动") + + url = f"https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={push_config.get('QYWX_KEY')}" + headers = {"Content-Type": "application/json;charset=utf-8"} + data = {"msgtype": "text", "text": {"content": f"{title}\n\n{content}"}} + response = requests.post( + url=url, data=json.dumps(data), headers=headers, timeout=15 + ).json() + + if response["errcode"] == 0: + print("企业微信机器人推送成功！") + else: + print("企业微信机器人推送失败！") + + +def telegram_bot(title: str, content: str) -> None: + """ + 使用 telegram 机器人 推送消息。 + """ + if not push_config.get("TG_BOT_TOKEN") or not push_config.get("TG_USER_ID"): + print("tg 服务的 bot_token 或者 user_id 未设置!!\n取消推送") + return + print("tg 服务启动") + + if push_config.get("TG_API_HOST"): + url = f"https://{push_config.get('TG_API_HOST')}/bot{push_config.get('TG_BOT_TOKEN')}/sendMessage" + else: + url = ( + f"https://api.telegram.org/bot{push_config.get('TG_BOT_TOKEN')}/sendMessage" + ) + headers = {"Content-Type": "application/x-www-form-urlencoded"} + payload = { + "chat_id": str(push_config.get("TG_USER_ID")), + "text": f"{title}\n\n{content}", + "disable_web_page_preview": "true", + } + proxies = None + if push_config.get("TG_PROXY_HOST") and push_config.get("TG_PROXY_PORT"): + if push_config.get("TG_PROXY_AUTH") is not None and "@" not in push_config.get( + "TG_PROXY_HOST" + ): + push_config["TG_PROXY_HOST"] = ( + push_config.get("TG_PROXY_AUTH") + + "@" + + push_config.get("TG_PROXY_HOST") + ) + proxyStr = "http://{}:{}".format( + push_config.get("TG_PROXY_HOST"), push_config.get("TG_PROXY_PORT") + ) + proxies = {"http": proxyStr, "https": proxyStr} + response = requests.post( + url=url, headers=headers, params=payload, proxies=proxies + ).json() + + if response["ok"]: + print("tg 推送成功！") + else: + print("tg 推送失败！") + + +def one() -> str: + """ + 获取一条一言。 + :return: + """ + url = "https://v1.hitokoto.cn/" + res = requests.get(url).json() + return res["hitokoto"] + " ----" + res["from"] + + +if push_config.get("BARK_PUSH"): + notify_function.append(bark) +if push_config.get("CONSOLE"): + notify_function.append(console) +if push_config.get("DD_BOT_TOKEN") and push_config.get("DD_BOT_SECRET"): + notify_function.append(dingding_bot) +if push_config.get("FSKEY"): + notify_function.append(feishu_bot) +if push_config.get("GOBOT_URL") and push_config.get("GOBOT_QQ"): + notify_function.append(go_cqhttp) +if push_config.get("GOTIFY_URL") and push_config.get("GOTIFY_TOKEN"): + notify_function.append(gotify) +if push_config.get("IGOT_PUSH_KEY"): + notify_function.append(iGot) +if push_config.get("PUSH_KEY"): + notify_function.append(serverJ) +if push_config.get("PUSH_PLUS_TOKEN"): + notify_function.append(pushplus_bot) +if push_config.get("QMSG_KEY") and push_config.get("QMSG_TYPE"): + notify_function.append(qmsg_bot) +if push_config.get("QYWX_AM"): + notify_function.append(wecom_app) +if push_config.get("QYWX_KEY"): + notify_function.append(wecom_bot) +if push_config.get("TG_BOT_TOKEN") and push_config.get("TG_USER_ID"): + notify_function.append(telegram_bot) + + +def send(title: str, content: str) -> None: + if not content: + print(f"{title} 推送内容为空！") + return + + hitokoto = push_config.get("HITOKOTO") + + text = one() if hitokoto else "" + content += "\n\n" + text + + ts = [ + threading.Thread(target=mode, args=(title, content), name=mode.__name__) + for mode in notify_function + ] + [t.start() for t in ts] + [t.join() for t in ts] + + +def main(): + send("title", "content") + + +if __name__ == "__main__": + main() diff --git a/小程序打卡/小程序打卡/photo.txt b/小程序打卡/小程序打卡/photo.txt new file mode 100644 index 0000000..e7898be --- /dev/null +++ b/小程序打卡/小程序打卡/photo.txt @@ -0,0 +1 @@ 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 diff --git a/小程序打卡/小程序打卡/sendNotify.py b/小程序打卡/小程序打卡/sendNotify.py new file mode 100644 index 0000000..87489e9 --- /dev/null +++ b/小程序打卡/小程序打卡/sendNotify.py @@ -0,0 +1,462 @@ +#!/usr/bin/env python3 +# _*_ coding:utf-8 _*_ + +#Modify: Kirin + +from curses.ascii import FS +import sys +import os, re +import requests +import json +import time +import hmac +import hashlib +import base64 +import urllib.parse +from requests.adapters import HTTPAdapter +from urllib3.util import Retry + +cur_path = os.path.abspath(os.path.dirname(__file__)) +root_path = os.path.split(cur_path)[0] +sys.path.append(root_path) + +# 通知服务 +BARK = 'GQ9g7h6ir2gQActgab25Jj' # bark服务,自行搜索; secrets可填; +BARK_PUSH='' # bark自建服务器，要填完整链接，结尾的/不要 +PUSH_KEY = '' # Server酱的PUSH_KEY; secrets可填 +TG_BOT_TOKEN = '' # tg机器人的TG_BOT_TOKEN; secrets可填1407203283:AAG9rt-6RDaaX0HBLZQq0laNOh898iFYaRQ +TG_USER_ID = '' # tg机器人的TG_USER_ID; secrets可填 1434078534 +TG_API_HOST='' # tg 代理api +TG_PROXY_IP = '' # tg机器人的TG_PROXY_IP; secrets可填 +TG_PROXY_PORT = '' # tg机器人的TG_PROXY_PORT; secrets可填 +DD_BOT_TOKEN = '' # 钉钉机器人的DD_BOT_TOKEN; secrets可填 +DD_BOT_SECRET = '' # 钉钉机器人的DD_BOT_SECRET; secrets可填 +QQ_SKEY = '' # qq机器人的QQ_SKEY; secrets可填 +QQ_MODE = '' # qq机器人的QQ_MODE; secrets可填 +QYWX_AM = '' # 企业微信 +QYWX_KEY = '' # 企业微信BOT +PUSH_PLUS_TOKEN = '' # 微信推送Plus+ +FS_KEY = '' #飞书群BOT + +notify_mode = [] + +message_info = '''''' + +# GitHub action运行需要填写对应的secrets +if "BARK" in os.environ and os.environ["BARK"]: + BARK = os.environ["BARK"] +if "BARK_PUSH" in os.environ and os.environ["BARK_PUSH"]: + BARK_PUSH = os.environ["BARK_PUSH"] +if "PUSH_KEY" in os.environ and os.environ["PUSH_KEY"]: + PUSH_KEY = os.environ["PUSH_KEY"] +if "TG_BOT_TOKEN" in os.environ and os.environ["TG_BOT_TOKEN"] and "TG_USER_ID" in os.environ and os.environ["TG_USER_ID"]: + TG_BOT_TOKEN = os.environ["TG_BOT_TOKEN"] + TG_USER_ID = os.environ["TG_USER_ID"] +if "TG_API_HOST" in os.environ and os.environ["TG_API_HOST"]: + TG_API_HOST = os.environ["TG_API_HOST"] +if "DD_BOT_TOKEN" in os.environ and os.environ["DD_BOT_TOKEN"] and "DD_BOT_SECRET" in os.environ and os.environ["DD_BOT_SECRET"]: + DD_BOT_TOKEN = os.environ["DD_BOT_TOKEN"] + DD_BOT_SECRET = os.environ["DD_BOT_SECRET"] +if "QQ_SKEY" in os.environ and os.environ["QQ_SKEY"] and "QQ_MODE" in os.environ and os.environ["QQ_MODE"]: + QQ_SKEY = os.environ["QQ_SKEY"] + QQ_MODE = os.environ["QQ_MODE"] +# 获取pushplus+ PUSH_PLUS_TOKEN +if "PUSH_PLUS_TOKEN" in os.environ: + if len(os.environ["PUSH_PLUS_TOKEN"]) > 1: + PUSH_PLUS_TOKEN = os.environ["PUSH_PLUS_TOKEN"] + # print("已获取并使用Env环境 PUSH_PLUS_TOKEN") +# 获取企业微信应用推送 QYWX_AM +if "QYWX_AM" in os.environ: + if len(os.environ["QYWX_AM"]) > 1: + QYWX_AM = os.environ["QYWX_AM"] + + +if "QYWX_KEY" in os.environ: + if len(os.environ["QYWX_KEY"]) > 1: + QYWX_KEY = os.environ["QYWX_KEY"] + # print("已获取并使用Env环境 QYWX_AM") + +#接入飞书webhook推送 +if "FS_KEY" in os.environ: + if len(os.environ["FS_KEY"]) > 1: + FS_KEY = os.environ["FS_KEY"] + + +if BARK: + notify_mode.append('bark') + # print("BARK 推送打开") +if BARK_PUSH: + notify_mode.append('bark') + # print("BARK 推送打开") +if PUSH_KEY: + notify_mode.append('sc_key') + # print("Server酱 推送打开") +if TG_BOT_TOKEN and TG_USER_ID: + notify_mode.append('telegram_bot') + # print("Telegram 推送打开") +if DD_BOT_TOKEN and DD_BOT_SECRET: + notify_mode.append('dingding_bot') + # print("钉钉机器人 推送打开") +if QQ_SKEY and QQ_MODE: + notify_mode.append('coolpush_bot') + # print("QQ机器人 推送打开") + +if PUSH_PLUS_TOKEN: + notify_mode.append('pushplus_bot') + # print("微信推送Plus机器人 推送打开") +if QYWX_AM: + notify_mode.append('wecom_app') + # print("企业微信机器人 推送打开") + +if QYWX_KEY: + notify_mode.append('wecom_key') + # print("企业微信机器人 推送打开") + +if FS_KEY: + notify_mode.append('fs_key') + # print("飞书机器人 推送打开") + +def message(str_msg): + global message_info + print(str_msg) + message_info = "{}\n{}".format(message_info, str_msg) + sys.stdout.flush() + +def bark(title, content): + print("\n") + if BARK: + try: + response = requests.get( + f"""https://api.day.app/{BARK}/{title}/{urllib.parse.quote_plus(content)}""").json() + if response['code'] == 200: + print('推送成功！') + else: + print('推送失败！') + except: + print('推送失败！') + if BARK_PUSH: + try: + response = requests.get( + f"""{BARK_PUSH}/{title}/{urllib.parse.quote_plus(content)}""").json() + if response['code'] == 200: + print('推送成功！') + else: + print('推送失败！') + except: + print('推送失败！') + print("bark服务启动") + if BARK=='' and BARK_PUSH=='': + print("bark服务的bark_token未设置!!\n取消推送") + return + +def serverJ(title, content): + print("\n") + if not PUSH_KEY: + print("server酱服务的PUSH_KEY未设置!!\n取消推送") + return + print("serverJ服务启动") + data = { + "text": title, + "desp": content.replace("\n", "\n\n") + } + response = requests.post(f"https://sc.ftqq.com/{PUSH_KEY}.send", data=data).json() + if response['errno'] == 0: + print('推送成功！') + else: + print('推送失败！') + +# tg通知 +def telegram_bot(title, content): + try: + print("\n") + bot_token = TG_BOT_TOKEN + user_id = TG_USER_ID + if not bot_token or not user_id: + print("tg服务的bot_token或者user_id未设置!!\n取消推送") + return + print("tg服务启动") + if TG_API_HOST: + if 'http' in TG_API_HOST: + url = f"{TG_API_HOST}/bot{TG_BOT_TOKEN}/sendMessage" + else: + url = f"https://{TG_API_HOST}/bot{TG_BOT_TOKEN}/sendMessage" + else: + url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage" + + headers = {'Content-Type': 'application/x-www-form-urlencoded'} + payload = {'chat_id': str(TG_USER_ID), 'text': f'{title}\n\n{content}', 'disable_web_page_preview': 'true'} + proxies = None + if TG_PROXY_IP and TG_PROXY_PORT: + proxyStr = "http://{}:{}".format(TG_PROXY_IP, TG_PROXY_PORT) + proxies = {"http": proxyStr, "https": proxyStr} + try: + response = requests.post(url=url, headers=headers, params=payload, proxies=proxies).json() + except: + print('推送失败！') + if response['ok']: + print('推送成功！') + else: + print('推送失败！') + except Exception as e: + print(e) + +def dingding_bot(title, content): + timestamp = str(round(time.time() * 1000)) # 时间戳 + secret_enc = DD_BOT_SECRET.encode('utf-8') + string_to_sign = '{}\n{}'.format(timestamp, DD_BOT_SECRET) + string_to_sign_enc = string_to_sign.encode('utf-8') + hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest() + sign = urllib.parse.quote_plus(base64.b64encode(hmac_code)) # 签名 + print('开始使用 钉钉机器人 推送消息...', end='') + url = f'https://oapi.dingtalk.com/robot/send?access_token={DD_BOT_TOKEN}×tamp={timestamp}&sign={sign}' + headers = {'Content-Type': 'application/json;charset=utf-8'} + data = { + 'msgtype': 'text', + 'text': {'content': f'{title}\n\n{content}'} + } + response = requests.post(url=url, data=json.dumps(data), headers=headers, timeout=15).json() + if not response['errcode']: + print('推送成功！') + else: + print('推送失败！') + +def coolpush_bot(title, content): + print("\n") + if not QQ_SKEY or not QQ_MODE: + print("qq服务的QQ_SKEY或者QQ_MODE未设置!!\n取消推送") + return + print("qq服务启动") + url=f"https://qmsg.zendee.cn/{QQ_MODE}/{QQ_SKEY}" + payload = {'msg': f"{title}\n\n{content}".encode('utf-8')} + response = requests.post(url=url, params=payload).json() + if response['code'] == 0: + print('推送成功！') + else: + print('推送失败！') +# push推送 +def pushplus_bot(title, content): + try: + print("\n") + if not PUSH_PLUS_TOKEN: + print("PUSHPLUS服务的token未设置!!\n取消推送") + return + print("PUSHPLUS服务启动") + url = 'http://www.pushplus.plus/send' + data = { + "token": PUSH_PLUS_TOKEN, + "title": title, + "content": content + } + body = json.dumps(data).encode(encoding='utf-8') + headers = {'Content-Type': 'application/json'} + response = requests.post(url=url, data=body, headers=headers).json() + if response['code'] == 200: + print('推送成功！') + else: + print('推送失败！') + except Exception as e: + print(e) + + +def wecom_key(title, content): + print("\n") + if not QYWX_KEY: + print("QYWX_KEY未设置!!\n取消推送") + return + print("QYWX_KEY服务启动") + print("content"+content) + headers = {'Content-Type': 'application/json'} + data = { + "msgtype":"text", + "text":{ + "content":title+"\n"+content.replace("\n", "\n\n") + } + } + + print(f"https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={QYWX_KEY}") + response = requests.post(f"https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={QYWX_KEY}", json=data,headers=headers).json() + print(response) + +# 飞书机器人推送 +def fs_key(title, content): + print("\n") + if not FS_KEY: + print("FS_KEY未设置!!\n取消推送") + return + print("FS_KEY服务启动") + print("content"+content) + headers = {'Content-Type': 'application/json'} + data = { + "msg_type":"text", + "content":{ + "text":title+"\n"+content.replace("\n", "\n\n") + } + } + + print(f"https://open.feishu.cn/open-apis/bot/v2/hook/{FS_KEY}") + response = requests.post(f"https://open.feishu.cn/open-apis/bot/v2/hook/{FS_KEY}", json=data,headers=headers).json() + print(response) + + +# 企业微信 APP 推送 +def wecom_app(title, content): + try: + if not QYWX_AM: + print("QYWX_AM 并未设置！！\n取消推送") + return + QYWX_AM_AY = re.split(',', QYWX_AM) + if 4 < len(QYWX_AM_AY) > 5: + print("QYWX_AM 设置错误！！\n取消推送") + return + corpid = QYWX_AM_AY[0] + corpsecret = QYWX_AM_AY[1] + touser = QYWX_AM_AY[2] + agentid = QYWX_AM_AY[3] + try: + media_id = QYWX_AM_AY[4] + except: + media_id = '' + wx = WeCom(corpid, corpsecret, agentid) + # 如果没有配置 media_id 默认就以 text 方式发送 + if not media_id: + message = title + '\n\n' + content + response = wx.send_text(message, touser) + else: + response = wx.send_mpnews(title, content, media_id, touser) + if response == 'ok': + print('推送成功！') + else: + print('推送失败！错误信息如下：\n', response) + except Exception as e: + print(e) + +class WeCom: + def __init__(self, corpid, corpsecret, agentid): + self.CORPID = corpid + self.CORPSECRET = corpsecret + self.AGENTID = agentid + + def get_access_token(self): + url = 'https://qyapi.weixin.qq.com/cgi-bin/gettoken' + values = {'corpid': self.CORPID, + 'corpsecret': self.CORPSECRET, + } + req = requests.post(url, params=values) + data = json.loads(req.text) + return data["access_token"] + + def send_text(self, message, touser="@all"): + send_url = 'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=' + self.get_access_token() + send_values = { + "touser": touser, + "msgtype": "text", + "agentid": self.AGENTID, + "text": { + "content": message + }, + "safe": "0" + } + send_msges = (bytes(json.dumps(send_values), 'utf-8')) + respone = requests.post(send_url, send_msges) + respone = respone.json() + return respone["errmsg"] + + def send_mpnews(self, title, message, media_id, touser="@all"): + send_url = 'https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=' + self.get_access_token() + send_values = { + "touser": touser, + "msgtype": "mpnews", + "agentid": self.AGENTID, + "mpnews": { + "articles": [ + { + "title": title, + "thumb_media_id": media_id, + "author": "Author", + "content_source_url": "", + "content": message.replace('\n', '
'), + "digest": message + } + ] + } + } + send_msges = (bytes(json.dumps(send_values), 'utf-8')) + respone = requests.post(send_url, send_msges) + respone = respone.json() + return respone["errmsg"] + +def send(title, content): + """ + 使用 bark, telegram bot, dingding bot, server, feishuJ 发送手机推送 + :param title: + :param content: + :return: + """ + + for i in notify_mode: + if i == 'bark': + if BARK or BARK_PUSH: + bark(title=title, content=content) + else: + print('未启用 bark') + continue + if i == 'sc_key': + if PUSH_KEY: + serverJ(title=title, content=content) + else: + print('未启用 Server酱') + continue + elif i == 'dingding_bot': + if DD_BOT_TOKEN and DD_BOT_SECRET: + dingding_bot(title=title, content=content) + else: + print('未启用 钉钉机器人') + continue + elif i == 'telegram_bot': + if TG_BOT_TOKEN and TG_USER_ID: + telegram_bot(title=title, content=content) + else: + print('未启用 telegram机器人') + continue + elif i == 'coolpush_bot': + if QQ_SKEY and QQ_MODE: + coolpush_bot(title=title, content=content) + else: + print('未启用 QQ机器人') + continue + elif i == 'pushplus_bot': + if PUSH_PLUS_TOKEN: + pushplus_bot(title=title, content=content) + else: + print('未启用 PUSHPLUS机器人') + continue + elif i == 'wecom_app': + if QYWX_AM: + wecom_app(title=title, content=content) + else: + print('未启用企业微信应用消息推送') + continue + elif i == 'wecom_key': + if QYWX_KEY: + + for i in range(int(len(content)/2000)+1): + wecom_key(title=title, content=content[i*2000:(i+1)*2000]) + else: + print('未启用企业微信应用消息推送') + continue + elif i == 'fs_key': + if FS_KEY: + fs_key(title=title, content=content) + else: + print('未启用飞书机器人消息推送') + continue + else: + print('此类推送方式不存在') + + +def main(): + send('title', 'content') + + +if __name__ == '__main__': + main() diff --git a/小程序打卡/小程序打卡/test_info.py b/小程序打卡/小程序打卡/test_info.py new file mode 100644 index 0000000..46f56aa --- /dev/null +++ b/小程序打卡/小程序打卡/test_info.py @@ -0,0 +1,300 @@ +""" +小程序打卡信息测试脚本（不执行实际打卡） + +=== 配置说明 === + +环境变量配置： +变量名: hxza_dk + +说明: +- 此脚本仅用于测试，只获取信息，不执行实际打卡 +- 会显示：用户信息、班次信息、打卡时间窗口等 + +""" + +import requests +import os +import logging +from datetime import datetime +from typing import Dict, Optional, Tuple +from requests.adapters import HTTPAdapter +from urllib3.util.retry import Retry + +# 配置日志 +logging.basicConfig( + level=logging.INFO, + format='%(message)s', + handlers=[logging.StreamHandler()] +) + +logger = logging.getLogger(__name__) + + +class CheckInInfoTest: + """打卡信息测试类（不执行实际打卡）""" + + def __init__(self): + self.base_url = "https://erp.baian.tech/baian-admin" + + # 解析环境变量 + config = os.getenv('hxza_dk', '') + if not config: + error_msg = "❌ 缺少环境变量 hxza_dk" + logger.error(error_msg) + raise ValueError(error_msg) + + parts = config.split('#') + self.token = parts[0].strip() + self.remark = parts[1].strip() if len(parts) > 1 else "" + + # 配置带重试的 session + self.session = self._create_session() + + # 动态获取的用户信息 + self.user_name = None + self.user_mobile = None + + # 动态获取的班次时间 + self.start_time = None # 上班时间（如 "23:00"） + self.end_time = None # 下班时间（如 "07:00"） + self.is_cross_day = False # 是否跨天 + + # 固定参数 + self.app_id = "wxa81d5d83880ea6b6" + + # 动态参数（从班次信息接口获取） + self.item_id = None + self.job_date_id = None + self.job_id = None + self.address_name = None + self.longitude = None + self.latitude = None + + self.headers = { + 'Host': 'erp.baian.tech', + 'Connection': 'keep-alive', + 'appId': self.app_id, + 'content-type': 'application/json', + 'wxAppKeyCompanyId': self.app_id, + 'token': self.token, + 'Accept-Encoding': 'gzip,compress,br,deflate', + 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1', + 'Referer': f"https://servicewechat.com/{self.app_id}/102/page-frame.html" + } + + logger.info("=" * 60) + logger.info("📋 打卡信息测试（不执行实际打卡）") + logger.info("=" * 60) + + # 初始化时获取用户信息 + if not self._fetch_user_info(): + raise ValueError("❌ 获取用户信息失败") + + # 初始化时获取班次信息 + if not self._fetch_job_details(): + raise ValueError("❌ 获取班次信息失败") + + # 显示打卡时间窗口 + self._show_checkin_windows() + + def _create_session(self) -> requests.Session: + """创建带重试机制的 session""" + session = requests.Session() + retry = Retry( + total=3, + backoff_factor=1, + status_forcelist=[500, 502, 503, 504], + allowed_methods=["POST", "GET"] + ) + adapter = HTTPAdapter(max_retries=retry) + session.mount('https://', adapter) + session.mount('http://', adapter) + return session + + def _fetch_user_info(self) -> bool: + """获取用户信息（姓名、手机号等）""" + try: + logger.info("\n🔍 正在获取用户信息...") + url = f"{self.base_url}/userH5/getMyDetails" + + response = self.session.get(url, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取用户信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取用户信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + self.user_name = data.get('name', '') + self.user_mobile = data.get('mobile', '') + + # 显示备注或姓名 + display_name = self.remark if self.remark else self.user_name + logger.info(f"✅ 用户信息获取成功") + logger.info(f" 👤 姓名: {display_name}") + logger.info(f" 📱 手机: {self.user_mobile}") + + return True + + except Exception as e: + logger.error(f"❌ 获取用户信息异常: {str(e)}") + return False + + def _fetch_job_details(self) -> bool: + """获取班次信息（itemId、jobDateId、经纬度、班次时间等）""" + try: + logger.info("\n🔍 正在获取班次信息...") + url = f"{self.base_url}/Management/getJobUserDetails" + params = {"userId": ""} + + response = self.session.get(url, params=params, headers=self.headers, timeout=15) + + if response.status_code != 200: + logger.error(f"❌ 获取班次信息失败: HTTP {response.status_code}") + return False + + result = response.json() + if result.get('code') != 200: + logger.error(f"❌ 获取班次信息失败: {result.get('msg')}") + return False + + data = result.get('data', {}) + + # 提取 itemId 和 jobId + self.item_id = data.get('itemId') + self.job_id = data.get('jobId') + + # 提取班次时段信息 + job_date_dtos = data.get('jobDateDTOS', []) + if job_date_dtos: + job_date = job_date_dtos[0] + self.job_date_id = job_date.get('jobDateId') + self.start_time = job_date.get('startDate') # 如 "23:00" + self.end_time = job_date.get('endDate') # 如 "07:00" + self.is_cross_day = job_date.get('ismorrow') == 1 # 是否跨天 + + # 提取地址信息（经纬度） + address_dtos = data.get('addressDTOS', []) + if address_dtos: + address = address_dtos[0] + self.address_name = address.get('addressName') + self.longitude = float(address.get('longitude')) + self.latitude = float(address.get('latitude')) + + # 验证必需参数 + if not all([self.item_id, self.job_date_id, self.address_name, self.longitude, self.latitude, self.start_time, self.end_time]): + logger.error(f"❌ 班次信息不完整") + return False + + logger.info(f"✅ 班次信息获取成功") + logger.info(f" 📍 打卡地点: {self.address_name}") + logger.info(f" 🌐 经纬度: {self.longitude}, {self.latitude}") + logger.info(f" ⏰ 班次时间: {self.start_time} - {self.end_time}{' (跨天)' if self.is_cross_day else ''}") + # logger.info(f" 🆔 项目ID: {self.item_id}") + # logger.info(f" 🆔 班次ID: {self.job_id}") + # logger.info(f" 🆔 时段ID: {self.job_date_id}") + + return True + + except Exception as e: + logger.error(f"❌ 获取班次信息异常: {str(e)}") + return False + + def _time_to_minutes(self, time_str: str) -> int: + """时间字符串转为分钟数""" + h, m = map(int, time_str.split(':')) + return h * 60 + m + + def _minutes_to_time(self, minutes: int) -> str: + """分钟数转时间字符串""" + h, m = divmod(minutes % 1440, 60) + return f"{h:02d}:{m:02d}" + + def _get_checkin_windows(self) -> Tuple[Tuple[int, int], Tuple[int, int]]: + """ + 根据班次时间，自动计算打卡时间窗口 + + 规则： + - 第一次打卡（上班）：start_time 前2小时 到 start_time + - 第二次打卡（下班）：end_time+1分钟 到 (start_time - 2小时 - 1分钟) + + Returns: + ((first_start, first_end), (second_start, second_end)) 分钟数 + """ + start_minutes = self._time_to_minutes(self.start_time) + end_minutes = self._time_to_minutes(self.end_time) + + # 第一次打卡窗口：start_time - 120分钟 到 start_time + first_start = (start_minutes - 120) % 1440 # 1440 = 24*60 + first_end = start_minutes + + # 第二次打卡窗口：end_time + 1分钟 到 (start_time - 121分钟) + second_start = (end_minutes + 1) % 1440 + second_end = (start_minutes - 121) % 1440 + + return (first_start, first_end), (second_start, second_end) + + def _is_in_window(self, current_minutes: int, start: int, end: int) -> bool: + """检查当前时间是否在窗口内""" + if start <= end: + # 同一天内的窗口（如 21:00-23:00） + return start <= current_minutes <= end + else: + # 跨天的窗口（如 23:00-05:59 跨天） + return current_minutes >= start or current_minutes <= end + + def _show_checkin_windows(self): + """显示打卡时间窗口信息""" + logger.info("\n📅 打卡时间窗口:") + + (first_start, first_end), (second_start, second_end) = self._get_checkin_windows() + + first_start_str = self._minutes_to_time(first_start) + first_end_str = self._minutes_to_time(first_end) + second_start_str = self._minutes_to_time(second_start) + second_end_str = self._minutes_to_time(second_end) + + logger.info(f" 🌅 上班打卡窗口: {first_start_str} - {first_end_str}") + logger.info(f" 🌆 下班打卡窗口: {second_start_str} - {second_end_str}") + + # 检查当前时间 + now = datetime.now() + current_minutes = now.hour * 60 + now.minute + current_time_str = now.strftime('%H:%M:%S') + + logger.info(f"\n🕐 当前时间: {current_time_str}") + + if self._is_in_window(current_minutes, first_start, first_end): + logger.info(f" ✅ 当前在【上班打卡】窗口内") + elif self._is_in_window(current_minutes, second_start, second_end): + logger.info(f" ✅ 当前在【下班打卡】窗口内") + else: + logger.info(f" ⏰ 当前不在任何打卡窗口内") + + +def main(): + """主函数""" + try: + logger.info("\n🚀 开始测试...\n") + test = CheckInInfoTest() + + logger.info("\n" + "=" * 60) + logger.info("✅ 所有信息获取成功！") + logger.info("=" * 60) + logger.info("\n💡 提示: 这是测试模式，未执行实际打卡操作") + logger.info("💡 如需执行打卡，请运行 auto_checkin.py\n") + + except KeyboardInterrupt: + logger.info("\n⚠️ 用户中断程序") + except Exception as e: + error_msg = f"\n❌ 程序异常: {str(e)}" + logger.error(error_msg) + exit(1) + + +if __name__ == '__main__': + main()