659 lines
24 KiB
Python
659 lines
24 KiB
Python
"""字段监控（多平台适配版）"""
|
|
import sys
|
|
from pathlib import Path
|
|
import pandas as pd
|
|
import zipfile
|
|
from datetime import datetime, timezone, timedelta, date
|
|
import requests
|
|
from typing import Optional, List, Dict, Any
|
|
from decimal import Decimal
|
|
import time
|
|
import numpy as np
|
|
import json
|
|
|
|
|
|
def replace_decimals(obj):
|
|
"""替换Decimal类型为float"""
|
|
if isinstance(obj, dict):
|
|
return {k: replace_decimals(v) for k, v in obj.items()}
|
|
elif isinstance(obj, list):
|
|
return [replace_decimals(item) for item in obj]
|
|
elif isinstance(obj, Decimal):
|
|
return float(obj)
|
|
return obj
|
|
|
|
|
|
class NpEncoder(json.JSONEncoder):
|
|
"""NumPy类型JSON编码器"""
|
|
def default(self, obj):
|
|
if isinstance(obj, np.integer):
|
|
return int(obj)
|
|
elif isinstance(obj, np.floating):
|
|
return float(obj)
|
|
elif isinstance(obj, np.ndarray):
|
|
return obj.tolist()
|
|
else:
|
|
return super(NpEncoder, self).default(obj)
|
|
|
|
|
|
# ---------------------------- 配置项（多平台适配）---------------------------
|
|
class Config:
|
|
# 基础路径（使用Path对象自动处理跨平台路径）
|
|
BASE_DIR = Path(__file__).parent.absolute()
|
|
OUTPUT_DIR = BASE_DIR / "output"
|
|
|
|
# 数据存储目录（英文命名避免编码问题）
|
|
DATA_DIR = OUTPUT_DIR / "data_snapshots"
|
|
ARCHIVE_DIR = OUTPUT_DIR / "archives"
|
|
|
|
# API配置
|
|
JIANDAOYUN_API_TOKEN = "Bearer qygHulymo1fekJk4CIZyNKjyQAzG8CFN"
|
|
|
|
# 运行参数
|
|
RETAIN_DAYS = 7
|
|
COMPRESS_FORMAT = "zip"
|
|
MAX_RETRIES = 3
|
|
RETRY_DELAY = 0.5 # 秒
|
|
|
|
# 监控表单配置
|
|
MONITOR_APP_ID = "6694d3c4fcb69ca9a111a6c4"
|
|
MONITOR_ENTRY_ID = "6850c044f17c934b3ec01fea"
|
|
CHANGES_ENTRY_ID = "6863a402a77925690a470cc5"
|
|
STATUS_ENTRY_ID = "67ede908eb9c22261016466e"
|
|
|
|
@classmethod
|
|
def get_log_file(cls):
|
|
"""获取跨平台兼容的日志文件路径"""
|
|
return cls.OUTPUT_DIR / "data_monitor.log"
|
|
|
|
@classmethod
|
|
def get_changes_file(cls):
|
|
"""获取跨平台兼容的变更记录文件路径"""
|
|
return cls.OUTPUT_DIR / "changes_summary.csv"
|
|
|
|
|
|
# ---------------------- 工具函数（多平台兼容）-----------------------
|
|
class Utils:
|
|
@staticmethod
|
|
def ensure_dir(path):
|
|
"""确保目录存在（自动处理Path对象或字符串）"""
|
|
path = Path(path) if not isinstance(path, Path) else path
|
|
try:
|
|
path.mkdir(parents=True, exist_ok=True)
|
|
return True
|
|
except Exception as e:
|
|
print(f"创建目录失败: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def get_iso_time():
|
|
"""获取ISO格式的UTC时间"""
|
|
return datetime.now(timezone.utc).isoformat(timespec='milliseconds') + "Z"
|
|
|
|
@staticmethod
|
|
def is_first_run_today():
|
|
"""检查是否是今天的第一次运行"""
|
|
today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
|
|
snapshot_file = Config.DATA_DIR / f"snapshot_{today}.csv"
|
|
widget_file = Config.DATA_DIR / f"all_widgets_{today}.csv"
|
|
return not (snapshot_file.exists() and widget_file.exists())
|
|
|
|
@staticmethod
|
|
def safe_csv_write(df, file_path):
|
|
"""安全的CSV写入（带临时文件和错误处理）"""
|
|
file_path = Path(file_path)
|
|
temp_file = file_path.parent / (file_path.name + '.tmp')
|
|
|
|
try:
|
|
df.to_csv(temp_file, index=False, encoding='utf-8-sig')
|
|
if file_path.exists():
|
|
file_path.unlink()
|
|
temp_file.rename(file_path)
|
|
return True
|
|
except Exception as e:
|
|
print(f"CSV写入失败: {e}")
|
|
if temp_file.exists():
|
|
temp_file.unlink()
|
|
return False
|
|
|
|
|
|
# ---------------------- API客户端（多平台兼容）-----------------------
|
|
class APIClient:
|
|
def __init__(self):
|
|
self.headers = {
|
|
'Authorization': Config.JIANDAOYUN_API_TOKEN,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
|
|
def request(self, url, payload, method='POST'):
|
|
"""带重试机制的API请求"""
|
|
for retry in range(Config.MAX_RETRIES + 1):
|
|
try:
|
|
response = requests.request(
|
|
method, url,
|
|
headers=self.headers,
|
|
data=payload,
|
|
timeout=30
|
|
)
|
|
response.raise_for_status()
|
|
return response
|
|
except requests.exceptions.RequestException as e:
|
|
if retry == Config.MAX_RETRIES:
|
|
raise
|
|
time.sleep(Config.RETRY_DELAY)
|
|
|
|
def data_batch_create(self, data: dict, max_retries: int = 20) -> Optional[Dict]:
|
|
"""新建单条表单数据"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/create'
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data": data['data'],
|
|
"is_start_workflow": data.get('is_start_workflow', "false"),
|
|
"is_start_trigger": data.get('is_start_trigger', "false"),
|
|
"transaction_id": data.get('transaction_id', "")
|
|
})
|
|
|
|
for retry in range(max_retries + 1):
|
|
try:
|
|
response = requests.post(url=url, data=payload, headers=self.headers, timeout=10)
|
|
response.raise_for_status()
|
|
return response.json()
|
|
except requests.exceptions.RequestException as e:
|
|
if retry == max_retries:
|
|
print(f"创建数据失败: {e}")
|
|
return None
|
|
time.sleep(3)
|
|
|
|
def entry_data_list(self, data: dict, max_retries: int = 20) -> Dict:
|
|
"""获取多条表单数据"""
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/list'
|
|
all_data_batches = []
|
|
last_data_id = None
|
|
|
|
while True:
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"limit": 100,
|
|
"data_id": last_data_id
|
|
})
|
|
|
|
for retry in range(max_retries + 1):
|
|
try:
|
|
response = requests.post(url=url, data=payload, headers=self.headers, timeout=10)
|
|
response.raise_for_status()
|
|
data_get = response.json()
|
|
|
|
if data_get.get("data"):
|
|
all_data_batches.extend(data_get['data'])
|
|
last_data_id = data_get['data'][-1].get('_id')
|
|
break
|
|
else:
|
|
return {"data": all_data_batches}
|
|
|
|
except requests.exceptions.RequestException as e:
|
|
if retry == max_retries:
|
|
print(f"获取数据列表失败: {e}")
|
|
return {"data": all_data_batches}
|
|
time.sleep(0.1)
|
|
|
|
if not data_get.get("data") or len(data_get['data']) < 100:
|
|
break
|
|
|
|
return {"data": all_data_batches}
|
|
|
|
def entry_data_batch_create(self, data: dict, chunk_size: int = 90, max_retries: int = 20) -> List[Optional[Dict]]:
|
|
"""新建多条数据"""
|
|
data = replace_decimals(data)
|
|
url = 'https://api.jiandaoyun.com/api/v5/app/entry/data/batch_create'
|
|
data_get_list = []
|
|
|
|
total_length = len(data['data_list'])
|
|
num_chunks = (total_length + chunk_size - 1) // chunk_size
|
|
|
|
for i in range(num_chunks):
|
|
start_index = i * chunk_size
|
|
end_index = min(start_index + chunk_size, total_length)
|
|
|
|
payload = json.dumps({
|
|
"app_id": data['api_key'],
|
|
"entry_id": data['entry_id'],
|
|
"data_list": data['data_list'][start_index:end_index],
|
|
"is_start_workflow": data.get('is_start_workflow', "false"),
|
|
"is_start_trigger": data.get('is_start_trigger', "false"),
|
|
}, cls=NpEncoder)
|
|
|
|
for retry in range(max_retries + 1):
|
|
try:
|
|
response = requests.post(url=url, data=payload, headers=self.headers, timeout=10)
|
|
response.raise_for_status()
|
|
data_get = response.json()
|
|
if data_get.get("status") == "success":
|
|
data_get_list.append(data_get)
|
|
break
|
|
except requests.exceptions.RequestException as e:
|
|
if retry == max_retries:
|
|
print(f"批量创建数据失败: {e}")
|
|
data_get_list.append(None)
|
|
time.sleep(0.1)
|
|
|
|
return data_get_list
|
|
|
|
|
|
# ---------------------- 数据处理基类 -----------------------
|
|
class DataHandler:
|
|
def __init__(self):
|
|
self.execution_time = Utils.get_iso_time()
|
|
self.today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
|
|
self.setup_dirs()
|
|
self.api = APIClient()
|
|
|
|
def setup_dirs(self):
|
|
"""初始化所有需要的目录"""
|
|
self.data_dir = Config.DATA_DIR
|
|
self.archive_dir = Config.ARCHIVE_DIR
|
|
Utils.ensure_dir(self.data_dir)
|
|
Utils.ensure_dir(self.archive_dir)
|
|
|
|
# 初始化数据文件路径
|
|
self.last_data_file = self.data_dir / "last_data.csv"
|
|
self.last_widget_file = self.data_dir / "last_widget_data.csv"
|
|
|
|
def load_last_data(self):
|
|
"""加载上次运行的数据"""
|
|
try:
|
|
last_data = pd.read_csv(self.last_data_file) if self.last_data_file.exists() else None
|
|
last_widget = pd.read_csv(self.last_widget_file) if self.last_widget_file.exists() else None
|
|
return last_data, last_widget
|
|
except Exception as e:
|
|
print(f"加载上次数据失败: {e}")
|
|
return None, None
|
|
|
|
def save_last_data(self, data, widget_data):
|
|
"""保存当前数据供下次比较"""
|
|
try:
|
|
success = Utils.safe_csv_write(data, self.last_data_file)
|
|
success &= Utils.safe_csv_write(widget_data, self.last_widget_file)
|
|
return success
|
|
except Exception as e:
|
|
print(f"保存数据失败: {e}")
|
|
return False
|
|
|
|
def field_replacement(self, data, final_data):
|
|
"""字段替换方法（由id替换为标签名）"""
|
|
# 这里实现具体的字段替换逻辑
|
|
# 由于具体替换规则未知，返回原始数据
|
|
return final_data
|
|
|
|
|
|
# ---------------------- 数据监控主类 -----------------------
|
|
class DataMonitor(DataHandler):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.last_data, self.last_widget = self.load_last_data()
|
|
|
|
def fetch_apps(self):
|
|
"""获取所有应用列表"""
|
|
url = "https://api.jiandaoyun.com/api/v5/app/list"
|
|
payload = json.dumps({"skip": 0, "limit": 100})
|
|
try:
|
|
response = self.api.request(url, payload)
|
|
return pd.DataFrame(response.json().get("apps", []))
|
|
except Exception as e:
|
|
print(f"获取应用列表失败: {e}")
|
|
return pd.DataFrame()
|
|
|
|
def fetch_entries(self, app_df):
|
|
"""获取所有表单条目"""
|
|
url = "https://api.jiandaoyun.com/api/v5/app/entry/list"
|
|
all_entries = []
|
|
|
|
for _, app in app_df.iterrows():
|
|
payload = json.dumps({"app_id": app['app_id']})
|
|
try:
|
|
response = self.api.request(url, payload)
|
|
entries = response.json().get("forms", [])
|
|
|
|
if entries:
|
|
entry_df = pd.DataFrame(entries)
|
|
entry_df['app_id'] = app['app_id']
|
|
all_entries.append(entry_df)
|
|
except Exception as e:
|
|
print(f"获取表单条目失败: {e}")
|
|
continue
|
|
|
|
return pd.concat(all_entries, ignore_index=True) if all_entries else pd.DataFrame()
|
|
|
|
def fetch_widgets(self, entry_df):
|
|
"""获取所有字段组件"""
|
|
url = "https://api.jiandaoyun.com/api/v5/app/entry/widget/list"
|
|
all_widgets = []
|
|
|
|
for _, entry in entry_df.iterrows():
|
|
payload = json.dumps({
|
|
"app_id": entry['app_id'],
|
|
"entry_id": entry['entry_id']
|
|
})
|
|
try:
|
|
response = self.api.request(url, payload)
|
|
widgets = response.json().get('widgets', [])
|
|
|
|
if widgets:
|
|
widget_df = pd.DataFrame(widgets)
|
|
widget_df['app_id'] = entry['app_id']
|
|
widget_df['entry_id'] = entry['entry_id']
|
|
all_widgets.append(widget_df)
|
|
except Exception as e:
|
|
print(f"获取字段组件失败: {e}")
|
|
continue
|
|
|
|
return pd.concat(all_widgets, ignore_index=True) if all_widgets else pd.DataFrame()
|
|
|
|
def fetch_monitor_data(self):
|
|
"""获取监控数据"""
|
|
payload = {
|
|
"api_key": Config.MONITOR_APP_ID,
|
|
"entry_id": Config.MONITOR_ENTRY_ID
|
|
}
|
|
try:
|
|
data = self.api.entry_data_list(payload).get("data", [])
|
|
data_list = pd.DataFrame(data)
|
|
|
|
# 处理复杂数据类型
|
|
for col in data_list.columns:
|
|
if data_list[col].apply(lambda x: isinstance(x, (dict, list))).any():
|
|
data_list[col] = data_list[col].astype(str)
|
|
|
|
return data_list.drop_duplicates()
|
|
except Exception as e:
|
|
print(f"获取监控数据失败: {e}")
|
|
return pd.DataFrame()
|
|
|
|
def match_widgets(self, data_list, widget_list):
|
|
"""匹配数据列表和组件列表"""
|
|
if '_widget_1750122565203' not in data_list.columns:
|
|
print("缺少必需的列 '_widget_1750122565203'")
|
|
return pd.DataFrame()
|
|
|
|
if widget_list.empty:
|
|
return pd.DataFrame()
|
|
|
|
return widget_list[widget_list['entry_id'].isin(data_list['_widget_1750122565203'])]
|
|
|
|
def archive_old_data(self):
|
|
"""归档旧数据"""
|
|
keep_dates = [
|
|
(datetime.now(timezone.utc) - timedelta(days=i)).strftime("%Y-%m-%d")
|
|
for i in range(Config.RETAIN_DAYS)
|
|
]
|
|
|
|
files_to_archive = [
|
|
f for f in self.data_dir.iterdir()
|
|
if f.is_file() and
|
|
(f.name.startswith("snapshot_") or f.name.startswith("all_widgets_")) and
|
|
f.suffix == '.csv'
|
|
]
|
|
|
|
for file_path in files_to_archive:
|
|
date_str = file_path.stem[9:] if file_path.name.startswith("snapshot_") else file_path.stem[12:]
|
|
|
|
if date_str not in keep_dates:
|
|
year_month = date_str[:7]
|
|
archive_path = self.archive_dir / f"snapshots_{year_month}.{Config.COMPRESS_FORMAT}"
|
|
|
|
try:
|
|
with zipfile.ZipFile(archive_path, 'a', zipfile.ZIP_DEFLATED) as zipf:
|
|
zipf.write(file_path, arcname=file_path.name)
|
|
file_path.unlink()
|
|
except Exception as e:
|
|
print(f"归档文件失败: {e}")
|
|
|
|
def compare_data(self, current_data):
|
|
"""比较新旧数据差异"""
|
|
if not self.last_data_file.exists() or current_data.empty:
|
|
return None
|
|
|
|
try:
|
|
last_data = pd.read_csv(self.last_data_file)
|
|
if last_data.empty:
|
|
return None
|
|
|
|
last_data['unique_id'] = last_data['name'].astype(str) + last_data['app_id'].astype(str)
|
|
current_data['unique_id'] = current_data['name'].astype(str) + current_data['app_id'].astype(str)
|
|
|
|
merged = pd.merge(
|
|
last_data, current_data,
|
|
on=['unique_id'],
|
|
how='outer',
|
|
suffixes=('_last', '_current'),
|
|
indicator=True
|
|
)
|
|
|
|
changes = {
|
|
'added': merged[merged['_merge'] == 'right_only'],
|
|
'deleted': merged[merged['_merge'] == 'left_only'],
|
|
'modified': pd.DataFrame()
|
|
}
|
|
|
|
for col in ['label', 'type']:
|
|
last_col = f"{col}_last"
|
|
current_col = f"{col}_current"
|
|
|
|
if last_col in merged.columns and current_col in merged.columns:
|
|
mask = (merged['_merge'] == 'both') & (merged[last_col] != merged[current_col])
|
|
mask = mask & ~merged[last_col].isna() & ~merged[current_col].isna()
|
|
|
|
if mask.any():
|
|
modified = merged.loc[mask].copy()
|
|
modified['changed_field'] = col
|
|
modified['old_value'] = modified[last_col]
|
|
modified['new_value'] = modified[current_col]
|
|
modified['change_status'] = 'update'
|
|
changes['modified'] = pd.concat([changes['modified'], modified])
|
|
|
|
return changes
|
|
except Exception as e:
|
|
print(f"比较数据失败: {e}")
|
|
return None
|
|
|
|
def save_changes(self, changes, apps, entries):
|
|
"""保存变更记录"""
|
|
if not changes or all(len(v) == 0 for v in changes.values()):
|
|
return False
|
|
|
|
result_rows = []
|
|
|
|
for change_type in ['added', 'deleted', 'modified']:
|
|
df = changes[change_type]
|
|
if df.empty:
|
|
continue
|
|
|
|
suffix = 'current' if change_type in ['added', 'modified'] else 'last'
|
|
|
|
for _, row in df.iterrows():
|
|
app_id = row.get(f'app_id_{suffix}')
|
|
entry_id = row.get(f'entry_id_{suffix}')
|
|
|
|
if not app_id or not entry_id:
|
|
continue
|
|
|
|
app_name = 'Unknown App'
|
|
entry_name = 'Unknown Entry'
|
|
|
|
if not apps.empty:
|
|
app_match = apps[apps['app_id'] == app_id]
|
|
if not app_match.empty:
|
|
app_name = app_match['name'].values[0]
|
|
|
|
if not entries.empty:
|
|
entry_match = entries[(entries['app_id'] == app_id) & (entries['entry_id'] == entry_id)]
|
|
if not entry_match.empty:
|
|
entry_name = entry_match['name'].values[0]
|
|
|
|
if change_type == 'added':
|
|
content = f"Added field: {row.get('label_current', 'Unknown')}"
|
|
elif change_type == 'deleted':
|
|
content = f"Deleted field: {row.get('label_last', 'Unknown')}"
|
|
else:
|
|
content = f"Changed from \"{row.get('old_value', 'Unknown')}\" to \"{row.get('new_value', 'Unknown')}\""
|
|
|
|
result_rows.append({
|
|
'timestamp': self.execution_time,
|
|
'unique_id': row.get('unique_id', ''),
|
|
'app_id': app_id,
|
|
'app_name': app_name,
|
|
'entry_id': entry_id,
|
|
'entry_name': entry_name,
|
|
'change_type': change_type,
|
|
'details': content
|
|
})
|
|
|
|
if result_rows:
|
|
result_df = pd.DataFrame(result_rows)
|
|
changes_file = Config.get_changes_file()
|
|
try:
|
|
result_df.to_csv(
|
|
changes_file,
|
|
mode='a',
|
|
header=not changes_file.exists(),
|
|
index=False,
|
|
encoding='utf-8-sig'
|
|
)
|
|
self.add_to_jiandaoyun(result_df)
|
|
return True
|
|
except Exception as e:
|
|
print(f"保存变更记录失败: {e}")
|
|
return False
|
|
return False
|
|
|
|
def add_to_jiandaoyun(self, result_df):
|
|
"""将变更记录写入简道云"""
|
|
all_data = [{
|
|
"_widget_1751446961315": {"value": row["app_name"]},
|
|
"_widget_1751446961316": {"value": row["entry_name"]},
|
|
"_widget_1751446961317": {"value": row["change_type"]},
|
|
"_widget_1751446961318": {"value": row["details"]},
|
|
"_widget_1751446961319": {"value": row["timestamp"]},
|
|
} for _, row in result_df.iterrows()]
|
|
|
|
payload = {
|
|
"api_key": Config.MONITOR_APP_ID,
|
|
"entry_id": Config.CHANGES_ENTRY_ID,
|
|
"data_list": all_data
|
|
}
|
|
|
|
try:
|
|
response = self.api.entry_data_batch_create(payload)
|
|
return isinstance(response, list) and len(response) > 0
|
|
except Exception as e:
|
|
print(f"写入简道云失败: {e}")
|
|
return False
|
|
|
|
def send_task_status(self, task_start_time: str, task_name: str) -> None:
|
|
"""将任务状态发送到简道云"""
|
|
try:
|
|
end_time_utc = datetime.now(timezone.utc)
|
|
task_start_naive = datetime.strptime(task_start_time, "%Y-%m-%d %H:%M:%S")
|
|
task_start_utc = task_start_naive - timedelta(hours=8)
|
|
task_start_utc = task_start_utc.replace(tzinfo=timezone.utc)
|
|
|
|
run_time = end_time_utc - task_start_utc
|
|
run_time_sec = int(run_time.total_seconds())
|
|
|
|
today_utc = end_time_utc.strftime("%Y-%m-%d")
|
|
task_end_iso = end_time_utc.strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
task_start_iso = task_start_utc.strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
|
|
payload = {
|
|
"api_key": Config.MONITOR_APP_ID,
|
|
"entry_id": Config.STATUS_ENTRY_ID,
|
|
"data": {
|
|
"_widget_1744873387500": {"value": today_utc},
|
|
"_widget_1743644977694": {"value": task_name},
|
|
"_widget_1744873387501": {"value": task_start_iso},
|
|
"_widget_1744873387502": {"value": task_end_iso},
|
|
"_widget_1744873387504": {"value": run_time_sec},
|
|
}
|
|
}
|
|
|
|
self.api.data_batch_create(payload)
|
|
except Exception as e:
|
|
print(f"发送任务状态失败: {e}")
|
|
|
|
def run_daily_snapshot(self):
|
|
"""执行每日快照任务"""
|
|
try:
|
|
apps = self.fetch_apps()
|
|
entries = self.fetch_entries(apps)
|
|
widgets = self.fetch_widgets(entries)
|
|
monitor_data = self.fetch_monitor_data()
|
|
matched_data = self.match_widgets(monitor_data, widgets)
|
|
|
|
if matched_data.empty:
|
|
print("没有匹配到数据")
|
|
return False
|
|
|
|
today_file = self.data_dir / f"snapshot_{self.today}.csv"
|
|
widget_file = self.data_dir / f"all_widgets_{self.today}.csv"
|
|
|
|
if not Utils.safe_csv_write(matched_data, today_file):
|
|
print("保存快照数据失败")
|
|
return False
|
|
if not Utils.safe_csv_write(widgets, widget_file):
|
|
print("保存组件数据失败")
|
|
return False
|
|
|
|
self.archive_old_data()
|
|
self.save_last_data(matched_data, widgets)
|
|
|
|
return True
|
|
except Exception as e:
|
|
print(f"每日快照任务失败: {e}")
|
|
return False
|
|
|
|
def run_hourly_check(self):
|
|
"""执行每小时检查任务"""
|
|
try:
|
|
apps = self.fetch_apps()
|
|
entries = self.fetch_entries(apps)
|
|
widgets = self.fetch_widgets(entries)
|
|
monitor_data = self.fetch_monitor_data()
|
|
current_data = self.match_widgets(monitor_data, widgets)
|
|
|
|
changes = self.compare_data(current_data)
|
|
if changes and any(len(v) > 0 for v in changes.values()):
|
|
self.save_changes(changes, apps, entries)
|
|
|
|
self.save_last_data(current_data, widgets)
|
|
|
|
return True
|
|
except Exception as e:
|
|
print(f"每小时检查任务失败: {e}")
|
|
return False
|
|
|
|
def main(self):
|
|
"""主运行逻辑"""
|
|
task_start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
try:
|
|
if Utils.is_first_run_today():
|
|
success = self.run_daily_snapshot()
|
|
else:
|
|
success = self.run_hourly_check()
|
|
|
|
self.send_task_status(task_start_time, "字段监控")
|
|
return success
|
|
except Exception as e:
|
|
print(f"主运行逻辑失败: {e}")
|
|
return False
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# 确保输出目录存在
|
|
Utils.ensure_dir(Config.OUTPUT_DIR)
|
|
|
|
# 运行监控任务
|
|
monitor = DataMonitor()
|
|
if not monitor.main():
|
|
sys.exit(1) |