Skip to content

C
customer-recall
Commit ee63f885 by yiling.shen
Options

添加数据库备份工具和部署脚本，支持无权限环境下的安全备份

parent 4ec2561d
Pipeline #3174 skipped with stage
in 0 seconds
Showing with 2026 additions and 11611 deletions
.gitlab-ci.yml
# .gitlab-ci.yml # .gitlab-ci.yml - 生产环境自动部署（包含数据库备份）
stages:
- deploy
deploy_to_production: deploy_to_production:
stage: deploy stage: deploy
image: alpine:latest image: alpine:latest
# --- 在这里添加 tags 部分 --- # 使用jarvis标签的Runner
tags: tags:
- jarvis # 指定使用带有 "jarvis" 标签的 Runner - jarvis
# ---------------------------
# 只在master分支触发
# before_script, script, only 这些部分保持不变 only:
- master
# 设置环境变量
variables:
PROJECT_DIR: "customer-recall"
BACKUP_DIR: "/backup/database"
before_script: before_script:
# 安装必要的工具
- apk add --update --no-cache openssh-client bash curl
# 设置SSH
- 'which ssh-agent || ( apk add --update --no-cache openssh-client )' - 'which ssh-agent || ( apk add --update --no-cache openssh-client )'
- eval $(ssh-agent -s) - eval $(ssh-agent -s)
- echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add - - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
...@@ -21,13 +35,54 @@ deploy_to_production: ...@@ -21,13 +35,54 @@ deploy_to_production:
script: script:
- | - |
echo "🚀 开始生产环境部署流程..."
echo "📅 部署时间: $(date)"
echo "🏥 项目: 患者画像回访话术系统"
# 上传部署脚本到生产服务器
echo "📤 上传部署脚本..."
scp -P $SSH_PORT deploy_scripts/deploy_with_backup.sh $SSH_USER@$SSH_HOST:/tmp/
# 设置脚本权限并执行
ssh -p $SSH_PORT $SSH_USER@$SSH_HOST " ssh -p $SSH_PORT $SSH_USER@$SSH_HOST "
echo '✅ 连接服务器成功，开始执行部署脚本...' echo '✅ 连接生产服务器成功！'
cd customer-recall
git pull origin master # 设置脚本权限
docker compose up -d --build chmod +x /tmp/deploy_with_backup.sh
echo '🚀 部署流程执行完毕！'
# 设置数据库环境变量
export DB_HOST='$DB_HOST'
export DB_PORT='$DB_PORT'
export DB_USER='$DB_USER'
export DB_NAME='$DB_NAME'
export DB_PASSWORD='$DB_PASSWORD'
# 执行部署脚本
echo '🚀 开始执行部署脚本...'
/tmp/deploy_with_backup.sh
# 清理临时文件
rm -f /tmp/deploy_with_backup.sh
echo '🎉 部署流程执行完毕！'
" "
only: after_script:
- master - echo "📋 部署完成，检查生产环境状态..."
\ No newline at end of file - |
ssh -p $SSH_PORT $SSH_USER@$SSH_HOST "
echo '🔍 检查容器状态...'
cd $PROJECT_DIR
docker compose ps
echo '📊 检查备份文件...'
ls -lh $BACKUP_DIR/production_backup_*.sql 2>/dev/null || echo '暂无备份文件'
echo '✅ 生产环境检查完成！'
"
# 部署成功后的通知
when: on_success
# 部署失败后的通知
when: on_failure
\ No newline at end of file
GitLab环境变量配置说明.md 0 → 100644
# GitLab环境变量配置说明
# GitLab环境变量配置说明
## 🚨 重要提醒
**在GitLab中设置这些环境变量后，CI/CD才能正常备份生产环境数据库！**
## 📋 需要在GitLab中设置的环境变量
### 1. SSH连接相关变量
在GitLab项目设置 → CI/CD → Variables 中添加：
| 变量名 | 说明 | 示例值 | 是否保护 |
|--------|------|--------|----------|
| `SSH_PRIVATE_KEY` | SSH私钥内容 | `-----BEGIN OPENSSH PRIVATE KEY-----...` | ✅ 是 |
| `SSH_KNOWN_HOSTS` | 服务器公钥指纹 | `server_ip ssh-rsa AAAAB3...` | ✅ 是 |
| `SSH_HOST` | 生产服务器IP地址 | `192.168.1.100` | ❌ 否 |
| `SSH_PORT` | SSH端口号 | `22` | ❌ 否 |
| `SSH_USER` | SSH用户名 | `root` | ❌ 否 |
### 2. 数据库连接相关变量
| 变量名 | 说明 | 示例值 | 是否保护 |
|--------|------|--------|----------|
| `DB_HOST` | 数据库主机地址 | `localhost` 或 `127.0.0.1` | ❌ 否 |
| `DB_PORT` | 数据库端口号 | `3306` | ❌ 否 |
| `DB_USER` | 数据库用户名 | `callback_user` | ❌ 否 |
| `DB_NAME` | 数据库名称 | `callback_system` | ❌ 否 |
| `DB_PASSWORD` | 数据库密码 | `your_password_here` | ✅ 是 |
## 🔧 设置步骤详解
### 步骤1：进入GitLab项目设置
1. 打开你的GitLab项目
2. 点击左侧菜单 `Settings` → `CI/CD`
3. 找到 `Variables` 部分
### 步骤2：添加SSH私钥
1. 点击 `Add variable`
2. 变量名：`SSH_PRIVATE_KEY`
3. 变量值：粘贴你的SSH私钥内容
4. 勾选 `Protected` 和 `Masked`
5. 点击 `Add variable`
### 步骤3：添加服务器公钥指纹
1. 点击 `Add variable`
2. 变量名：`SSH_KNOWN_HOSTS`
3. 变量值：`your_server_ip ssh-rsa your_public_key_fingerprint`
4. 勾选 `Protected`
5. 点击 `Add variable`
### 步骤4：添加服务器连接信息
1. 点击 `Add variable`
2. 变量名：`SSH_HOST`
3. 变量值：你的生产服务器IP地址
4. 点击 `Add variable`
重复上述步骤添加：
- `SSH_PORT`：SSH端口（通常是22）
- `SSH_USER`：SSH用户名
### 步骤5：添加数据库连接信息
1. 点击 `Add variable`
2. 变量名：`DB_HOST`
3. 变量值：数据库主机地址
4. 点击 `Add variable`
重复上述步骤添加：
- `DB_PORT`：数据库端口
- `DB_USER`：数据库用户名
- `DB_NAME`：数据库名称
- `DB_PASSWORD`：数据库密码（勾选Protected和Masked）
## 🔍 如何获取SSH公钥指纹
在生产服务器上执行：
```bash
# 方法1：查看SSH服务公钥
cat /etc/ssh/ssh_host_rsa_key.pub
# 方法2：使用ssh-keyscan获取
ssh-keyscan -H your_server_ip
# 方法3：手动连接获取
ssh -o StrictHostKeyChecking=no your_user@your_server_ip
```
## 📊 环境变量检查清单
- [ ] `SSH_PRIVATE_KEY` - SSH私钥（Protected + Masked）
- [ ] `SSH_KNOWN_HOSTS` - 服务器公钥指纹（Protected）
- [ ] `SSH_HOST` - 服务器IP地址
- [ ] `SSH_PORT` - SSH端口号
- [ ] `SSH_USER` - SSH用户名
- [ ] `DB_HOST` - 数据库主机地址
- [ ] `DB_PORT` - 数据库端口号
- [ ] `DB_USER` - 数据库用户名
- [ ] `DB_NAME` - 数据库名称
- [ ] `DB_PASSWORD` - 数据库密码（Protected + Masked）
## 🚀 测试部署
设置完环境变量后：
1. **推送代码到master分支**
2. **GitLab自动触发CI/CD**
3. **自动备份生产环境数据库**
4. **自动部署新代码**
5. **自动执行安全数据导入**
## 🎯 预期结果
部署成功后，你将看到：
- ✅ 数据库自动备份到 `/backup/database/` 目录
- ✅ 新代码自动部署到生产环境
- ✅ 患者数据安全更新
- ✅ 容器状态检查完成
## 🆘 常见问题
### Q: 为什么SSH连接失败？
A: 检查 `SSH_PRIVATE_KEY`、`SSH_HOST`、`SSH_PORT`、`SSH_USER` 是否正确设置
### Q: 为什么数据库备份失败？
A: 检查 `DB_HOST`、`DB_PORT`、`DB_USER`、`DB_NAME`、`DB_PASSWORD` 是否正确设置
### Q: 如何查看部署日志？
A: 在GitLab项目页面 → CI/CD → Pipelines 中查看详细日志
## 📞 需要帮助？
如果遇到问题，请检查：
1. 环境变量是否正确设置
2. SSH连接是否正常
3. 数据库连接是否正常
4. 服务器权限是否足够
\ No newline at end of file
add_callback_module_to_all_patients.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
为所有患者页面添加回访话术模块
在患者画像页面中添加口腔回访话术模块的占位符
"""
import os
import re
from typing import List
class CallbackModuleAdder:
"""回访话术模块添加器"""
def __init__(self):
"""初始化"""
self.patient_profiles_dir = "patient_profiles"
# 诊所目录列表
self.clinic_dirs = [
"clinic_dafeng",
"clinic_dongting",
"clinic_helai",
"clinic_hongdou",
"clinic_hospital",
"clinic_huishan",
"clinic_mashan",
"clinic_xinwu",
"clinic_xuexian"
]
def add_callback_module_to_patient(self, patient_file: str) -> bool:
"""为单个患者页面添加回访话术模块"""
try:
# 读取患者页面
with open(patient_file, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已有回访话术模块
if "<!-- 口腔回访话术模块 -->" in content:
return True # 已存在，跳过
# 查找插入位置（在回访记录模块之前）
callback_records_pattern = r'(<!-- 回访记录模块 -->)'
match = re.search(callback_records_pattern, content)
if not match:
print(f"⚠️ 患者页面 {patient_file} 未找到回访记录模块")
return False
# 构建回访话术模块HTML
callback_module_html = """
<!-- 口腔回访话术模块 -->
<div id="callback-content" class="mt-8">
<section class="scroll-trigger">
<div class="bg-white rounded-xl shadow-lg overflow-hidden border-l-4 border-green-500">
<div class="bg-green-600 px-6 py-4 text-white">
<h2 class="text-xl font-bold flex items-center">
<i class="fas fa-phone mr-3"></i>
口腔回访话术 <span class="text-sm ml-2 font-normal">Oral Callback Script</span>
</h2>
</div>
<div class="p-6">
<div class="mb-6 grid grid-cols-1 md:grid-cols-2 gap-4 bg-gray-50 p-4 rounded-lg">
<div>
<span class="font-medium text-gray-600">患者姓名：</span>
<span class="text-gray-800">待更新</span>
</div>
<div>
<span class="font-medium text-gray-600">年龄性别：</span>
<span class="text-gray-800">待更新</span>
</div>
<div>
<span class="font-medium text-gray-600">优先诊断：</span>
<span class="text-blue-600 font-semibold">待更新</span>
</div>
<div>
<span class="font-medium text-gray-600">生成时间：</span>
<span class="text-gray-800">待更新</span>
</div>
</div>
<!-- 结构化回访话术内容 -->
<div class="callback-sections">
<div class="callback-script-content">
<div class="bg-gray-50 p-4 rounded-lg mb-4">
<h4 class="font-medium text-gray-800 mb-3">AI生成的回访话术</h4>
<div class="text-sm text-gray-700 leading-relaxed whitespace-pre-line">
回访话术内容将在这里显示...
</div>
</div>
</div>
</div>
<div class="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
<p class="text-sm text-blue-700">
<i class="fas fa-info-circle mr-2"></i>
<strong>使用提示：</strong>此话术为Dify AI智能生成，请根据实际情况灵活调整使用。建议按照四个模块的顺序进行回访。
</p>
</div>
</div>
</div>
</section>
</div>
"""
# 在回访记录模块之前插入回访话术模块
new_content = re.sub(
callback_records_pattern,
callback_module_html + r'\1',
content
)
# 写回文件
with open(patient_file, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
except Exception as e:
print(f"❌ 为患者页面 {patient_file} 添加回访话术模块时出错: {e}")
return False
def add_callback_module_to_clinic(self, clinic_dir: str) -> tuple:
"""为诊所的所有患者页面添加回访话术模块"""
clinic_path = os.path.join(self.patient_profiles_dir, clinic_dir)
patients_dir = os.path.join(clinic_path, "patients")
if not os.path.exists(patients_dir):
print(f"❌ 诊所目录不存在: {patients_dir}")
return 0, 0
# 获取所有患者HTML文件
patient_files = [f for f in os.listdir(patients_dir) if f.endswith('.html')]
print(f"📁 处理诊所 {clinic_dir}: {len(patient_files)} 个患者文件")
success_count = 0
total_count = len(patient_files)
for patient_file in patient_files:
patient_path = os.path.join(patients_dir, patient_file)
if self.add_callback_module_to_patient(patient_path):
success_count += 1
return success_count, total_count
def add_callback_module_to_all_clinics(self):
"""为所有诊所的患者页面添加回访话术模块"""
print("=" * 60)
print("为所有患者页面添加回访话术模块")
print("=" * 60)
total_success = 0
total_files = 0
for clinic_dir in self.clinic_dirs:
success, total = self.add_callback_module_to_clinic(clinic_dir)
total_success += success
total_files += total
print(f"✅ {clinic_dir}: {success}/{total} 个文件处理成功")
print("\n" + "=" * 60)
print("添加完成！统计结果:")
print(f" 成功添加: {total_success} 个患者页面")
print(f" 总文件数: {total_files} 个")
print(f" 成功率: {total_success/total_files*100:.1f}%" if total_files > 0 else " 成功率: 0%")
print("=" * 60)
def main():
"""主函数"""
adder = CallbackModuleAdder()
adder.add_callback_module_to_all_clinics()
if __name__ == "__main__":
main()
\ No newline at end of file
analyze_data.py deleted 100644 → 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pandas as pd
import sys
def analyze_excel_data():
try:
# 读取Excel文件
df = pd.read_excel('合并结果.xlsx')
print('=== 数据基本信息 ===')
print(f'总行数: {len(df)}')
print(f'总列数: {len(df.columns)}')
print()
print('=== 所有字段列表 ===')
for i, col in enumerate(df.columns, 1):
print(f'{i:2d}. {col}')
print()
print('=== 各字段非空值统计 ===')
for col in df.columns:
non_null = df[col].notna().sum()
print(f'{col}: {non_null}/{len(df)} ({non_null/len(df)*100:.1f}%)')
print()
print('=== 前5行数据示例 ===')
pd.set_option('display.max_columns', None)
pd.set_option('display.width', 1000)
pd.set_option('display.max_colwidth', 50)
# 分批显示数据，避免输出过宽
cols_per_batch = 5
for i in range(0, len(df.columns), cols_per_batch):
batch_cols = df.columns[i:i+cols_per_batch]
print(f'\n--- 字段 {i+1}-{min(i+cols_per_batch, len(df.columns))} ---')
print(df[batch_cols].head(5))
print('\n=== 数据类型信息 ===')
print(df.dtypes)
# 检查关键字段的数据分布
print('\n=== 关键字段数据分布 ===')
key_fields = ['姓名', '病历号', '性别', '年龄', '诊所']
for field in key_fields:
if field in df.columns:
unique_count = df[field].nunique()
print(f'{field}: {unique_count} 个不同值')
if field == '性别':
print(f' 性别分布: {df[field].value_counts().to_dict()}')
elif field == '诊所':
print(f' 诊所分布: {df[field].value_counts().head(5).to_dict()}')
except Exception as e:
print(f'读取Excel文件时出错: {e}')
sys.exit(1)
if __name__ == "__main__":
analyze_excel_data()
\ No newline at end of file
auth_system.py
...@@ -25,11 +25,12 @@ except ImportError as e: ...@@ -25,11 +25,12 @@ except ImportError as e:
# 尝试导入clinic_config，如果失败则使用默认配置 # 尝试导入clinic_config，如果失败则使用默认配置
try: try:
from clinic_config import DEFAULT_USERS, get_user_by_username, get_clinic_info from clinic_config import DEFAULT_USERS, get_user_by_username, get_clinic_info
print("✅ 成功导入clinic_config配置")
except ImportError as e: except ImportError as e:
print(f"⚠️ 无法导入clinic_config: {e}") print(f"⚠️ 无法导入clinic_config: {e}")
print("使用默认用户配置...") print("使用默认用户配置...")
# 默认用户配置 # 最小默认用户配置（仅作为备用）
DEFAULT_USERS = [ DEFAULT_USERS = [
# 管理员 # 管理员
{ {
...@@ -39,24 +40,6 @@ except ImportError as e: ...@@ -39,24 +40,6 @@ except ImportError as e:
'clinic_id': 'admin', 'clinic_id': 'admin',
'real_name': '系统管理员', 'real_name': '系统管理员',
'clinic_name': '总部' 'clinic_name': '总部'
},
# 学前街门诊
{
'username': 'jinqin',
'password': 'jinqin123',
'role': 'clinic_user',
'clinic_id': 'clinic_xuexian',
'real_name': '金沁',
'clinic_name': '学前街门诊'
},
# 大丰门诊
{
'username': 'chenlin',
'password': 'chenlin123',
'role': 'clinic_user',
'clinic_id': 'clinic_dafeng',
'real_name': '陈琳',
'clinic_name': '大丰门诊'
} }
] ]
...@@ -69,18 +52,7 @@ except ImportError as e: ...@@ -69,18 +52,7 @@ except ImportError as e:
def get_clinic_info(clinic_id): def get_clinic_info(clinic_id):
"""获取门诊信息""" """获取门诊信息"""
clinic_mapping = { return {'name': '未知门诊'}
'clinic_xuexian': {'name': '学前街门诊'},
'clinic_dafeng': {'name': '大丰门诊'},
'clinic_dongting': {'name': '东亭门诊'},
'clinic_helai': {'name': '河埒门诊'},
'clinic_hongdou': {'name': '红豆门诊'},
'clinic_huishan': {'name': '惠山门诊'},
'clinic_mashan': {'name': '马山门诊'},
'clinic_hospital': {'name': '通善口腔医院'},
'clinic_xinwu': {'name': '新吴门诊'}
}
return clinic_mapping.get(clinic_id, {'name': '未知门诊'})
class AuthSystem: class AuthSystem:
"""用户认证系统""" """用户认证系统"""
......
backup_api.py 0 → 100644
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
通过Web API备份数据库
无需SSH权限，通过应用程序接口备份数据
"""
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from auth_system import app
from flask import jsonify, request, send_file
import pymysql
import json
from datetime import datetime
import tempfile
import zipfile
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3307,
'user': 'callback_user',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4'
}
def backup_database():
"""备份数据库到临时文件"""
try:
connection = pymysql.connect(**DB_CONFIG)
cursor = connection.cursor()
# 创建临时文件
temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.sql', delete=False, encoding='utf-8')
temp_file_path = temp_file.name
# 获取所有表名
cursor.execute("SHOW TABLES")
tables = [table[0] for table in cursor.fetchall()]
print(f"📋 开始备份 {len(tables)} 个表...")
# 写入备份头部信息
temp_file.write(f"-- 患者画像回访话术系统数据库备份\n")
temp_file.write(f"-- 备份时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
temp_file.write(f"-- 数据库: {DB_CONFIG['database']}\n\n")
# 备份每个表
for table_name in tables:
print(f" 📊 备份表: {table_name}")
# 获取表结构
cursor.execute(f"SHOW CREATE TABLE `{table_name}`")
create_table_sql = cursor.fetchone()[1]
temp_file.write(f"\n-- 表结构: {table_name}\n")
temp_file.write(f"DROP TABLE IF EXISTS `{table_name}`;\n")
temp_file.write(f"{create_table_sql};\n\n")
# 获取表数据
cursor.execute(f"SELECT COUNT(*) FROM `{table_name}`")
row_count = cursor.fetchone()[0]
if row_count > 0:
temp_file.write(f"-- 表数据: {table_name} ({row_count} 行)\n")
# 分批获取数据避免内存问题
batch_size = 1000
offset = 0
while offset < row_count:
cursor.execute(f"SELECT * FROM `{table_name}` LIMIT {batch_size} OFFSET {offset}")
rows = cursor.fetchall()
for row in rows:
# 构建INSERT语句
values = []
for value in row:
if value is None:
values.append('NULL')
elif isinstance(value, (int, float)):
values.append(str(value))
else:
# 转义字符串
escaped_value = str(value).replace("'", "''").replace("\\", "\\\\")
values.append(f"'{escaped_value}'")
temp_file.write(f"INSERT INTO `{table_name}` VALUES ({', '.join(values)});\n")
offset += batch_size
print(f" ✅ 已备份 {min(offset, row_count)}/{row_count} 行")
temp_file.write("\n")
temp_file.close()
connection.close()
print(f"✅ 数据库备份完成: {temp_file_path}")
return temp_file_path
except Exception as e:
print(f"❌ 数据库备份失败: {e}")
if 'connection' in locals():
connection.close()
return None
def create_backup_zip(backup_file_path):
"""创建备份压缩包"""
try:
# 创建临时压缩文件
zip_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.zip', delete=False)
zip_file_path = zip_file.name
zip_file.close()
# 压缩备份文件
with zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
# 添加备份文件
backup_filename = os.path.basename(backup_file_path)
zipf.write(backup_file_path, backup_filename)
# 添加备份信息
info = {
'backup_time': datetime.now().isoformat(),
'database': DB_CONFIG['database'],
'tables_count': len([f for f in os.listdir('.') if f.endswith('.sql')]),
'backup_size': os.path.getsize(backup_file_path)
}
zipf.writestr('backup_info.json', json.dumps(info, ensure_ascii=False, indent=2))
print(f"✅ 备份压缩包创建完成: {zip_file_path}")
return zip_file_path
except Exception as e:
print(f"❌ 创建压缩包失败: {e}")
return None
# 添加备份API路由到Flask应用
@app.route('/api/backup/database', methods=['POST'])
def api_backup_database():
"""API接口：备份数据库"""
try:
print("🚀 收到数据库备份请求...")
# 执行备份
backup_file_path = backup_database()
if not backup_file_path:
return jsonify({'error': '数据库备份失败'}), 500
# 创建压缩包
zip_file_path = create_backup_zip(backup_file_path)
if not zip_file_path:
return jsonify({'error': '创建压缩包失败'}), 500
# 清理临时文件
os.unlink(backup_file_path)
# 返回下载链接
backup_filename = f"database_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
return jsonify({
'success': True,
'message': '数据库备份成功',
'backup_file': backup_filename,
'download_url': f'/api/backup/download/{backup_filename}',
'backup_time': datetime.now().isoformat()
})
except Exception as e:
print(f"❌ API备份失败: {e}")
return jsonify({'error': f'备份失败: {str(e)}'}), 500
@app.route('/api/backup/download/<filename>')
def api_download_backup(filename):
"""API接口：下载备份文件"""
try:
# 查找最新的备份文件
backup_dir = tempfile.gettempdir()
backup_files = [f for f in os.listdir(backup_dir) if f.endswith('.zip') and 'database_backup' in f]
if not backup_files:
return jsonify({'error': '未找到备份文件'}), 404
# 使用最新的备份文件
latest_backup = max(backup_files, key=lambda f: os.path.getctime(os.path.join(backup_dir, f)))
backup_path = os.path.join(backup_dir, latest_backup)
return send_file(
backup_path,
as_attachment=True,
download_name=filename,
mimetype='application/zip'
)
except Exception as e:
print(f"❌ 下载备份文件失败: {e}")
return jsonify({'error': f'下载失败: {str(e)}'}), 500
@app.route('/api/backup/status')
def api_backup_status():
"""API接口：获取备份状态"""
try:
backup_dir = tempfile.gettempdir()
backup_files = [f for f in os.listdir(backup_dir) if f.endswith('.zip') and 'database_backup' in f]
backups = []
for backup_file in backup_files:
backup_path = os.path.join(backup_dir, backup_file)
backup_info = {
'filename': backup_file,
'size': os.path.getsize(backup_path),
'created_time': datetime.fromtimestamp(os.path.getctime(backup_path)).isoformat(),
'download_url': f'/api/backup/download/{backup_file}'
}
backups.append(backup_info)
# 按创建时间排序
backups.sort(key=lambda x: x['created_time'], reverse=True)
return jsonify({
'success': True,
'backups': backups,
'total_count': len(backups)
})
except Exception as e:
print(f"❌ 获取备份状态失败: {e}")
return jsonify({'error': f'获取状态失败: {str(e)}'}), 500
if __name__ == "__main__":
print("🔧 数据库备份API已添加到Flask应用")
print("📋 可用的API接口:")
print(" POST /api/backup/database - 创建数据库备份")
print(" GET /api/backup/status - 获取备份状态")
print(" GET /api/backup/download/* - 下载备份文件")
\ No newline at end of file
backup_page.html 0 → 100644
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>数据库备份工具</title>
<style>
body {
font-family: 'Microsoft YaHei', Arial, sans-serif;
max-width: 800px;
margin: 0 auto;
padding: 20px;
background-color: #f5f5f5;
}
.container {
background: white;
padding: 30px;
border-radius: 10px;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
.header {
text-align: center;
margin-bottom: 30px;
color: #333;
}
.backup-section {
background: #f8f9fa;
padding: 20px;
border-radius: 8px;
margin-bottom: 20px;
border-left: 4px solid #007bff;
}
.btn {
background: #007bff;
color: white;
border: none;
padding: 12px 24px;
border-radius: 6px;
cursor: pointer;
font-size: 16px;
margin: 5px;
transition: background 0.3s;
}
.btn:hover {
background: #0056b3;
}
.btn-danger {
background: #dc3545;
}
.btn-danger:hover {
background: #c82333;
}
.btn-success {
background: #28a745;
}
.btn-success:hover {
background: #218838;
}
.status {
padding: 15px;
border-radius: 6px;
margin: 15px 0;
display: none;
}
.status.success {
background: #d4edda;
color: #155724;
border: 1px solid #c3e6cb;
}
.status.error {
background: #f8d7da;
color: #721c24;
border: 1px solid #f5c6cb;
}
.status.info {
background: #d1ecf1;
color: #0c5460;
border: 1px solid #bee5eb;
}
.backup-list {
background: #fff;
border: 1px solid #ddd;
border-radius: 6px;
padding: 15px;
margin-top: 20px;
}
.backup-item {
display: flex;
justify-content: space-between;
align-items: center;
padding: 10px;
border-bottom: 1px solid #eee;
}
.backup-item:last-child {
border-bottom: none;
}
.backup-info {
flex: 1;
}
.backup-name {
font-weight: bold;
color: #333;
}
.backup-time {
color: #666;
font-size: 14px;
}
.backup-size {
color: #888;
font-size: 12px;
}
.loading {
display: none;
text-align: center;
padding: 20px;
}
.spinner {
border: 4px solid #f3f3f3;
border-top: 4px solid #007bff;
border-radius: 50%;
width: 40px;
height: 40px;
animation: spin 1s linear infinite;
margin: 0 auto 10px;
}
@keyframes spin {
0% { transform: rotate(0deg); }
100% { transform: rotate(360deg); }
}
</style>
</head>
<body>
<div class="container">
<div class="header">
<h1>🗄️ 数据库备份工具</h1>
<p>安全备份生产环境数据库，无需SSH权限</p>
</div>
<div class="backup-section">
<h3>📋 备份操作</h3>
<p>点击下方按钮开始备份数据库，备份文件将自动下载到本地。</p>
<button class="btn btn-success" onclick="startBackup()">
🚀 开始备份数据库
</button>
<button class="btn" onclick="refreshBackupList()">
🔄 刷新备份列表
</button>
</div>
<div class="loading" id="loading">
<div class="spinner"></div>
<p>正在备份数据库，请稍候...</p>
</div>
<div id="status" class="status"></div>
<div class="backup-section">
<h3>📊 备份历史</h3>
<div id="backupList" class="backup-list">
<p>点击"刷新备份列表"查看备份历史</p>
</div>
</div>
<div class="backup-section">
<h3>⚠️ 重要提醒</h3>
<ul>
<li>备份过程可能需要几分钟时间，请耐心等待</li>
<li>备份文件会自动下载到本地，请妥善保存</li>
<li>建议在业务低峰期进行备份操作</li>
<li>备份完成后，请验证备份文件的完整性</li>
</ul>
</div>
</div>
<script>
// 显示状态信息
function showStatus(message, type = 'info') {
const statusDiv = document.getElementById('status');
statusDiv.textContent = message;
statusDiv.className = `status ${type}`;
statusDiv.style.display = 'block';
// 5秒后自动隐藏
setTimeout(() => {
statusDiv.style.display = 'none';
}, 5000);
}
// 开始备份
async function startBackup() {
try {
// 显示加载状态
document.getElementById('loading').style.display = 'block';
showStatus('正在启动数据库备份...', 'info');
// 调用备份API
const response = await fetch('/api/backup/database', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
}
});
const result = await response.json();
if (result.success) {
showStatus('✅ 数据库备份成功！正在下载备份文件...', 'success');
// 自动下载备份文件
setTimeout(() => {
downloadBackup(result.download_url, result.backup_file);
}, 1000);
// 刷新备份列表
setTimeout(() => {
refreshBackupList();
}, 2000);
} else {
showStatus(`❌ 备份失败: ${result.error}`, 'error');
}
} catch (error) {
showStatus(`❌ 备份过程出错: ${error.message}`, 'error');
} finally {
document.getElementById('loading').style.display = 'none';
}
}
// 下载备份文件
function downloadBackup(downloadUrl, filename) {
const link = document.createElement('a');
link.href = downloadUrl;
link.download = filename;
document.body.appendChild(link);
link.click();
document.body.removeChild(link);
showStatus(`📥 备份文件 ${filename} 下载完成！`, 'success');
}
// 刷新备份列表
async function refreshBackupList() {
try {
const response = await fetch('/api/backup/status');
const result = await response.json();
if (result.success) {
displayBackupList(result.backups);
} else {
showStatus(`❌ 获取备份列表失败: ${result.error}`, 'error');
}
} catch (error) {
showStatus(`❌ 刷新失败: ${error.message}`, 'error');
}
}
// 显示备份列表
function displayBackupList(backups) {
const backupListDiv = document.getElementById('backupList');
if (backups.length === 0) {
backupListDiv.innerHTML = '<p>暂无备份文件</p>';
return;
}
let html = '';
backups.forEach(backup => {
const size = formatFileSize(backup.size);
const time = new Date(backup.created_time).toLocaleString('zh-CN');
html += `
<div class="backup-item">
<div class="backup-info">
<div class="backup-name">${backup.filename}</div>
<div class="backup-time">创建时间: ${time}</div>
<div class="backup-size">文件大小: ${size}</div>
</div>
<button class="btn" onclick="downloadBackup('${backup.download_url}', '${backup.filename}')">
📥 下载
</button>
</div>
`;
});
backupListDiv.innerHTML = html;
}
// 格式化文件大小
function formatFileSize(bytes) {
if (bytes === 0) return '0 Bytes';
const k = 1024;
const sizes = ['Bytes', 'KB', 'MB', 'GB'];
const i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}
// 页面加载完成后自动刷新备份列表
window.onload = function() {
refreshBackupList();
};
</script>
</body>
</html>
\ No newline at end of file
batch_generate_clinic_callbacks.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
诊所患者回访话术批量生成器
基于诊所患者json目录中的所有诊所文件，使用Dify平台批量生成个性化的回访话术
支持按诊所分别生成或合并生成
"""
import json
import os
from datetime import datetime
from pathlib import Path
from dify_callback_api import DifyCallbackAPI
from dify_config import get_dify_config, map_patient_data
def load_clinic_data():
"""加载所有诊所的患者数据"""
print("正在扫描诊所患者json目录...")
clinic_data_dir = "诊所患者json"
if not os.path.exists(clinic_data_dir):
raise FileNotFoundError(f"未找到目录: {clinic_data_dir}")
clinic_files = {}
total_patients = 0
for file_name in os.listdir(clinic_data_dir):
if file_name.endswith('.json') and not file_name.startswith('conversion_summary'):
file_path = os.path.join(clinic_data_dir, file_name)
clinic_name = Path(file_name).stem
try:
with open(file_path, 'r', encoding='utf-8') as f:
patients_data = json.load(f)
if patients_data: # 确保不是空文件
clinic_files[clinic_name] = {
'file_path': file_path,
'patients_data': patients_data,
'patient_count': len(patients_data)
}
total_patients += len(patients_data)
print(f"✓ 加载 {clinic_name}: {len(patients_data)} 个患者")
else:
print(f"⚠ 跳过空文件: {file_name}")
except Exception as e:
print(f"✗ 加载文件 {file_name} 时出错: {e}")
continue
if not clinic_files:
raise FileNotFoundError("未找到可用的诊所患者数据文件")
print(f"\n✅ 总共加载了 {len(clinic_files)} 个诊所的 {total_patients} 个患者数据")
return clinic_files
def select_clinics(clinic_files):
"""选择要处理的诊所"""
print("\n📋 可用的诊所:")
clinic_list = list(clinic_files.keys())
for i, clinic_name in enumerate(clinic_list, 1):
patient_count = clinic_files[clinic_name]['patient_count']
print(f" {i}. {clinic_name} ({patient_count} 个患者)")
print(f" {len(clinic_list) + 1}. 全部诊所")
while True:
try:
choice = input(f"\n请选择要处理的诊所 (1-{len(clinic_list) + 1}): ").strip()
if choice == str(len(clinic_list) + 1):
# 选择全部诊所
return clinic_files
else:
choice_num = int(choice)
if 1 <= choice_num <= len(clinic_list):
selected_clinic = clinic_list[choice_num - 1]
return {selected_clinic: clinic_files[selected_clinic]}
else:
print(f"请输入1-{len(clinic_list) + 1}之间的数字")
except ValueError:
print("请输入有效的数字")
except KeyboardInterrupt:
print("\n用户取消操作")
return None
def generate_callbacks_for_clinic(clinic_name, patients_data, api_type="agent_chat"):
"""为单个诊所生成回访话术"""
print(f"\n🏥 正在为 {clinic_name} 生成回访话术...")
print(f"📊 患者数量: {len(patients_data)}")
# 获取配置
config = get_dify_config()
# 验证配置
if not config.validate_config():
raise ValueError("Dify配置验证失败，请检查API密钥和服务器地址")
# 初始化Dify API客户端
api_client = DifyCallbackAPI(config.API_KEY, config.BASE_URL)
# 测试连接
if not api_client.test_connection():
raise ConnectionError("无法连接到Dify服务器，请检查服务器地址和网络连接")
# 存储所有生成的话术
all_callbacks = []
success_count = 0
failed_count = 0
for i, patient_data in enumerate(patients_data, 1):
patient_id = patient_data.get('病历号', f'Unknown_{i}')
patient_name = patient_data.get('姓名', f'患者{i}')
print(f" [{i}/{len(patients_data)}] {patient_name}({patient_id})...", end=" ")
try:
# 根据API类型调用不同的方法
if api_type == "agent_chat":
callback_content = api_client.call_agent_chat(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
elif api_type == "chat":
result = api_client.call_chat_completion(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
callback_content = result.get('answer', '') or result.get('message', {}).get('content', '')
elif api_type == "completion":
callback_content = api_client.call_completion_api(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
elif api_type == "workflow":
result = api_client.call_workflow(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
# 从工作流结果中提取内容
callback_content = result.get('data', {}).get('outputs', {}).get('text', '') or str(result)
else:
raise ValueError(f"不支持的API类型: {api_type}")
if callback_content:
callback_data = {
'clinic_name': clinic_name,
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': callback_content,
'api_type': api_type,
'patient_data_summary': {
'last_visit_time': patient_data.get('最后一次就诊时间', ''),
'last_clinic': patient_data.get('最后一次就诊诊所', ''),
'last_doctor': patient_data.get('最后一次就诊医生', ''),
'diagnosis': patient_data.get('医生诊断', ''),
'last_treatment': patient_data.get('上次处置', ''),
'clinic_source': clinic_name
},
'callback_type': 'success'
}
all_callbacks.append(callback_data)
success_count += 1
print("✓")
else:
raise ValueError("API返回内容为空")
except Exception as e:
print(f"✗ {str(e)}")
error_data = {
'clinic_name': clinic_name,
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': '',
'api_type': api_type,
'error_message': str(e),
'callback_type': 'error'
}
all_callbacks.append(error_data)
failed_count += 1
# 添加延迟避免频率限制
if config.REQUEST_DELAY > 0 and i < len(patients_data):
import time
time.sleep(config.REQUEST_DELAY)
print(f"\n🏥 {clinic_name} 处理完成: ✅{success_count} / ❌{failed_count}")
return all_callbacks
def generate_batch_callbacks_for_clinics(selected_clinics, api_type="agent_chat", mode="separate"):
"""批量为选定的诊所生成回访话术"""
print(f"\n🚀 开始批量生成回访话术...")
print(f"📊 处理模式: {'分诊所生成' if mode == 'separate' else '合并生成'}")
print(f"🔗 API类型: {api_type.upper()}")
all_results = {}
total_success = 0
total_failed = 0
if mode == "separate":
# 分诊所处理
for clinic_name, clinic_info in selected_clinics.items():
try:
callbacks = generate_callbacks_for_clinic(
clinic_name,
clinic_info['patients_data'],
api_type
)
all_results[clinic_name] = callbacks
success_count = len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
failed_count = len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
total_success += success_count
total_failed += failed_count
except Exception as e:
print(f"❌ 处理诊所 {clinic_name} 时出错: {e}")
continue
elif mode == "merged":
# 合并所有患者数据
all_patients = []
clinic_mapping = {}
for clinic_name, clinic_info in selected_clinics.items():
for patient in clinic_info['patients_data']:
# 添加诊所标识
patient['source_clinic'] = clinic_name
all_patients.append(patient)
clinic_mapping[patient.get('病历号', '')] = clinic_name
print(f"📋 合并后总患者数: {len(all_patients)}")
try:
callbacks = generate_callbacks_for_clinic("合并所有诊所", all_patients, api_type)
all_results["merged"] = callbacks
total_success = len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
total_failed = len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
except Exception as e:
print(f"❌ 合并处理时出错: {e}")
return None
print(f"\n🎉 批量生成完成!")
print(f"✅ 总成功: {total_success}")
print(f"❌ 总失败: {total_failed}")
print(f"📊 成功率: {(total_success/(total_success+total_failed)*100):.1f}%")
return all_results
def save_clinic_callbacks_to_files(all_results, api_type="agent_chat", mode="separate"):
"""保存回访话术到文件"""
print("\n💾 正在保存回访话术到文件...")
# 创建输出目录
config = get_dify_config()
output_dir = config.OUTPUT_DIR
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# 生成时间戳
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
saved_files = []
if mode == "separate":
# 为每个诊所保存单独的文件
for clinic_name, callbacks in all_results.items():
clinic_safe_name = clinic_name.replace('/', '_').replace('\\', '_')
# JSON完整版
json_filename = f"{output_dir}/Dify回访话术_{clinic_safe_name}_{api_type}_{timestamp}.json"
with open(json_filename, 'w', encoding='utf-8') as f:
json.dump({
'generation_info': {
'platform': 'Dify',
'api_type': api_type,
'clinic_name': clinic_name,
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'total_count': len(callbacks),
'success_count': len([cb for cb in callbacks if cb.get('callback_type') == 'success']),
'error_count': len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
},
'callbacks': callbacks
}, f, ensure_ascii=False, indent=2)
# 文本版
txt_filename = f"{output_dir}/Dify回访话术_{clinic_safe_name}_文本版_{api_type}_{timestamp}.txt"
save_text_version(txt_filename, callbacks, clinic_name, api_type)
saved_files.extend([json_filename, txt_filename])
print(f"✓ 已保存 {clinic_name}: {os.path.basename(json_filename)}")
elif mode == "merged":
# 保存合并后的文件
callbacks = all_results.get("merged", [])
# JSON完整版
json_filename = f"{output_dir}/Dify回访话术_所有诊所_{api_type}_{timestamp}.json"
with open(json_filename, 'w', encoding='utf-8') as f:
json.dump({
'generation_info': {
'platform': 'Dify',
'api_type': api_type,
'clinic_name': '所有诊所合并',
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'total_count': len(callbacks),
'success_count': len([cb for cb in callbacks if cb.get('callback_type') == 'success']),
'error_count': len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
},
'callbacks': callbacks
}, f, ensure_ascii=False, indent=2)
# 文本版
txt_filename = f"{output_dir}/Dify回访话术_所有诊所_文本版_{api_type}_{timestamp}.txt"
save_text_version(txt_filename, callbacks, "所有诊所合并", api_type)
saved_files.extend([json_filename, txt_filename])
print(f"✓ 已保存合并文件: {os.path.basename(json_filename)}")
# 生成统计汇总
stats_filename = f"{output_dir}/Dify回访话术_统计汇总_{api_type}_{timestamp}.json"
save_statistics_summary(stats_filename, all_results, api_type, mode)
saved_files.append(stats_filename)
print(f"✓ 已保存统计汇总: {os.path.basename(stats_filename)}")
print(f"\n📁 所有文件已保存到: {output_dir}/")
return saved_files
def save_text_version(filename, callbacks, clinic_name, api_type):
"""保存文本版话术"""
success_callbacks = [cb for cb in callbacks if cb.get('callback_type') == 'success']
error_callbacks = [cb for cb in callbacks if cb.get('callback_type') == 'error']
with open(filename, 'w', encoding='utf-8') as f:
f.write("="*60 + "\n")
f.write("Dify平台诊所回访话术批量生成结果\n")
f.write(f"诊所名称: {clinic_name}\n")
f.write(f"API类型: {api_type.upper()}\n")
f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"总计处理: {len(callbacks)} 个患者\n")
f.write(f"成功生成: {len(success_callbacks)} 个话术\n")
f.write(f"生成失败: {len(error_callbacks)} 个\n")
f.write("="*60 + "\n\n")
# 写入成功生成的话术
for i, callback in enumerate(success_callbacks, 1):
f.write(f"【{i}】患者: {callback['patient_name']} ({callback['patient_id']})\n")
f.write(f"诊所: {callback.get('clinic_name', '未知')}\n")
f.write(f"年龄: {callback['age']}岁, 性别: {callback['gender']}\n")
f.write(f"最后就诊: {callback['patient_data_summary'].get('last_visit_time', '未知')}\n")
f.write(f"就诊医生: {callback['patient_data_summary'].get('last_doctor', '未知')}\n")
f.write(f"诊断信息: {callback['patient_data_summary'].get('diagnosis', '未知')}\n")
f.write("-"*40 + "\n")
f.write("回访话术:\n")
f.write(callback['callback_script'])
f.write("\n" + "="*60 + "\n\n")
# 添加失败患者的信息
if error_callbacks:
f.write("\n" + "="*60 + "\n")
f.write("生成失败的患者\n")
f.write("="*60 + "\n\n")
for i, callback in enumerate(error_callbacks, 1):
f.write(f"【{i}】患者: {callback['patient_name']} ({callback['patient_id']})\n")
f.write(f"诊所: {callback.get('clinic_name', '未知')}\n")
f.write(f"年龄: {callback['age']}岁, 性别: {callback['gender']}\n")
f.write(f"失败原因: {callback.get('error_message', '未知错误')}\n")
f.write("-"*40 + "\n\n")
def save_statistics_summary(filename, all_results, api_type, mode):
"""保存统计汇总信息"""
stats_data = {
'generation_info': {
'platform': 'Dify',
'api_type': api_type,
'processing_mode': mode,
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
},
'clinic_statistics': {},
'overall_summary': {
'total_clinics': len(all_results),
'total_patients': 0,
'total_success': 0,
'total_failed': 0
}
}
# 统计每个诊所的数据
for clinic_name, callbacks in all_results.items():
success_count = len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
failed_count = len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
stats_data['clinic_statistics'][clinic_name] = {
'total_patients': len(callbacks),
'successful_callbacks': success_count,
'failed_callbacks': failed_count,
'success_rate': f"{(success_count/len(callbacks)*100):.1f}%" if callbacks else "0%"
}
stats_data['overall_summary']['total_patients'] += len(callbacks)
stats_data['overall_summary']['total_success'] += success_count
stats_data['overall_summary']['total_failed'] += failed_count
# 计算总体成功率
total = stats_data['overall_summary']['total_patients']
success = stats_data['overall_summary']['total_success']
stats_data['overall_summary']['overall_success_rate'] = f"{(success/total*100):.1f}%" if total > 0 else "0%"
with open(filename, 'w', encoding='utf-8') as f:
json.dump(stats_data, f, ensure_ascii=False, indent=2)
def main():
"""主函数"""
print("="*60)
print("诊所患者回访话术批量生成器")
print("="*60)
try:
# 1. 加载所有诊所数据
clinic_files = load_clinic_data()
# 2. 选择要处理的诊所
selected_clinics = select_clinics(clinic_files)
if not selected_clinics:
return
# 3. 选择处理模式
print("\n📋 请选择处理模式:")
print("1. 分诊所生成 (为每个诊所生成单独的话术文件)")
print("2. 合并生成 (将所有诊所患者合并后生成)")
while True:
try:
mode_choice = input("请选择处理模式 (1-2): ").strip()
if mode_choice == "1":
mode = "separate"
break
elif mode_choice == "2":
mode = "merged"
break
else:
print("无效选择，请输入1或2")
except KeyboardInterrupt:
print("\n用户取消操作")
return
# 4. 选择API类型
print("\n📋 请选择API类型:")
print("1. Agent Chat API (智能对话) - 推荐")
print("2. Chat API (聊天完成)")
print("3. Completion API (文本完成)")
print("4. Workflow API (工作流)")
while True:
try:
api_choice = input("请输入选择 (1-4): ").strip()
if api_choice == "1":
api_type = "agent_chat"
break
elif api_choice == "2":
api_type = "chat"
break
elif api_choice == "3":
api_type = "completion"
break
elif api_choice == "4":
api_type = "workflow"
break
else:
print("无效选择，请输入1-4")
except KeyboardInterrupt:
print("\n用户取消操作")
return
# 5. 开始生成
print(f"\n🚀 开始处理...")
print(f"📊 选择的诊所: {list(selected_clinics.keys())}")
print(f"🔧 处理模式: {mode}")
print(f"🔗 API类型: {api_type}")
# 确认是否继续
confirm = input("\n确认开始生成？(y/N): ").strip().lower()
if confirm not in ['y', 'yes']:
print("取消操作")
return
# 6. 生成话术
all_results = generate_batch_callbacks_for_clinics(selected_clinics, api_type, mode)
if not all_results:
print("❌ 没有成功生成任何话术！")
return
# 7. 保存文件
saved_files = save_clinic_callbacks_to_files(all_results, api_type, mode)
# 8. 显示最终统计
print("\n" + "="*60)
print("🎉 诊所回访话术批量生成完成！")
print("="*60)
print(f"📊 处理统计:")
print(f" - 使用平台: Dify")
print(f" - API类型: {api_type.upper()}")
print(f" - 处理模式: {mode}")
print(f" - 处理诊所: {len(selected_clinics)} 个")
total_patients = sum(len(callbacks) for callbacks in all_results.values())
total_success = sum(len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
for callbacks in all_results.values())
total_failed = sum(len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
for callbacks in all_results.values())
print(f" - 总计患者: {total_patients} 个")
print(f" - ✅ 成功生成: {total_success} 个话术")
print(f" - ❌ 生成失败: {total_failed} 个")
print(f" - 📈 成功率: {(total_success/total_patients*100):.1f}%")
print(f"📁 输出目录: {get_dify_config().OUTPUT_DIR}/")
print(f"📄 生成文件数: {len(saved_files)} 个")
print("="*60)
except FileNotFoundError as e:
print(f"❌ 文件未找到: {e}")
print("请确保以下目录和文件存在：")
print(" - 诊所患者json/ 目录")
print(" - 诊所患者json/ 目录中的JSON文件")
except Exception as e:
print(f"❌ 运行过程中发生错误: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
main()
\ No newline at end of file
batch_generate_clinic_callbacks_enhanced.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
诊所患者回访话术批量生成器 - 增强版
支持断点续传、进度保存、错误恢复等功能
基于诊所患者json目录中的所有诊所文件，使用Dify平台批量生成个性化的回访话术
"""
import json
import os
import pickle
import signal
import sys
from datetime import datetime
from pathlib import Path
from dify_callback_api import DifyCallbackAPI
from dify_config import get_dify_config, map_patient_data
class CallbackGeneratorState:
"""生成器状态管理类"""
def __init__(self, session_id=None):
self.session_id = session_id or datetime.now().strftime('%Y%m%d_%H%M%S')
self.progress_dir = "progress_saves"
self.progress_file = f"{self.progress_dir}/session_{self.session_id}.pkl"
# 确保进度保存目录存在
os.makedirs(self.progress_dir, exist_ok=True)
# 状态数据
self.current_clinic = None
self.current_patient_index = 0
self.completed_clinics = []
self.current_clinic_callbacks = []
self.all_results = {}
self.generation_config = {}
self.start_time = None
self.last_save_time = None
def save_progress(self):
"""保存当前进度"""
try:
state_data = {
'session_id': self.session_id,
'current_clinic': self.current_clinic,
'current_patient_index': self.current_patient_index,
'completed_clinics': self.completed_clinics,
'current_clinic_callbacks': self.current_clinic_callbacks,
'all_results': self.all_results,
'generation_config': self.generation_config,
'start_time': self.start_time,
'last_save_time': datetime.now(),
'save_timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
with open(self.progress_file, 'wb') as f:
pickle.dump(state_data, f)
print(f"✓ 进度已保存: {self.progress_file}")
return True
except Exception as e:
print(f"❌ 保存进度失败: {e}")
return False
def load_progress(self):
"""加载之前的进度"""
try:
if not os.path.exists(self.progress_file):
return False
with open(self.progress_file, 'rb') as f:
state_data = pickle.load(f)
self.session_id = state_data.get('session_id', self.session_id)
self.current_clinic = state_data.get('current_clinic')
self.current_patient_index = state_data.get('current_patient_index', 0)
self.completed_clinics = state_data.get('completed_clinics', [])
self.current_clinic_callbacks = state_data.get('current_clinic_callbacks', [])
self.all_results = state_data.get('all_results', {})
self.generation_config = state_data.get('generation_config', {})
self.start_time = state_data.get('start_time')
self.last_save_time = state_data.get('last_save_time')
print(f"✓ 成功加载进度: {state_data.get('save_timestamp', '未知时间')}")
return True
except Exception as e:
print(f"❌ 加载进度失败: {e}")
return False
def list_saved_sessions(self):
"""列出所有保存的会话"""
sessions = []
if not os.path.exists(self.progress_dir):
return sessions
for file_name in os.listdir(self.progress_dir):
if file_name.startswith('session_') and file_name.endswith('.pkl'):
session_id = file_name[8:-4] # 去掉 'session_' 前缀和 '.pkl' 后缀
file_path = os.path.join(self.progress_dir, file_name)
try:
with open(file_path, 'rb') as f:
state_data = pickle.load(f)
sessions.append({
'session_id': session_id,
'save_time': state_data.get('save_timestamp', '未知'),
'current_clinic': state_data.get('current_clinic', '未知'),
'completed_clinics': len(state_data.get('completed_clinics', [])),
'current_patient_index': state_data.get('current_patient_index', 0),
'file_path': file_path
})
except:
continue
return sorted(sessions, key=lambda x: x['save_time'], reverse=True)
def cleanup_old_sessions(self, keep_recent=5):
"""清理旧的会话文件，保留最近的几个"""
sessions = self.list_saved_sessions()
if len(sessions) <= keep_recent:
return
for session in sessions[keep_recent:]:
try:
os.remove(session['file_path'])
print(f"清理旧会话: {session['session_id']}")
except:
pass
class EnhancedCallbackGenerator:
"""增强版回访话术生成器"""
def __init__(self):
self.state = None
self.api_client = None
self.config = None
self.interrupted = False
# 设置信号处理器
signal.signal(signal.SIGINT, self.signal_handler)
if hasattr(signal, 'SIGTERM'):
signal.signal(signal.SIGTERM, self.signal_handler)
def signal_handler(self, signum, frame):
"""处理中断信号"""
print(f"\n🛑 收到中断信号 ({signum})，正在保存进度...")
self.interrupted = True
if self.state:
self.state.save_progress()
print("✓ 进度已保存，可以稍后继续")
sys.exit(0)
def load_clinic_data(self):
"""加载所有诊所的患者数据"""
print("正在扫描诊所患者json目录...")
clinic_data_dir = "诊所患者json"
if not os.path.exists(clinic_data_dir):
raise FileNotFoundError(f"未找到目录: {clinic_data_dir}")
clinic_files = {}
total_patients = 0
for file_name in os.listdir(clinic_data_dir):
if file_name.endswith('.json') and not file_name.startswith('conversion_summary'):
file_path = os.path.join(clinic_data_dir, file_name)
clinic_name = Path(file_name).stem
try:
with open(file_path, 'r', encoding='utf-8') as f:
patients_data = json.load(f)
if patients_data: # 确保不是空文件
clinic_files[clinic_name] = {
'file_path': file_path,
'patients_data': patients_data,
'patient_count': len(patients_data)
}
total_patients += len(patients_data)
print(f"✓ 加载 {clinic_name}: {len(patients_data)} 个患者")
else:
print(f"⚠ 跳过空文件: {file_name}")
except Exception as e:
print(f"✗ 加载文件 {file_name} 时出错: {e}")
continue
if not clinic_files:
raise FileNotFoundError("未找到可用的诊所患者数据文件")
print(f"\n✅ 总共加载了 {len(clinic_files)} 个诊所的 {total_patients} 个患者数据")
return clinic_files
def check_for_resume(self):
"""检查是否有可恢复的会话"""
temp_state = CallbackGeneratorState()
sessions = temp_state.list_saved_sessions()
if not sessions:
return None
print("\n📋 发现以下未完成的会话:")
for i, session in enumerate(sessions, 1):
print(f" {i}. 会话ID: {session['session_id']}")
print(f" 保存时间: {session['save_time']}")
print(f" 当前诊所: {session['current_clinic']}")
print(f" 已完成诊所: {session['completed_clinics']} 个")
print(f" 当前患者索引: {session['current_patient_index']}")
print()
print(f" {len(sessions) + 1}. 开始新的会话")
while True:
try:
choice = input(f"请选择要恢复的会话 (1-{len(sessions) + 1}): ").strip()
choice_num = int(choice)
if choice_num == len(sessions) + 1:
return None # 开始新会话
elif 1 <= choice_num <= len(sessions):
selected_session = sessions[choice_num - 1]
self.state = CallbackGeneratorState(selected_session['session_id'])
if self.state.load_progress():
print(f"✓ 已恢复会话: {selected_session['session_id']}")
return self.state
else:
print("❌ 恢复会话失败")
return None
else:
print(f"请输入1-{len(sessions) + 1}之间的数字")
except ValueError:
print("请输入有效的数字")
except KeyboardInterrupt:
print("\n用户取消操作")
return None
def generate_callbacks_for_clinic(self, clinic_name, patients_data, api_type="agent_chat", resume_from=0):
"""为单个诊所生成回访话术，支持从指定位置继续"""
print(f"\n🏥 正在为 {clinic_name} 生成回访话术...")
print(f"📊 患者数量: {len(patients_data)}")
if resume_from > 0:
print(f"🔄 从第 {resume_from + 1} 个患者继续...")
# 初始化API客户端（如果还没有）
if not self.api_client:
self.config = get_dify_config()
if not self.config.validate_config():
raise ValueError("Dify配置验证失败，请检查API密钥和服务器地址")
self.api_client = DifyCallbackAPI(self.config.API_KEY, self.config.BASE_URL)
if not self.api_client.test_connection():
raise ConnectionError("无法连接到Dify服务器，请检查服务器地址和网络连接")
# 从状态中恢复已有的回调数据，或初始化新的
all_callbacks = self.state.current_clinic_callbacks if self.state.current_clinic_callbacks else []
success_count = len([cb for cb in all_callbacks if cb.get('callback_type') == 'success'])
failed_count = len([cb for cb in all_callbacks if cb.get('callback_type') == 'error'])
for i in range(resume_from, len(patients_data)):
if self.interrupted:
print("⚠ 检测到中断信号，停止处理")
break
patient_data = patients_data[i]
patient_id = patient_data.get('病历号', f'Unknown_{i+1}')
patient_name = patient_data.get('姓名', f'患者{i+1}')
print(f" [{i+1}/{len(patients_data)}] {patient_name}({patient_id})...", end=" ")
# 更新状态
self.state.current_patient_index = i
try:
# 根据API类型调用不同的方法
if api_type == "agent_chat":
callback_content = self.api_client.call_agent_chat(
patient_data,
timeout=self.config.REQUEST_TIMEOUT
)
elif api_type == "chat":
result = self.api_client.call_chat_completion(
patient_data,
timeout=self.config.REQUEST_TIMEOUT
)
callback_content = result.get('answer', '') or result.get('message', {}).get('content', '')
elif api_type == "completion":
callback_content = self.api_client.call_completion_api(
patient_data,
timeout=self.config.REQUEST_TIMEOUT
)
elif api_type == "workflow":
result = self.api_client.call_workflow(
patient_data,
timeout=self.config.REQUEST_TIMEOUT
)
callback_content = result.get('data', {}).get('outputs', {}).get('text', '') or str(result)
else:
raise ValueError(f"不支持的API类型: {api_type}")
if callback_content:
callback_data = {
'clinic_name': clinic_name,
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': callback_content,
'api_type': api_type,
'patient_data_summary': {
'last_visit_time': patient_data.get('最后一次就诊时间', ''),
'last_clinic': patient_data.get('最后一次就诊诊所', ''),
'last_doctor': patient_data.get('最后一次就诊医生', ''),
'diagnosis': patient_data.get('医生诊断', ''),
'last_treatment': patient_data.get('上次处置', ''),
'clinic_source': clinic_name
},
'callback_type': 'success'
}
all_callbacks.append(callback_data)
success_count += 1
print("✓")
else:
raise ValueError("API返回内容为空")
except Exception as e:
print(f"✗ {str(e)}")
error_data = {
'clinic_name': clinic_name,
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': '',
'api_type': api_type,
'error_message': str(e),
'callback_type': 'error'
}
all_callbacks.append(error_data)
failed_count += 1
# 更新状态中的回调数据
self.state.current_clinic_callbacks = all_callbacks
# 每处理5个患者保存一次进度
if (i + 1) % 5 == 0:
self.state.save_progress()
# 添加延迟避免频率限制
if self.config.REQUEST_DELAY > 0 and i < len(patients_data) - 1:
import time
time.sleep(self.config.REQUEST_DELAY)
print(f"\n🏥 {clinic_name} 处理完成: ✅{success_count} / ❌{failed_count}")
return all_callbacks
def save_intermediate_results(self, clinic_name, callbacks):
"""保存中间结果"""
config = get_dify_config()
output_dir = config.OUTPUT_DIR
if not os.path.exists(output_dir):
os.makedirs(output_dir)
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
clinic_safe_name = clinic_name.replace('/', '_').replace('\\', '_')
# 保存中间结果
intermediate_file = f"{output_dir}/中间结果_{clinic_safe_name}_{timestamp}.json"
with open(intermediate_file, 'w', encoding='utf-8') as f:
json.dump({
'clinic_name': clinic_name,
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'session_id': self.state.session_id,
'callbacks': callbacks
}, f, ensure_ascii=False, indent=2)
print(f"✓ 中间结果已保存: {os.path.basename(intermediate_file)}")
return intermediate_file
def start_generation(self):
"""开始生成流程"""
print("="*60)
print("诊所患者回访话术批量生成器 - 增强版")
print("支持断点续传、进度保存、错误恢复")
print("="*60)
try:
# 1. 检查是否有可恢复的会话
resume_state = self.check_for_resume()
if resume_state:
# 恢复会话
self.state = resume_state
print(f"📋 恢复会话配置:")
print(f" - API类型: {self.state.generation_config.get('api_type', '未知')}")
print(f" - 处理模式: {self.state.generation_config.get('mode', '未知')}")
print(f" - 已完成诊所: {len(self.state.completed_clinics)} 个")
print(f" - 当前诊所: {self.state.current_clinic}")
print(f" - 当前进度: 第 {self.state.current_patient_index + 1} 个患者")
confirm = input("\n确认继续这个会话？(Y/n): ").strip().lower()
if confirm in ['n', 'no']:
print("取消恢复会话")
return
# 加载诊所数据继续处理
clinic_files = self.load_clinic_data()
return self.resume_generation(clinic_files)
else:
# 开始新会话
return self.start_new_generation()
except Exception as e:
print(f"❌ 运行过程中发生错误: {e}")
import traceback
traceback.print_exc()
def start_new_generation(self):
"""开始新的生成会话"""
# 创建新的状态
self.state = CallbackGeneratorState()
self.state.start_time = datetime.now()
# 加载诊所数据
clinic_files = self.load_clinic_data()
# 选择诊所、模式、API类型等（复用原有逻辑）
selected_clinics = self.select_clinics(clinic_files)
if not selected_clinics:
return
# 选择处理模式和API类型
mode, api_type = self.select_generation_options()
# 保存配置到状态
self.state.generation_config = {
'mode': mode,
'api_type': api_type,
'selected_clinics': list(selected_clinics.keys()),
'total_patients': sum(clinic['patient_count'] for clinic in selected_clinics.values())
}
# 保存初始状态
self.state.save_progress()
print(f"\n🚀 开始新的生成会话: {self.state.session_id}")
# 开始处理
return self.process_clinics(selected_clinics, mode, api_type)
def resume_generation(self, clinic_files):
"""恢复之前的生成会话"""
# 重建选定的诊所数据
config = self.state.generation_config
selected_clinics = {}
for clinic_name in config.get('selected_clinics', []):
if clinic_name in clinic_files:
selected_clinics[clinic_name] = clinic_files[clinic_name]
mode = config.get('mode', 'separate')
api_type = config.get('api_type', 'agent_chat')
print(f"🔄 恢复处理...")
return self.process_clinics(selected_clinics, mode, api_type, resume=True)
def select_clinics(self, clinic_files):
"""选择要处理的诊所"""
print("\n📋 可用的诊所:")
clinic_list = list(clinic_files.keys())
for i, clinic_name in enumerate(clinic_list, 1):
patient_count = clinic_files[clinic_name]['patient_count']
print(f" {i}. {clinic_name} ({patient_count} 个患者)")
print(f" {len(clinic_list) + 1}. 全部诊所")
while True:
try:
choice = input(f"\n请选择要处理的诊所 (1-{len(clinic_list) + 1}): ").strip()
if choice == str(len(clinic_list) + 1):
return clinic_files
else:
choice_num = int(choice)
if 1 <= choice_num <= len(clinic_list):
selected_clinic = clinic_list[choice_num - 1]
return {selected_clinic: clinic_files[selected_clinic]}
else:
print(f"请输入1-{len(clinic_list) + 1}之间的数字")
except ValueError:
print("请输入有效的数字")
except KeyboardInterrupt:
print("\n用户取消操作")
return None
def select_generation_options(self):
"""选择生成选项"""
# 选择处理模式
print("\n📋 请选择处理模式:")
print("1. 分诊所生成 (为每个诊所生成单独的话术文件)")
print("2. 合并生成 (将所有诊所患者合并后生成)")
while True:
try:
mode_choice = input("请选择处理模式 (1-2): ").strip()
if mode_choice == "1":
mode = "separate"
break
elif mode_choice == "2":
mode = "merged"
break
else:
print("无效选择，请输入1或2")
except KeyboardInterrupt:
print("\n用户取消操作")
return None, None
# 选择API类型
print("\n📋 请选择API类型:")
print("1. Agent Chat API (智能对话) - 推荐")
print("2. Chat API (聊天完成)")
print("3. Completion API (文本完成)")
print("4. Workflow API (工作流)")
while True:
try:
api_choice = input("请输入选择 (1-4): ").strip()
if api_choice == "1":
api_type = "agent_chat"
break
elif api_choice == "2":
api_type = "chat"
break
elif api_choice == "3":
api_type = "completion"
break
elif api_choice == "4":
api_type = "workflow"
break
else:
print("无效选择，请输入1-4")
except KeyboardInterrupt:
print("\n用户取消操作")
return None, None
return mode, api_type
def process_clinics(self, selected_clinics, mode, api_type, resume=False):
"""处理诊所数据"""
if mode == "separate":
# 分诊所处理
clinic_list = list(selected_clinics.keys())
# 确定从哪个诊所开始
start_clinic_index = 0
if resume and self.state.current_clinic:
try:
start_clinic_index = clinic_list.index(self.state.current_clinic)
except ValueError:
start_clinic_index = 0
for i in range(start_clinic_index, len(clinic_list)):
if self.interrupted:
break
clinic_name = clinic_list[i]
clinic_info = selected_clinics[clinic_name]
# 检查是否已经完成
if clinic_name in self.state.completed_clinics:
print(f"⏭ 跳过已完成的诊所: {clinic_name}")
continue
self.state.current_clinic = clinic_name
# 确定从哪个患者开始
resume_from = 0
if resume and clinic_name == self.state.current_clinic:
resume_from = self.state.current_patient_index
try:
callbacks = self.generate_callbacks_for_clinic(
clinic_name,
clinic_info['patients_data'],
api_type,
resume_from
)
# 保存这个诊所的结果
self.state.all_results[clinic_name] = callbacks
self.state.completed_clinics.append(clinic_name)
self.state.current_clinic_callbacks = [] # 清空当前诊所的临时数据
self.state.current_patient_index = 0 # 重置患者索引
# 保存中间结果
self.save_intermediate_results(clinic_name, callbacks)
# 保存进度
self.state.save_progress()
except Exception as e:
print(f"❌ 处理诊所 {clinic_name} 时出错: {e}")
# 保存当前进度即使出错
self.state.save_progress()
continue
# 最终保存和统计
if not self.interrupted:
self.finalize_results(mode, api_type)
def finalize_results(self, mode, api_type):
"""完成处理并保存最终结果"""
print("\n💾 保存最终结果...")
# 清理状态文件
if os.path.exists(self.state.progress_file):
os.remove(self.state.progress_file)
print("✓ 清理进度文件")
# 保存最终统计
total_patients = sum(len(callbacks) for callbacks in self.state.all_results.values())
total_success = sum(len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
for callbacks in self.state.all_results.values())
total_failed = sum(len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
for callbacks in self.state.all_results.values())
print("\n" + "="*60)
print("🎉 诊所回访话术批量生成完成！")
print("="*60)
print(f"📊 最终统计:")
print(f" - 会话ID: {self.state.session_id}")
print(f" - 处理诊所: {len(self.state.all_results)} 个")
print(f" - 总计患者: {total_patients} 个")
print(f" - ✅ 成功生成: {total_success} 个话术")
print(f" - ❌ 生成失败: {total_failed} 个")
print(f" - 📈 成功率: {(total_success/total_patients*100):.1f}%")
print("="*60)
def main():
"""主函数"""
generator = EnhancedCallbackGenerator()
generator.start_generation()
if __name__ == "__main__":
main()
\ No newline at end of file
batch_generate_dify_callback.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Dify平台批量回访话术生成器
基于漏诊客户画像和病历漏诊信息，使用Dify平台批量生成个性化的回访话术
"""
import json
import os
from datetime import datetime
from dify_callback_api import DifyCallbackAPI
from dify_config import get_dify_config, map_patient_data
def load_patient_data():
"""加载患者数据"""
print("正在加载患者数据...")
# 尝试加载不同的数据文件
data_files = [
'漏诊客户画像.json',
'合并结果.json',
'2024年11月份至2025年6月江苏通善客户数据.json'
]
patients_data = None
loaded_file = None
for file_name in data_files:
try:
with open(file_name, 'r', encoding='utf-8') as f:
patients_data = json.load(f)
loaded_file = file_name
print(f"成功加载患者数据文件: {file_name}")
break
except FileNotFoundError:
continue
except Exception as e:
print(f"加载文件 {file_name} 时出错: {e}")
continue
if not patients_data:
raise FileNotFoundError("未找到可用的患者数据文件")
print(f"已加载 {len(patients_data)} 个患者数据")
return patients_data, loaded_file
def load_missed_diagnosis_data():
"""加载漏诊数据（可选）"""
try:
with open('病历漏诊信息.json', 'r', encoding='utf-8') as f:
missed_diagnosis_data = json.load(f)
print(f"已加载 {len(missed_diagnosis_data.get('病历漏诊信息', []))} 个漏诊信息")
return missed_diagnosis_data
except FileNotFoundError:
print("未找到漏诊信息文件，将只使用基础患者数据")
return None
except Exception as e:
print(f"加载漏诊信息时出错: {e}")
return None
def match_patient_with_missed_diagnosis(patients_data, missed_diagnosis_data):
"""匹配患者数据和漏诊信息"""
if not missed_diagnosis_data:
return patients_data
print("正在匹配患者数据和漏诊信息...")
# 创建漏诊信息的字典，以病历号为键
missed_diagnosis_dict = {}
for record in missed_diagnosis_data.get('病历漏诊信息', []):
missed_diagnosis_dict[record['病历号']] = record
# 为患者数据添加漏诊信息
matched_patients = []
for patient in patients_data:
patient_id = patient.get('病历号')
if patient_id and patient_id in missed_diagnosis_dict:
# 复制患者数据并添加漏诊信息
enhanced_patient = patient.copy()
enhanced_patient['missed_diagnosis'] = missed_diagnosis_dict[patient_id]
matched_patients.append(enhanced_patient)
else:
# 没有漏诊信息的患者也保留
matched_patients.append(patient)
print(f"成功匹配 {sum(1 for p in matched_patients if 'missed_diagnosis' in p)} 个患者的漏诊信息")
return matched_patients
def generate_batch_callbacks_with_dify(patients_data, api_type="chat"):
"""使用Dify平台批量生成回访话术"""
print(f"正在使用Dify平台批量生成回访话术（API类型: {api_type}）...")
# 获取配置
config = get_dify_config()
# 验证配置
if not config.validate_config():
raise ValueError("Dify配置验证失败，请检查API密钥和服务器地址")
# 初始化Dify API客户端
api_client = DifyCallbackAPI(config.API_KEY, config.BASE_URL)
# 测试连接
if not api_client.test_connection():
raise ConnectionError("无法连接到Dify服务器，请检查服务器地址和网络连接")
# 存储所有生成的话术
all_callbacks = []
success_count = 0
failed_count = 0
for i, patient_data in enumerate(patients_data, 1):
patient_id = patient_data.get('病历号', f'Unknown_{i}')
patient_name = patient_data.get('姓名', f'患者{i}')
print(f"\n[{i}/{len(patients_data)}] 正在为患者 {patient_name}({patient_id}) 生成话术...")
try:
# 根据API类型调用不同的方法
if api_type == "agent_chat":
callback_content = api_client.call_agent_chat(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
elif api_type == "chat":
result = api_client.call_chat_completion(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
callback_content = result.get('answer', '') or result.get('message', {}).get('content', '')
elif api_type == "completion":
callback_content = api_client.call_completion_api(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
elif api_type == "workflow":
result = api_client.call_workflow(
patient_data,
timeout=config.REQUEST_TIMEOUT
)
# 从工作流结果中提取内容
callback_content = result.get('data', {}).get('outputs', {}).get('text', '') or str(result)
else:
raise ValueError(f"不支持的API类型: {api_type}")
if callback_content:
callback_data = {
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': callback_content,
'api_type': api_type,
'has_missed_diagnosis': 'missed_diagnosis' in patient_data,
'patient_data_summary': {
'last_visit_time': patient_data.get('最后一次就诊时间', ''),
'last_clinic': patient_data.get('最后一次就诊诊所', ''),
'last_doctor': patient_data.get('最后一次就诊医生', ''),
'visit_count': patient_data.get('累计就诊次数', 0)
},
'callback_type': 'success'
}
# 添加漏诊信息摘要（如果存在）
if 'missed_diagnosis' in patient_data:
missed_info = patient_data['missed_diagnosis']
callback_data['missed_diagnosis_summary'] = {
'total_count': missed_info.get('漏诊总次数', 0),
'estimated_cost': missed_info.get('预估治疗费用', 0),
'projects': missed_info.get('漏诊项目', [])
}
all_callbacks.append(callback_data)
success_count += 1
print(f"✓ 生成成功")
else:
raise ValueError("API返回内容为空")
except Exception as e:
print(f"✗ 生成失败: {str(e)}")
error_data = {
'patient_id': patient_id,
'patient_name': patient_name,
'age': patient_data.get('年龄', ''),
'gender': patient_data.get('性别', ''),
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'callback_script': '',
'api_type': api_type,
'error_message': str(e),
'callback_type': 'error'
}
all_callbacks.append(error_data)
failed_count += 1
# 添加延迟避免频率限制
if config.REQUEST_DELAY > 0 and i < len(patients_data):
import time
print(f"等待 {config.REQUEST_DELAY} 秒后处理下一个患者...")
time.sleep(config.REQUEST_DELAY)
print(f"\n批量生成完成！")
print(f"✅ 成功生成: {success_count}")
print(f"❌ 失败: {failed_count}")
print(f"📊 总计处理: {len(all_callbacks)}")
return all_callbacks
def save_callbacks_to_file(all_callbacks, api_type="chat"):
"""保存话术到文件"""
print("正在保存话术到文件...")
# 创建输出目录
config = get_dify_config()
output_dir = config.OUTPUT_DIR
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# 生成时间戳
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
# 保存完整的JSON文件
json_filename = f"{output_dir}/Dify回访话术_完整版_{api_type}_{timestamp}.json"
with open(json_filename, 'w', encoding='utf-8') as f:
json.dump({
'generation_info': {
'platform': 'Dify',
'api_type': api_type,
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'total_count': len(all_callbacks),
'success_count': len([cb for cb in all_callbacks if cb.get('callback_type') == 'success']),
'error_count': len([cb for cb in all_callbacks if cb.get('callback_type') == 'error'])
},
'callbacks': all_callbacks
}, f, ensure_ascii=False, indent=2)
# 只保存成功生成的话术
success_callbacks = [cb for cb in all_callbacks if cb.get('callback_type') == 'success']
error_callbacks = [cb for cb in all_callbacks if cb.get('callback_type') == 'error']
# 保存简化的话术文本文件
txt_filename = f"{output_dir}/Dify回访话术_文本版_{api_type}_{timestamp}.txt"
with open(txt_filename, 'w', encoding='utf-8') as f:
f.write("="*60 + "\n")
f.write("Dify平台回访话术批量生成结果\n")
f.write(f"API类型: {api_type.upper()}\n")
f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"总计处理: {len(all_callbacks)} 个患者\n")
f.write(f"成功生成: {len(success_callbacks)} 个话术\n")
f.write(f"生成失败: {len(error_callbacks)} 个\n")
f.write("="*60 + "\n\n")
# 写入成功生成的话术
for i, callback in enumerate(success_callbacks, 1):
f.write(f"【{i}】患者: {callback['patient_name']} ({callback['patient_id']})\n")
f.write(f"年龄: {callback['age']}岁, 性别: {callback['gender']}\n")
f.write(f"最后就诊: {callback['patient_data_summary'].get('last_visit_time', '未知')}\n")
f.write(f"就诊医生: {callback['patient_data_summary'].get('last_doctor', '未知')}\n")
f.write(f"就诊次数: {callback['patient_data_summary'].get('visit_count', 0)}次\n")
if callback.get('has_missed_diagnosis') and 'missed_diagnosis_summary' in callback:
missed_summary = callback['missed_diagnosis_summary']
f.write(f"漏诊次数: {missed_summary['total_count']}次\n")
f.write(f"预估费用: {missed_summary['estimated_cost']}元\n")
f.write("-"*40 + "\n")
f.write("回访话术:\n")
f.write(callback['callback_script'])
f.write("\n" + "="*60 + "\n\n")
# 添加失败患者的信息
if error_callbacks:
f.write("\n" + "="*60 + "\n")
f.write("生成失败的患者\n")
f.write("="*60 + "\n\n")
for i, callback in enumerate(error_callbacks, 1):
f.write(f"【{i}】患者: {callback['patient_name']} ({callback['patient_id']})\n")
f.write(f"年龄: {callback['age']}岁, 性别: {callback['gender']}\n")
f.write(f"失败原因: {callback.get('error_message', '未知错误')}\n")
f.write("-"*40 + "\n\n")
# 生成统计报告
stats_filename = f"{output_dir}/Dify回访话术_统计报告_{api_type}_{timestamp}.json"
# 统计分析（只统计成功生成的话术）
age_groups = {'儿童': 0, '青少年': 0, '青年': 0, '中年': 0, '老年': 0}
gender_stats = {'男': 0, '女': 0, '未知': 0}
missed_diagnosis_stats = {'有漏诊': 0, '无漏诊': 0}
for callback in success_callbacks:
# 年龄分组
try:
age = int(callback['age']) if callback['age'] else 0
if age <= 12:
age_groups['儿童'] += 1
elif age <= 18:
age_groups['青少年'] += 1
elif age <= 35:
age_groups['青年'] += 1
elif age <= 60:
age_groups['中年'] += 1
else:
age_groups['老年'] += 1
except:
age_groups['中年'] += 1 # 默认分组
# 性别统计
gender = callback['gender'] if callback['gender'] in ['男', '女'] else '未知'
gender_stats[gender] += 1
# 漏诊统计
if callback.get('has_missed_diagnosis'):
missed_diagnosis_stats['有漏诊'] += 1
else:
missed_diagnosis_stats['无漏诊'] += 1
stats_data = {
'generation_info': {
'platform': 'Dify',
'api_type': api_type,
'generation_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'total_processed': len(all_callbacks),
'successful_callbacks': len(success_callbacks),
'failed_callbacks': len(error_callbacks),
'success_rate': f"{(len(success_callbacks)/len(all_callbacks)*100):.1f}%" if all_callbacks else "0%"
},
'statistics': {
'age_distribution': age_groups,
'gender_distribution': gender_stats,
'missed_diagnosis_distribution': missed_diagnosis_stats
},
'summary': {
'most_common_age_group': max(age_groups.items(), key=lambda x: x[1])[0] if any(age_groups.values()) else '无',
'gender_ratio': f"男:{gender_stats['男']}, 女:{gender_stats['女']}, 未知:{gender_stats['未知']}",
'missed_diagnosis_ratio': f"有漏诊:{missed_diagnosis_stats['有漏诊']}, 无漏诊:{missed_diagnosis_stats['无漏诊']}"
}
}
with open(stats_filename, 'w', encoding='utf-8') as f:
json.dump(stats_data, f, ensure_ascii=False, indent=2)
print(f"✓ 完整版JSON文件已保存: {json_filename}")
print(f"✓ 文本版话术文件已保存: {txt_filename}")
print(f"✓ 统计报告已保存: {stats_filename}")
return json_filename, txt_filename, stats_filename
def main():
"""主函数"""
print("="*60)
print("Dify平台回访话术批量生成器")
print("="*60)
try:
# 1. 加载患者数据
patients_data, loaded_file = load_patient_data()
# 2. 数据已经是合并格式，包含了漏诊信息，无需额外加载和匹配
# 4. 选择API类型
print("\n请选择API类型:")
print("1. Agent Chat API (智能对话) - 推荐")
print("2. Chat API (聊天完成)")
print("3. Completion API (文本完成)")
print("4. Workflow API (工作流)")
while True:
try:
choice = input("请输入选择 (1-4): ").strip()
if choice == "1":
api_type = "agent_chat"
break
elif choice == "2":
api_type = "chat"
break
elif choice == "3":
api_type = "completion"
break
elif choice == "4":
api_type = "workflow"
break
else:
print("无效选择，请输入1-4")
except KeyboardInterrupt:
print("\n用户取消操作")
return
# 5. 选择处理数量
print(f"\n总共有 {len(patients_data)} 个患者数据")
while True:
try:
count_input = input("请输入要处理的患者数量 (直接回车处理全部): ").strip()
if not count_input:
process_count = len(patients_data)
break
else:
process_count = int(count_input)
if 1 <= process_count <= len(patients_data):
break
else:
print(f"请输入1-{len(patients_data)}之间的数字")
except ValueError:
print("请输入有效的数字")
except KeyboardInterrupt:
print("\n用户取消操作")
return
# 6. 生成话术
selected_patients = patients_data[:process_count]
print(f"\n将处理前 {process_count} 个患者")
all_callbacks = generate_batch_callbacks_with_dify(selected_patients, api_type)
if not all_callbacks:
print("❌ 没有成功生成任何话术！")
return
# 7. 保存文件
json_file, txt_file, stats_file = save_callbacks_to_file(all_callbacks, api_type)
# 统计信息
success_count = len([cb for cb in all_callbacks if cb.get('callback_type') == 'success'])
error_count = len([cb for cb in all_callbacks if cb.get('callback_type') == 'error'])
print("\n" + "="*60)
print("🎉 Dify平台批量生成完成！")
print("="*60)
print(f"📊 处理统计:")
print(f" - 使用平台: Dify")
print(f" - API类型: {api_type.upper()}")
print(f" - 数据来源: {loaded_file}")
print(f" - 总计处理: {len(all_callbacks)} 个患者")
print(f" - ✅ 成功生成: {success_count} 个话术")
print(f" - ❌ 生成失败: {error_count} 个")
print(f" - 📈 成功率: {(success_count/len(all_callbacks)*100):.1f}%")
print(f"📁 输出目录: {get_dify_config().OUTPUT_DIR}/")
print("📄 生成文件:")
print(f" - 完整版JSON: {os.path.basename(json_file)}")
print(f" - 文本版话术: {os.path.basename(txt_file)}")
print(f" - 统计报告: {os.path.basename(stats_file)}")
print("="*60)
except FileNotFoundError as e:
print(f"❌ 文件未找到: {e}")
print("请确保以下文件存在：")
print(" - 漏诊客户画像.json 或 合并结果.json")
print(" - 病历漏诊信息.json (可选)")
except Exception as e:
print(f"❌ 运行过程中发生错误: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
main()
\ No newline at end of file
check_callback_duplicates.py deleted 100644 → 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
回访话术重复检查工具
检查所有患者画像页面中是否存在重复的回访话术记录
"""
import os
import re
import sys
# 确保输出为UTF-8编码
if sys.stdout.encoding != 'utf-8':
sys.stdout.reconfigure(encoding='utf-8')
def check_callback_duplicates(profiles_dir='patient_profiles'):
"""检查患者画像页面中的回访话术重复情况"""
if not os.path.exists(profiles_dir):
print(f"患者画像目录不存在: {profiles_dir}")
return
print("=" * 60)
print("回访话术重复检查工具")
print("=" * 60)
html_files = [f for f in os.listdir(profiles_dir) if f.endswith('.html')]
total_files = len(html_files)
duplicate_files = []
for html_file in html_files:
file_path = os.path.join(profiles_dir, html_file)
patient_id = html_file.replace('.html', '')
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 查找所有的 callback-content 块
callback_content_matches = re.findall(r'<div id="callback-content"', content)
count = len(callback_content_matches)
if count > 1:
duplicate_files.append((patient_id, count))
print(f"❌ {patient_id}: 发现 {count} 个重复的回访话术块")
elif count == 1:
print(f"✅ {patient_id}: 回访话术正常 (1个)")
else:
print(f"⚠️ {patient_id}: 没有回访话术")
except Exception as e:
print(f"❌ {patient_id}: 读取文件时出错 - {e}")
print("\n" + "=" * 60)
print("检查结果汇总")
print("=" * 60)
print(f"总计检查文件: {total_files}")
print(f"发现重复问题: {len(duplicate_files)} 个")
if duplicate_files:
print("\n重复问题详情:")
for patient_id, count in duplicate_files:
print(f" - {patient_id}: {count} 个重复块")
else:
print("🎉 所有患者页面的回访话术都正常，没有重复问题！")
print("=" * 60)
def main():
"""主函数"""
check_callback_duplicates()
if __name__ == "__main__":
main()
\ No newline at end of file
check_chenxinyu_config.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
检查陈心语用户配置
"""
from clinic_config import DEFAULT_USERS, get_user_by_username
def main():
print("🔍 检查陈心语用户配置")
print("=" * 50)
# 查找陈心语用户
chenxinyu = get_user_by_username('chenxinyu')
if chenxinyu:
print("✅ 找到陈心语用户配置:")
print(f" 用户名: {chenxinyu['username']}")
print(f" 真实姓名: {chenxinyu['real_name']}")
print(f" 角色: {chenxinyu['role']}")
print(f" 诊所ID: {chenxinyu['clinic_id']}")
print(f" 诊所名称: {chenxinyu['clinic_name']}")
print(f" 密码: {chenxinyu['password']}")
# 检查权限
if chenxinyu['clinic_id'] == 'clinic_helai':
print("\n✅ 权限已正确调整到河埒诊所")
else:
print(f"\n❌ 权限还是 {chenxinyu['clinic_id']}，需要调整")
else:
print("❌ 未找到陈心语用户配置")
# 显示所有用户
print(f"\n👥 所有用户列表 ({len(DEFAULT_USERS)} 个):")
for user in DEFAULT_USERS:
clinic_name = user.get('clinic_name', '总部')
print(f" {user['username']} ({user['real_name']}) - {user['role']} - {clinic_name}")
if __name__ == "__main__":
main()
\ No newline at end of file
check_db_records.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
检查数据库中的回访记录详情
"""
import pymysql
from datetime import datetime
def check_callback_records():
"""检查回访记录详情"""
try:
# 连接数据库
connection = pymysql.connect(
host='localhost',
port=3307,
user='callback_user',
password='dev_password_123',
database='callback_system',
charset='utf8mb4',
use_unicode=True,
init_command='SET NAMES utf8mb4'
)
cursor = connection.cursor()
# 查看表结构
print("=== 回访记录表结构 ===")
cursor.execute("DESCRIBE callback_records")
columns = cursor.fetchall()
for col in columns:
print(f"{col[0]}: {col[1]} {col[2]} {col[3]}")
print("\n=== 最新5条回访记录 ===")
cursor.execute("""
SELECT record_id, case_number, callback_methods, callback_result,
callback_record, operator, create_time
FROM callback_records
ORDER BY create_time DESC
LIMIT 5
""")
records = cursor.fetchall()
for record in records:
print(f"\n记录ID: {record[0]}")
print(f"病例号: {record[1]}")
print(f"回访方式: {record[2]}")
print(f"回访结果: {record[3]}")
print(f"回访记录: {record[4]}")
print(f"操作员: {record[5]}")
print(f"创建时间: {record[6]}")
print("-" * 50)
# 检查是否有失败原因等字段
print("\n=== 检查失败原因字段 ===")
cursor.execute("SHOW COLUMNS FROM callback_records LIKE '%failure%'")
failure_cols = cursor.fetchall()
if failure_cols:
print("失败原因相关字段:")
for col in failure_cols:
print(f" {col[0]}: {col[1]}")
else:
print("没有找到失败原因相关字段")
cursor.close()
connection.close()
except Exception as e:
print(f"数据库连接失败: {e}")
if __name__ == "__main__":
check_callback_records()
\ No newline at end of file
check_db_structure.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
查看数据库表结构
"""
import sqlite3
import os
def check_database_structure():
"""检查数据库表结构"""
db_path = "callback_records.db"
if not os.path.exists(db_path):
print(f"数据库文件 {db_path} 不存在")
return
try:
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
# 获取表结构
cursor.execute("PRAGMA table_info(callback_records)")
columns = cursor.fetchall()
print("=== 数据库表结构 ===")
print(f"表名: callback_records")
print(f"字段数量: {len(columns)}")
print("\n字段详情:")
print("-" * 60)
print(f"{'序号':<4} {'字段名':<20} {'类型':<15} {'是否为空':<8} {'默认值':<10}")
print("-" * 60)
for row in columns:
cid, name, type_name, not_null, default_value, pk = row
print(f"{cid:<4} {name:<20} {type_name:<15} {'NOT NULL' if not_null else 'NULL':<8} {str(default_value):<10}")
# 查看放弃回访原因字段的详细信息
print("\n=== 放弃回访原因字段详情 ===")
abandon_reason_info = None
for row in columns:
if row[1] == 'abandon_reason':
abandon_reason_info = row
break
if abandon_reason_info:
print(f"字段名: {abandon_reason_info[1]}")
print(f"数据类型: {abandon_reason_info[2]}")
print(f"是否允许空值: {'否' if abandon_reason_info[3] else '是'}")
print(f"默认值: {abandon_reason_info[4]}")
print(f"是否主键: {'是' if abandon_reason_info[5] else '否'}")
else:
print("未找到 abandon_reason 字段")
# 查看表中的数据示例
print("\n=== 数据示例 ===")
cursor.execute("SELECT * FROM callback_records LIMIT 3")
rows = cursor.fetchall()
if rows:
print(f"找到 {len(rows)} 条记录")
for i, row in enumerate(rows, 1):
print(f"\n记录 {i}:")
for j, value in enumerate(row):
column_name = columns[j][1] if j < len(columns) else f"col_{j}"
print(f" {column_name}: {value}")
else:
print("表中暂无数据")
conn.close()
except Exception as e:
print(f"查看数据库结构时出错: {e}")
if __name__ == "__main__":
check_database_structure()
\ No newline at end of file
check_patient.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
# 加载患者数据
with open('合并结果.json', encoding='utf-8') as f:
data = json.load(f)
# 查找TS0K064355患者
found = False
for patient in data:
if patient.get('病历号') == 'TS0K064355':
print(f'✅ 找到患者: {patient.get("姓名", "未知")} - {patient.get("病历号")}')
found = True
break
if not found:
print('❌ 未找到病历号为TS0K064355的患者')
print('前10个患者的病历号:')
for i, patient in enumerate(data[:10]):
print(f' {i+1}. {patient.get("病历号", "未知")}')
# 查找包含064355的病历号
print('\n包含064355的病历号:')
for patient in data:
case_num = patient.get('病历号', '')
if '064355' in case_num:
print(f' - {case_num} ({patient.get("姓名", "未知")})')
\ No newline at end of file
check_progress.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
检查回访话术生成进度
显示当前会话的详细状态信息
"""
import os
import pickle
from datetime import datetime
def check_progress():
"""检查当前进度"""
print("📊 检查回访话术生成进度...")
progress_dir = "progress_saves"
if not os.path.exists(progress_dir):
print("❌ 未找到进度保存目录")
return
session_files = []
for file_name in os.listdir(progress_dir):
if file_name.startswith('session_') and file_name.endswith('.pkl'):
file_path = os.path.join(progress_dir, file_name)
session_files.append((file_name, file_path, os.path.getmtime(file_path)))
if not session_files:
print("❌ 未找到任何保存的会话")
return
# 按修改时间排序
session_files.sort(key=lambda x: x[2], reverse=True)
print(f"\n📋 找到 {len(session_files)} 个保存的会话:")
print("=" * 60)
for i, (file_name, file_path, mtime) in enumerate(session_files, 1):
session_id = file_name[8:-4]
try:
with open(file_path, 'rb') as f:
state_data = pickle.load(f)
save_time = datetime.fromtimestamp(mtime).strftime('%Y-%m-%d %H:%M:%S')
print(f"🔹 会话 {i}: {session_id}")
print(f" 保存时间: {save_time}")
print(f" 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" 当前患者索引: {state_data.get('current_patient_index', 0) + 1}")
completed = state_data.get('completed_clinics', [])
print(f" 已完成诊所 ({len(completed)}): {', '.join(completed) if completed else '无'}")
config = state_data.get('generation_config', {})
print(f" API类型: {config.get('api_type', '未知')}")
print(f" 处理模式: {config.get('mode', '未知')}")
selected_clinics = config.get('selected_clinics', [])
remaining_clinics = [c for c in selected_clinics if c not in completed]
print(f" 剩余诊所 ({len(remaining_clinics)}): {', '.join(remaining_clinics) if remaining_clinics else '无'}")
# 计算进度百分比
total_clinics = len(selected_clinics)
completed_clinics = len(completed)
if total_clinics > 0:
progress_percent = (completed_clinics / total_clinics) * 100
print(f" 整体进度: {completed_clinics}/{total_clinics} ({progress_percent:.1f}%)")
print("-" * 60)
except Exception as e:
print(f"❌ 读取会话 {session_id} 失败: {e}")
print("-" * 60)
# 显示最新会话的详细信息
if session_files:
latest_file = session_files[0][1]
print(f"\n🔍 最新会话详细信息:")
try:
with open(latest_file, 'rb') as f:
state_data = pickle.load(f)
print(f"📅 开始时间: {state_data.get('start_time', '未知')}")
print(f"💾 最后保存: {state_data.get('save_timestamp', '未知')}")
# 显示当前诊所的处理结果
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
success_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'success'])
error_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'error'])
print(f"📊 当前诊所已处理: {len(current_callbacks)} 个患者")
print(f" ✅ 成功: {success_count} 个")
print(f" ❌ 失败: {error_count} 个")
# 显示所有已完成诊所的统计
all_results = state_data.get('all_results', {})
if all_results:
print(f"\n📈 已完成诊所统计:")
total_processed = 0
total_success = 0
total_failed = 0
for clinic_name, callbacks in all_results.items():
success = len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
failed = len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
total_processed += len(callbacks)
total_success += success
total_failed += failed
print(f" 🏥 {clinic_name}: {success}✅ / {failed}❌ (共{len(callbacks)}个)")
print(f"\n📊 总计统计:")
print(f" 总处理患者: {total_processed} 个")
print(f" 总成功: {total_success} 个")
print(f" 总失败: {total_failed} 个")
if total_processed > 0:
success_rate = (total_success / total_processed) * 100
print(f" 成功率: {success_rate:.1f}%")
except Exception as e:
print(f"❌ 读取详细信息失败: {e}")
if __name__ == "__main__":
check_progress()
\ No newline at end of file
check_users_table.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
检查数据库用户表和用户数据
"""
import pymysql
import json
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3306,
'user': 'root',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4',
'use_unicode': True,
'init_command': 'SET NAMES utf8mb4',
'sql_mode': 'STRICT_TRANS_TABLES',
'read_timeout': 30,
'write_timeout': 30,
'connect_timeout': 30
}
def connect_database():
"""连接数据库"""
try:
connection = pymysql.connect(**DB_CONFIG)
print("✅ 数据库连接成功")
return connection
except Exception as e:
print(f"❌ 数据库连接失败: {e}")
return None
def check_table_structure(connection):
"""检查用户表结构"""
try:
with connection.cursor() as cursor:
# 检查表是否存在
cursor.execute("SHOW TABLES LIKE 'users'")
if not cursor.fetchone():
print("❌ users表不存在")
return False
# 查看表结构
cursor.execute("DESCRIBE users")
columns = cursor.fetchall()
print("\n📋 users表结构:")
for col in columns:
print(f" {col[0]} - {col[1]} - {col[2]}")
return True
except Exception as e:
print(f"❌ 检查表结构失败: {e}")
return False
def check_all_users(connection):
"""检查所有用户"""
try:
with connection.cursor() as cursor:
cursor.execute("SELECT username, user_type, clinic_access, created_at, is_active FROM users")
users = cursor.fetchall()
print(f"\n👥 数据库中的用户 ({len(users)} 个):")
for user in users:
print(f" {user[0]} - {user[1]} - {user[2]} - {user[4]}")
return users
except Exception as e:
print(f"❌ 查询用户失败: {e}")
return []
def check_specific_user(connection, username):
"""检查特定用户"""
try:
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))
user = cursor.fetchone()
if user:
print(f"\n✅ 找到用户 {username}:")
cursor.execute("DESCRIBE users")
columns = [col[0] for col in cursor.fetchall()]
for i, col in enumerate(columns):
print(f" {col}: {user[i]}")
return True
else:
print(f"\n❌ 用户 {username} 不存在")
return False
except Exception as e:
print(f"❌ 查询特定用户失败: {e}")
return False
def main():
"""主函数"""
print("🔍 数据库用户检查工具")
print("=" * 50)
# 连接数据库
connection = connect_database()
if not connection:
return
try:
# 检查表结构
if not check_table_structure(connection):
return
# 检查所有用户
users = check_all_users(connection)
# 检查特定用户
check_specific_user(connection, 'chenxinyu')
# 检查其他可能的用户名
print(f"\n🔍 检查可能的用户名变体:")
for username in ['chenxinyu', 'ChenXinyu', 'CHENXINYU', 'chen_xinyu']:
check_specific_user(connection, username)
except Exception as e:
print(f"❌ 执行过程中发生错误: {e}")
finally:
connection.close()
print("\n🔒 数据库连接已关闭")
if __name__ == "__main__":
main()
\ No newline at end of file
clear_test_data.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
清除杜秋萍患者的测试回访记录数据
"""
import sqlite3
import json
from datetime import datetime
import os
def view_and_clear_test_data():
"""查看并清除测试数据"""
db_path = "callback_records.db"
if not os.path.exists(db_path):
print(f"❌ 数据库文件不存在: {db_path}")
return
try:
with sqlite3.connect(db_path) as conn:
cursor = conn.cursor()
# 检查表结构
cursor.execute("PRAGMA table_info(callback_records)")
columns = [row[1] for row in cursor.fetchall()]
print(f"📋 数据库表结构: {columns}")
# 查找杜秋萍相关的记录
print("\n🔍 查找杜秋萍患者的回访记录...")
# 尝试不同的查询方式
queries = [
"SELECT * FROM callback_records WHERE case_number LIKE '%杜秋萍%'",
"SELECT * FROM callback_records WHERE case_number LIKE '%TS0%'",
"SELECT * FROM callback_records WHERE case_number LIKE '%TEST%'",
"SELECT * FROM callback_records LIMIT 10"
]
for i, query in enumerate(queries, 1):
try:
cursor.execute(query)
records = cursor.fetchall()
print(f"\n📊 查询 {i}: {query}")
print(f"找到 {len(records)} 条记录")
for record in records:
print(f" - {record}")
except Exception as e:
print(f"查询 {i} 失败: {e}")
# 查找所有记录
print("\n📋 查看所有回访记录...")
try:
cursor.execute("SELECT * FROM callback_records")
all_records = cursor.fetchall()
print(f"总共有 {len(all_records)} 条记录")
if all_records:
print("\n前5条记录:")
for i, record in enumerate(all_records[:5], 1):
print(f" {i}. {record}")
# 询问是否清除所有测试数据
print(f"\n⚠️ 发现 {len(all_records)} 条记录，可能包含测试数据")
response = input("是否清除所有回访记录？(y/N): ")
if response.lower() == 'y':
cursor.execute("DELETE FROM callback_records")
conn.commit()
print("✅ 已清除所有回访记录")
# 验证清除结果
cursor.execute("SELECT COUNT(*) FROM callback_records")
count = cursor.fetchone()[0]
print(f"📊 清除后剩余记录数: {count}")
else:
print("❌ 取消清除操作")
except Exception as e:
print(f"查询所有记录失败: {e}")
except Exception as e:
print(f"❌ 数据库操作失败: {e}")
def clear_specific_patient_data(patient_name="杜秋萍"):
"""清除特定患者的回访记录"""
db_path = "callback_records.db"
if not os.path.exists(db_path):
print(f"❌ 数据库文件不存在: {db_path}")
return
try:
with sqlite3.connect(db_path) as conn:
cursor = conn.cursor()
# 查找包含患者姓名的记录
cursor.execute("SELECT * FROM callback_records WHERE case_number LIKE ?", (f'%{patient_name}%',))
records = cursor.fetchall()
if records:
print(f"🔍 找到 {len(records)} 条 {patient_name} 的记录:")
for record in records:
print(f" - {record}")
response = input(f"\n是否删除 {patient_name} 的所有回访记录？(y/N): ")
if response.lower() == 'y':
cursor.execute("DELETE FROM callback_records WHERE case_number LIKE ?", (f'%{patient_name}%',))
conn.commit()
print(f"✅ 已删除 {patient_name} 的所有回访记录")
else:
print("❌ 取消删除操作")
else:
print(f"📝 未找到 {patient_name} 的回访记录")
except Exception as e:
print(f"❌ 操作失败: {e}")
if __name__ == "__main__":
print("🧹 清除测试回访记录数据")
print("=" * 50)
print("选择操作:")
print("1. 查看并清除所有测试数据")
print("2. 清除杜秋萍患者的记录")
print("3. 清除所有回访记录")
choice = input("\n请选择 (1-3): ")
if choice == "1":
view_and_clear_test_data()
elif choice == "2":
clear_specific_patient_data("杜秋萍")
elif choice == "3":
db_path = "callback_records.db"
if os.path.exists(db_path):
try:
with sqlite3.connect(db_path) as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM callback_records")
conn.commit()
print("✅ 已清除所有回访记录")
except Exception as e:
print(f"❌ 清除失败: {e}")
else:
print("❌ 数据库文件不存在")
else:
print("❌ 无效选择")
\ No newline at end of file
clinic_config.py
...@@ -8,16 +8,16 @@ ...@@ -8,16 +8,16 @@
# 门诊映射配置 (基于实际数据分析结果) # 门诊映射配置 (基于实际数据分析结果)
CLINIC_MAPPING = { CLINIC_MAPPING = {
'学前街门诊': { '学前街门诊': {
'clinic_id': 'clinic_xuexian', 'clinic_id': 'clinic_xuexian',
'clinic_name': '学前街门诊', 'clinic_name': '学前街门诊',
'json_file': '学前街门诊.json', 'json_file': '诊所患者json/学前街门诊.json',
'folder_name': 'clinic_xuexian', 'folder_name': 'clinic_xuexian',
'description': '通善学前街门诊', 'description': '通善学前街门诊',
'expected_patients': 765 'expected_patients': 765
}, },
'大丰门诊': { '大丰门诊': {
'clinic_id': 'clinic_dafeng', 'clinic_id': 'clinic_dafeng',
'clinic_name': '大丰门诊', 'clinic_name': '大丰门诊',
'json_file': '诊所患者json/大丰门诊.json', 'json_file': '诊所患者json/大丰门诊.json',
'folder_name': 'clinic_dafeng', 'folder_name': 'clinic_dafeng',
'description': '通善大丰门诊', 'description': '通善大丰门诊',
...@@ -26,7 +26,7 @@ CLINIC_MAPPING = { ...@@ -26,7 +26,7 @@ CLINIC_MAPPING = {
'东亭门诊': { '东亭门诊': {
'clinic_id': 'clinic_dongting', 'clinic_id': 'clinic_dongting',
'clinic_name': '东亭门诊', 'clinic_name': '东亭门诊',
'json_file': '诊所患者json/东亭门诊.json', 'json_file': '诊所患者json/东亭门诊.json',
'folder_name': 'clinic_dongting', 'folder_name': 'clinic_dongting',
'description': '通善东亭门诊', 'description': '通善东亭门诊',
'expected_patients': 479 'expected_patients': 479
...@@ -40,7 +40,7 @@ CLINIC_MAPPING = { ...@@ -40,7 +40,7 @@ CLINIC_MAPPING = {
'expected_patients': 108 'expected_patients': 108
}, },
'红豆门诊': { '红豆门诊': {
'clinic_id': 'clinic_hongdou', 'clinic_id': 'clinic_hongdou',
'clinic_name': '红豆门诊', 'clinic_name': '红豆门诊',
'json_file': '诊所患者json/红豆门诊.json', 'json_file': '诊所患者json/红豆门诊.json',
'folder_name': 'clinic_hongdou', 'folder_name': 'clinic_hongdou',
...@@ -57,7 +57,7 @@ CLINIC_MAPPING = { ...@@ -57,7 +57,7 @@ CLINIC_MAPPING = {
}, },
'马山门诊': { '马山门诊': {
'clinic_id': 'clinic_mashan', 'clinic_id': 'clinic_mashan',
'clinic_name': '马山门诊', 'clinic_name': '马山门诊',
'json_file': '诊所患者json/马山门诊.json', 'json_file': '诊所患者json/马山门诊.json',
'folder_name': 'clinic_mashan', 'folder_name': 'clinic_mashan',
'description': '通善马山门诊', 'description': '通善马山门诊',
...@@ -74,7 +74,7 @@ CLINIC_MAPPING = { ...@@ -74,7 +74,7 @@ CLINIC_MAPPING = {
'新吴门诊': { '新吴门诊': {
'clinic_id': 'clinic_xinwu', 'clinic_id': 'clinic_xinwu',
'clinic_name': '新吴门诊', 'clinic_name': '新吴门诊',
'json_file': '诊所患者json/新吴门诊.json', 'json_file': '诊所患者json/新吴门诊.json',
'folder_name': 'clinic_xinwu', 'folder_name': 'clinic_xinwu',
'description': '通善新吴门诊', 'description': '通善新吴门诊',
'expected_patients': 297 'expected_patients': 297
...@@ -86,6 +86,7 @@ CLINIC_ID_TO_NAME = {info['clinic_id']: info['clinic_name'] for info in CLINIC_M ...@@ -86,6 +86,7 @@ CLINIC_ID_TO_NAME = {info['clinic_id']: info['clinic_name'] for info in CLINIC_M
CLINIC_ID_TO_JSON = {info['clinic_id']: info['json_file'] for info in CLINIC_MAPPING.values()} CLINIC_ID_TO_JSON = {info['clinic_id']: info['json_file'] for info in CLINIC_MAPPING.values()}
CLINIC_ID_TO_FOLDER = {info['clinic_id']: info['folder_name'] for info in CLINIC_MAPPING.values()} CLINIC_ID_TO_FOLDER = {info['clinic_id']: info['folder_name'] for info in CLINIC_MAPPING.values()}
# 默认用户配置 (基于实际门诊用户) # 默认用户配置 (基于实际门诊用户)
DEFAULT_USERS = [ DEFAULT_USERS = [
# 学前街门诊 (3名用户) # 学前街门诊 (3名用户)
...@@ -102,7 +103,7 @@ DEFAULT_USERS = [ ...@@ -102,7 +103,7 @@ DEFAULT_USERS = [
'password': 'renshanshan123', 'password': 'renshanshan123',
'role': 'clinic_user', 'role': 'clinic_user',
'clinic_id': 'clinic_xuexian', 'clinic_id': 'clinic_xuexian',
'real_name': '任珊珊', 'real_name': '任姗姗',
'clinic_name': '学前街门诊' 'clinic_name': '学前街门诊'
}, },
{ {
...@@ -110,10 +111,10 @@ DEFAULT_USERS = [ ...@@ -110,10 +111,10 @@ DEFAULT_USERS = [
'password': 'shaojun123', 'password': 'shaojun123',
'role': 'clinic_user', 'role': 'clinic_user',
'clinic_id': 'clinic_xuexian', 'clinic_id': 'clinic_xuexian',
'real_name': '邵君', 'real_name': '邵军',
'clinic_name': '学前街门诊' 'clinic_name': '学前街门诊'
}, },
# 新吴门诊 (1名用户) # 新吴门诊 (1名用户)
{ {
'username': 'litingting', 'username': 'litingting',
...@@ -123,7 +124,7 @@ DEFAULT_USERS = [ ...@@ -123,7 +124,7 @@ DEFAULT_USERS = [
'real_name': '李婷婷', 'real_name': '李婷婷',
'clinic_name': '新吴门诊' 'clinic_name': '新吴门诊'
}, },
# 红豆门诊 (2名用户) # 红豆门诊 (2名用户)
{ {
'username': 'maqiuyi', 'username': 'maqiuyi',
...@@ -138,10 +139,10 @@ DEFAULT_USERS = [ ...@@ -138,10 +139,10 @@ DEFAULT_USERS = [
'password': 'tangqimin123', 'password': 'tangqimin123',
'role': 'clinic_user', 'role': 'clinic_user',
'clinic_id': 'clinic_hongdou', 'clinic_id': 'clinic_hongdou',
'real_name': '唐其敏', 'real_name': '汤其敏',
'clinic_name': '红豆门诊' 'clinic_name': '红豆门诊'
}, },
# 东亭门诊 (1名用户) # 东亭门诊 (1名用户)
{ {
'username': 'yueling', 'username': 'yueling',
...@@ -151,14 +152,14 @@ DEFAULT_USERS = [ ...@@ -151,14 +152,14 @@ DEFAULT_USERS = [
'real_name': '岳玲', 'real_name': '岳玲',
'clinic_name': '东亭门诊' 'clinic_name': '东亭门诊'
}, },
# 马山门诊 (2名用户) # 马山门诊 (2名用户)
{ {
'username': 'jijunlin', 'username': 'jijunlin',
'password': 'jijunlin123', 'password': 'jijunlin123',
'role': 'clinic_user', 'role': 'clinic_user',
'clinic_id': 'clinic_mashan', 'clinic_id': 'clinic_mashan',
'real_name': '季君林', 'real_name': '季军林',
'clinic_name': '马山门诊' 'clinic_name': '马山门诊'
}, },
{ {
...@@ -169,14 +170,14 @@ DEFAULT_USERS = [ ...@@ -169,14 +170,14 @@ DEFAULT_USERS = [
'real_name': '周丽萍', 'real_name': '周丽萍',
'clinic_name': '马山门诊' 'clinic_name': '马山门诊'
}, },
# 通善口腔医院总院 (2名用户) # 通善口腔医院总院 (2名用户)
{ {
'username': 'feimiaomiao', 'username': 'feimiaomiao',
'password': 'feimiaomiao123', 'password': 'feimiaomiao123',
'role': 'clinic_user', 'role': 'clinic_user',
'clinic_id': 'clinic_hospital', 'clinic_id': 'clinic_hospital',
'real_name': '费苗妙', 'real_name': '费苗苗',
'clinic_name': '通善口腔医院' 'clinic_name': '通善口腔医院'
}, },
{ {
...@@ -187,7 +188,7 @@ DEFAULT_USERS = [ ...@@ -187,7 +188,7 @@ DEFAULT_USERS = [
'real_name': '陈心语', 'real_name': '陈心语',
'clinic_name': '河埒门诊' 'clinic_name': '河埒门诊'
}, },
# 惠山门诊 (2名用户) # 惠山门诊 (2名用户)
{ {
'username': 'yanghong', 'username': 'yanghong',
...@@ -205,7 +206,7 @@ DEFAULT_USERS = [ ...@@ -205,7 +206,7 @@ DEFAULT_USERS = [
'real_name': '潘金丽', 'real_name': '潘金丽',
'clinic_name': '惠山门诊' 'clinic_name': '惠山门诊'
}, },
# 大丰门诊 (1名用户) # 大丰门诊 (1名用户)
{ {
'username': 'chenlin', 'username': 'chenlin',
...@@ -215,7 +216,7 @@ DEFAULT_USERS = [ ...@@ -215,7 +216,7 @@ DEFAULT_USERS = [
'real_name': '陈琳', 'real_name': '陈琳',
'clinic_name': '大丰门诊' 'clinic_name': '大丰门诊'
}, },
# 总部管理员 (最高权限) # 总部管理员 (最高权限)
{ {
'username': 'admin', 'username': 'admin',
...@@ -231,6 +232,7 @@ DEFAULT_USERS = [ ...@@ -231,6 +232,7 @@ DEFAULT_USERS = [
SYSTEM_CONFIG = { SYSTEM_CONFIG = {
'total_clinics': len(CLINIC_MAPPING), 'total_clinics': len(CLINIC_MAPPING),
'total_expected_patients': sum(info['expected_patients'] for info in CLINIC_MAPPING.values()), 'total_expected_patients': sum(info['expected_patients'] for info in CLINIC_MAPPING.values()),
'base_url': '/patient_profiles', 'base_url': '/patient_profiles',
'shared_resources_path': '/shared', 'shared_resources_path': '/shared',
'admin_path': '/admin' 'admin_path': '/admin'
......
complete_fix.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
完整修复方案
确保处理所有诊所的所有患者
"""
import os
import pickle
import shutil
from datetime import datetime
def complete_fix():
"""完整修复方案"""
print("🎯 完整修复方案")
print("="*60)
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
# 1. 备份当前文件
backup_file = f"progress_saves/complete_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pkl"
shutil.copy2(session_file, backup_file)
print(f"✅ 已创建备份: {os.path.basename(backup_file)}")
# 2. 读取当前状态
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print("\n📊 当前状态分析:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
print(f" - 当前诊所已处理: {len(current_callbacks)} 个患者")
# 3. 分析问题
print("\n🔍 问题分析:")
print(" 1. 红豆门诊: 500个患者完全丢失")
print(" 2. 通善口腔医院: 前89个缺失，已处理114个，后422个未处理")
print(" 3. 马山门诊: 527个患者未处理")
# 4. 提供修复方案
print("\n🔧 修复方案选择:")
print("1. 保守方案: 保存当前数据，按顺序重新处理")
print("2. 激进方案: 完全重新开始，确保数据完整性")
print("3. 智能方案: 保存已处理数据，补充缺失部分")
while True:
try:
choice = input("请选择方案 (1-3): ").strip()
if choice == "1":
conservative_fix(state_data)
break
elif choice == "2":
aggressive_fix(state_data)
break
elif choice == "3":
smart_complete_fix(state_data)
break
else:
print("请输入1-3")
except KeyboardInterrupt:
print("\n取消操作")
return
# 5. 保存修复后的状态
with open(session_file, 'wb') as f:
pickle.dump(state_data, f)
print("\n✅ 完整修复完成！")
except Exception as e:
print(f"❌ 修复失败: {e}")
import traceback
traceback.print_exc()
def conservative_fix(state_data):
"""保守方案"""
print("\n🛡️ 保守方案...")
# 保存当前通善口腔医院数据
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
if 'all_results' not in state_data:
state_data['all_results'] = {}
state_data['all_results']['通善口腔医院_部分'] = current_callbacks
print(f" ✅ 保存了通善口腔医院 {len(current_callbacks)} 个患者的处理结果")
# 设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
# 确保红豆门诊不在已完成列表中
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
# 确保通善口腔医院不在已完成列表中
if '通善口腔医院' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('通善口腔医院')
print(" ✅ 设置当前诊所为红豆门诊")
print(" 📋 处理顺序: 红豆门诊 → 通善口腔医院 → 马山门诊")
print(" 💡 通善口腔医院已处理的数据已保存，稍后可合并")
def aggressive_fix(state_data):
"""激进方案"""
print("\n⚡ 激进方案...")
# 清空所有数据，重新开始
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
state_data['completed_clinics'] = ['东亭门诊', '大丰门诊', '惠山门诊', '新吴门诊', '河埒门诊']
# 保留已完成诊所的数据
print(" ✅ 保留已完成诊所的数据")
print(" ✅ 重新开始处理剩余诊所")
print(" 📋 处理顺序: 红豆门诊 → 通善口腔医院 → 马山门诊")
def smart_complete_fix(state_data):
"""智能完整修复方案"""
print("\n🧠 智能完整修复方案...")
# 保存当前通善口腔医院数据
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
if 'all_results' not in state_data:
state_data['all_results'] = {}
state_data['all_results']['通善口腔医院_已处理'] = current_callbacks
print(f" ✅ 保存了通善口腔医院 {len(current_callbacks)} 个患者的处理结果")
# 设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
# 确保红豆门诊不在已完成列表中
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
# 确保通善口腔医院不在已完成列表中
if '通善口腔医院' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('通善口腔医院')
print(" ✅ 设置当前诊所为红豆门诊")
print(" 📋 处理顺序:")
print(" 1. 红豆门诊 (500个患者)")
print(" 2. 通善口腔医院 (前89个 + 后422个 = 511个患者)")
print(" 3. 马山门诊 (527个患者)")
print(" 💡 通善口腔医院已处理的数据已保存，稍后可合并")
def show_detailed_status():
"""显示详细状态"""
print("\n📊 详细状态分析:")
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
# 诊所患者数量
clinic_patients = {
'东亭门诊': 479,
'大丰门诊': 598,
'惠山门诊': 323,
'新吴门诊': 297,
'河埒门诊': 108,
'红豆门诊': 500,
'通善口腔医院': 536,
'马山门诊': 527
}
print("📋 各诊所状态:")
completed_clinics = state_data.get('completed_clinics', [])
current_clinic = state_data.get('current_clinic', '未知')
for clinic, patient_count in clinic_patients.items():
if clinic in completed_clinics:
print(f" ✅ {clinic}: {patient_count} 个患者 (已完成)")
elif clinic == current_clinic:
current_callbacks = state_data.get('current_clinic_callbacks', [])
print(f" 🔄 {clinic}: {patient_count} 个患者 (处理中: {len(current_callbacks)} 个)")
else:
print(f" ⏳ {clinic}: {patient_count} 个患者 (待处理)")
# 计算总体进度
total_patients = sum(clinic_patients.values())
completed_patients = sum(clinic_patients[clinic] for clinic in completed_clinics)
current_processed = len(state_data.get('current_clinic_callbacks', []))
print(f"\n📊 总体进度:")
print(f" - 总患者数: {total_patients} 个")
print(f" - 已完成: {completed_patients} 个")
print(f" - 当前处理: {current_processed} 个")
print(f" - 剩余: {total_patients - completed_patients - current_processed} 个")
if total_patients > 0:
progress_percent = ((completed_patients + current_processed) / total_patients) * 100
print(f" - 进度: {progress_percent:.1f}%")
except Exception as e:
print(f"❌ 读取状态失败: {e}")
if __name__ == "__main__":
print("="*60)
print("完整修复方案")
print("="*60)
# 显示详细状态
show_detailed_status()
# 询问是否修复
print("\n🔧 是否要执行完整修复？")
confirm = input("确认修复？(Y/n): ").strip().lower()
if confirm in ['', 'y', 'yes']:
complete_fix()
else:
print("取消修复")
\ No newline at end of file
create_test_callback_for_existing.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from callback_record_model import CallbackRecordManager, CallbackRecord
def create_test_callback_for_existing():
"""为现有患者TS0K030750创建测试回访记录"""
manager = CallbackRecordManager()
# 测试回访记录数据
test_records = [
{
'case_number': 'TS0K030750',
'callback_methods': ['打电话', '发微信'],
'callback_success': True,
'next_appointment_time': '2025-08-15 10:00',
'failure_reason': None,
'ai_feedback_type': None,
'callback_status': '已回访',
'operator': '张护士'
},
{
'case_number': 'TS0K030750',
'callback_methods': ['打电话'],
'callback_success': False,
'next_appointment_time': None,
'failure_reason': '患者电话无人接听/关机/停机',
'ai_feedback_type': 'AI话术内容不合适（过于专业或过于简单）',
'callback_status': '已回访',
'operator': '李医生'
},
{
'case_number': 'TS0K030750',
'callback_methods': ['发短信', '视频通话'],
'callback_success': True,
'next_appointment_time': '2025-08-20 14:30',
'failure_reason': None,
'ai_feedback_type': None,
'callback_status': '已回访',
'operator': '王助理'
}
]
print('📝 为TS0K030750创建测试回访记录...')
for i, data in enumerate(test_records, 1):
record = CallbackRecord(
case_number=data['case_number'],
callback_methods=data['callback_methods'],
callback_success=data['callback_success'],
operator=data['operator'],
next_appointment_time=data['next_appointment_time'],
failure_reason=data['failure_reason'],
ai_feedback_type=data['ai_feedback_type'],
callback_status=data['callback_status']
)
result = manager.save_record(record)
print(f'✅ 测试记录 {i}: 保存成功，ID: {result.record_id}')
print('🎉 测试数据创建完成!')
if __name__ == "__main__":
create_test_callback_for_existing()
\ No newline at end of file
debug_callback.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
调试回访话术数据加载和匹配
"""
from generate_html import load_oral_callback_data
def test_callback_data():
"""测试回访话术数据加载"""
print("测试大丰门诊回访话术数据加载...")
# 加载大丰门诊的回访话术数据
oral_callback_data = load_oral_callback_data('大丰门诊')
print(f"加载的数据数量: {len(oral_callback_data)}")
# 测试特定患者ID
patient_id = 'TS0G040927'
patient_data = oral_callback_data.get(patient_id)
if patient_data:
print(f"找到患者 {patient_id} 的回访话术数据:")
print(f" 患者姓名: {patient_data.get('patient_name')}")
print(f" 年龄性别: {patient_data.get('age')}岁 {patient_data.get('gender')}")
print(f" 生成时间: {patient_data.get('generation_time')}")
print(f" 回访类型: {patient_data.get('callback_type')}")
print(f" 回访话术长度: {len(patient_data.get('callback_script', ''))}")
# 检查是否有回访话术内容
callback_script = patient_data.get('callback_script', '')
if callback_script:
print("✓ 回访话术内容存在")
else:
print("✗ 回访话术内容为空")
else:
print(f"未找到患者 {patient_id} 的回访话术数据")
print(f"可用的患者ID前5个: {list(oral_callback_data.keys())[:5]}")
if __name__ == "__main__":
test_callback_data()
\ No newline at end of file
debug_generate.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from generate_html import generate_html
import os
def debug_generate():
print('当前工作目录:', os.getcwd())
print('patient_profiles目录是否存在:', os.path.exists('patient_profiles'))
try:
# 尝试生成页面
print('开始生成TS0K030750页面...')
generate_html('TS0K030750', {})
print('生成函数执行完毕')
# 检查文件是否存在
file_path = 'patient_profiles/TS0K030750.html'
if os.path.exists(file_path):
print(f'✅ 文件已生成: {file_path}')
print(f'文件大小: {os.path.getsize(file_path)} 字节')
else:
print(f'❌ 文件未生成: {file_path}')
except Exception as e:
print(f'❌ 生成过程出错: {e}')
import traceback
traceback.print_exc()
if __name__ == "__main__":
debug_generate()
\ No newline at end of file
debug_generate_detailed.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import os
def debug_generate_detailed():
print('=== 调试generate_html函数 ===')
# 1. 检查患者数据
print('1. 加载患者数据...')
with open('合并结果.json', encoding='utf-8') as f:
data = json.load(f)
# 查找TS0K030750
patient_records = []
for record in data:
if record.get('病历号') == 'TS0K030750':
patient_records.append(record)
print(f'找到 {len(patient_records)} 条TS0K030750的记录')
if patient_records:
latest = patient_records[0]
print(f'患者姓名: {latest.get("姓名", "未知")}')
print(f'病历号: {latest.get("病历号", "未知")}')
else:
print('❌ 未找到TS0K030750的记录!')
return
# 2. 检查回访记录数据
print('\n2. 检查回访记录...')
from callback_record_model import CallbackRecordManager
manager = CallbackRecordManager()
callback_records = manager.get_records_by_case_number('TS0K030750')
print(f'找到 {len(callback_records)} 条回访记录')
# 3. 调用generate_html函数
print('\n3. 调用generate_html函数...')
from generate_html import generate_html
try:
generate_html('TS0K030750', patient_records)
print('✅ generate_html函数执行完毕')
# 检查文件是否生成
if os.path.exists('TS0K030750.html'):
print('✅ 文件已生成: TS0K030750.html')
file_size = os.path.getsize('TS0K030750.html')
print(f'文件大小: {file_size} 字节')
# 移动到正确位置
import shutil
if not os.path.exists('patient_profiles'):
os.makedirs('patient_profiles')
shutil.move('TS0K030750.html', 'patient_profiles/TS0K030750.html')
print('✅ 文件已移动到patient_profiles目录')
else:
print('❌ 文件未生成')
except Exception as e:
print(f'❌ 生成过程出错: {e}')
import traceback
traceback.print_exc()
if __name__ == "__main__":
debug_generate_detailed()
\ No newline at end of file
debug_progress.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
调试进度文件
详细分析当前会话的状态信息
"""
import os
import pickle
import json
from datetime import datetime
def debug_progress():
"""详细调试进度文件"""
print("🔍 详细调试进度文件...")
progress_dir = "progress_saves"
session_file = os.path.join(progress_dir, "session_20250805_232912.pkl")
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print("="*60)
print("🔍 会话详细信息:")
print("="*60)
print(f"📅 会话ID: {state_data.get('session_id', '未知')}")
print(f"📅 开始时间: {state_data.get('start_time', '未知')}")
print(f"💾 最后保存: {state_data.get('save_timestamp', '未知')}")
print(f"🏥 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f"👤 当前患者索引: {state_data.get('current_patient_index', 0)}")
print("\n📋 配置信息:")
config = state_data.get('generation_config', {})
print(f" - API类型: {config.get('api_type', '未知')}")
print(f" - 处理模式: {config.get('mode', '未知')}")
selected_clinics = config.get('selected_clinics', [])
print(f" - 选择的诊所 ({len(selected_clinics)}): {selected_clinics}")
completed_clinics = state_data.get('completed_clinics', [])
print(f"\n✅ 已完成诊所 ({len(completed_clinics)}): {completed_clinics}")
remaining_clinics = [c for c in selected_clinics if c not in completed_clinics]
print(f"⏳ 剩余诊所 ({len(remaining_clinics)}): {remaining_clinics}")
print("\n📊 当前诊所处理状态:")
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
success_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'success'])
error_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'error'])
print(f" - 当前诊所已处理: {len(current_callbacks)} 个患者")
print(f" - ✅ 成功: {success_count} 个")
print(f" - ❌ 失败: {error_count} 个")
# 显示最后几个处理的患者
if len(current_callbacks) > 0:
print(f"\n📋 最后5个处理的患者:")
last_5 = current_callbacks[-5:] if len(current_callbacks) >= 5 else current_callbacks
for i, cb in enumerate(last_5):
status = "✅" if cb.get('callback_type') == 'success' else "❌"
print(f" {len(current_callbacks) - len(last_5) + i + 1}. {cb.get('patient_name', '未知')} ({cb.get('patient_id', '未知')}) {status}")
else:
print(" - 当前诊所无处理记录")
print("\n📈 所有已完成诊所统计:")
all_results = state_data.get('all_results', {})
total_processed = 0
total_success = 0
total_failed = 0
for clinic_name, callbacks in all_results.items():
success = len([cb for cb in callbacks if cb.get('callback_type') == 'success'])
failed = len([cb for cb in callbacks if cb.get('callback_type') == 'error'])
total_processed += len(callbacks)
total_success += success
total_failed += failed
print(f" 🏥 {clinic_name}: {success}✅ / {failed}❌ (共{len(callbacks)}个)")
print(f"\n📊 总计统计:")
print(f" - 总处理患者: {total_processed} 个")
print(f" - 总成功: {total_success} 个")
print(f" - 总失败: {total_failed} 个")
if total_processed > 0:
success_rate = (total_success / total_processed) * 100
print(f" - 成功率: {success_rate:.1f}%")
# 检查红豆门诊的状态
print("\n🔍 红豆门诊状态分析:")
if "红豆门诊" in completed_clinics:
print(" ✅ 红豆门诊在已完成列表中")
else:
print(" ❌ 红豆门诊不在已完成列表中")
if "红豆门诊" in all_results:
red_callbacks = all_results["红豆门诊"]
red_success = len([cb for cb in red_callbacks if cb.get('callback_type') == 'success'])
red_failed = len([cb for cb in red_callbacks if cb.get('callback_type') == 'error'])
print(f" 📊 红豆门诊结果: {red_success}✅ / {red_failed}❌ (共{len(red_callbacks)}个)")
else:
print(" ❌ 红豆门诊不在结果列表中")
if state_data.get('current_clinic') == "红豆门诊":
print(" 🔄 当前正在处理红豆门诊")
else:
print(f" ℹ️ 当前处理诊所: {state_data.get('current_clinic', '未知')}")
# 检查是否有红豆门诊的中间结果文件
output_dir = "dify_callback_results"
red_files = []
if os.path.exists(output_dir):
for file_name in os.listdir(output_dir):
if "红豆门诊" in file_name:
red_files.append(file_name)
if red_files:
print(f" 📁 找到红豆门诊文件: {red_files}")
else:
print(" 📁 未找到红豆门诊中间结果文件")
except Exception as e:
print(f"❌ 读取进度文件失败: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
debug_progress()
\ No newline at end of file
deploy_scripts/deploy_with_backup.sh 0 → 100644
#!/bin/bash
# 生产环境部署脚本（包含数据库备份）
# 使用方法：./deploy_with_backup.sh
set -e # 遇到错误立即退出
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 配置信息
PROJECT_DIR="customer-recall"
BACKUP_DIR="/backup/database"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="production_backup_${TIMESTAMP}.sql"
# 数据库配置（从环境变量获取）
DB_HOST="${DB_HOST:-localhost}"
DB_PORT="${DB_PORT:-3306}"
DB_USER="${DB_USER:-callback_user}"
DB_NAME="${DB_NAME:-callback_system}"
log_info "🚀 开始生产环境部署流程..."
log_info "📅 部署时间: $(date)"
log_info "🏥 项目目录: $PROJECT_DIR"
log_info "🗄️ 数据库: $DB_NAME@$DB_HOST:$DB_PORT"
# 第一步：创建备份目录
log_info "📁 创建备份目录..."
mkdir -p "$BACKUP_DIR"
log_success "备份目录创建成功: $BACKUP_DIR"
# 第二步：数据库备份
log_info "💾 开始数据库备份..."
if command -v mysqldump &> /dev/null; then
# 使用mysqldump备份
log_info "使用mysqldump备份数据库..."
# 检查数据库连接
if mysql -h"$DB_HOST" -P"$DB_PORT" -u"$DB_USER" -p"$DB_PASSWORD" -e "SELECT 1;" "$DB_NAME" &> /dev/null; then
log_success "数据库连接成功，开始备份..."
# 执行备份
mysqldump -h"$DB_HOST" -P"$DB_PORT" -u"$DB_USER" -p"$DB_PASSWORD" \
--single-transaction \
--routines \
--triggers \
--events \
--add-drop-database \
--create-options \
"$DB_NAME" > "$BACKUP_DIR/$BACKUP_FILE"
if [ $? -eq 0 ]; then
BACKUP_SIZE=$(du -h "$BACKUP_DIR/$BACKUP_FILE" | cut -f1)
log_success "数据库备份成功！"
log_info "📊 备份文件: $BACKUP_FILE"
log_info "📏 备份大小: $BACKUP_SIZE"
log_info "📍 备份路径: $BACKUP_DIR/$BACKUP_FILE"
else
log_error "数据库备份失败！"
exit 1
fi
else
log_error "无法连接到数据库，请检查配置！"
exit 1
fi
else
log_warning "mysqldump命令不存在，尝试使用Docker容器备份..."
# 使用Docker容器备份
if docker ps | grep -q mysql; then
log_info "使用Docker容器备份数据库..."
docker exec $(docker ps -q --filter "ancestor=mysql") \
mysqldump -u"$DB_USER" -p"$DB_PASSWORD" \
--single-transaction \
--routines \
--triggers \
--events \
--add-drop-database \
--create-options \
"$DB_NAME" > "$BACKUP_DIR/$BACKUP_FILE"
if [ $? -eq 0 ]; then
BACKUP_SIZE=$(du -h "$BACKUP_DIR/$BACKUP_FILE" | cut -f1)
log_success "Docker容器备份成功！"
log_info "📊 备份文件: $BACKUP_FILE"
log_info "📏 备份大小: $BACKUP_SIZE"
else
log_error "Docker容器备份失败！"
exit 1
fi
else
log_error "未找到MySQL容器，无法备份数据库！"
exit 1
fi
fi
# 第三步：验证备份文件
log_info "🔍 验证备份文件..."
if [ -f "$BACKUP_DIR/$BACKUP_FILE" ] && [ -s "$BACKUP_DIR/$BACKUP_FILE" ]; then
log_success "备份文件验证成功！"
else
log_error "备份文件验证失败！"
exit 1
fi
# 第四步：更新代码
log_info "📥 更新项目代码..."
cd "$PROJECT_DIR"
git pull origin master
log_success "代码更新成功！"
# 第五步：部署Docker容器
log_info "🐳 部署Docker容器..."
docker compose down
docker compose up -d --build
# 等待容器启动
log_info "⏳ 等待容器启动..."
sleep 10
# 检查容器状态
if docker compose ps | grep -q "Up"; then
log_success "Docker容器启动成功！"
else
log_error "Docker容器启动失败！"
exit 1
fi
# 第六步：执行安全数据导入
log_info "📋 执行安全数据导入..."
if docker exec $(docker compose ps -q app) python safe_import_patients.py; then
log_success "安全数据导入成功！"
else
log_warning "安全数据导入失败，但部署继续..."
fi
# 第七步：清理旧备份（保留最近7天）
log_info "🧹 清理旧备份文件..."
find "$BACKUP_DIR" -name "production_backup_*.sql" -mtime +7 -delete
log_success "旧备份文件清理完成！"
# 部署完成
log_success "🎉 生产环境部署完成！"
log_info "📊 部署总结:"
log_info " ✅ 数据库备份: $BACKUP_FILE"
log_info " ✅ 代码更新: 完成"
log_info " ✅ 容器部署: 完成"
log_info " ✅ 数据导入: 完成"
log_info " 📍 备份位置: $BACKUP_DIR"
log_info " 🕐 完成时间: $(date)"
# 显示备份文件列表
log_info "📋 当前备份文件列表:"
ls -lh "$BACKUP_DIR"/production_backup_*.sql 2>/dev/null || log_warning "暂无备份文件"
\ No newline at end of file
export_data.py
...@@ -49,7 +49,7 @@ class DataExporter: ...@@ -49,7 +49,7 @@ class DataExporter:
connection = pymysql.connect(**self.db_config) connection = pymysql.connect(**self.db_config)
cursor = connection.cursor() cursor = connection.cursor()
# 获取所有回访记录 # 获取所有回访记录，同时关联患者表获取诊所信息
cursor.execute(""" cursor.execute("""
SELECT SELECT
cr.case_number, cr.case_number,
...@@ -58,126 +58,88 @@ class DataExporter: ...@@ -58,126 +58,88 @@ class DataExporter:
cr.callback_record, cr.callback_record,
cr.operator, cr.operator,
cr.create_time, cr.create_time,
cr.update_time cr.update_time,
p.clinic_name
FROM callback_records cr FROM callback_records cr
ORDER BY cr.create_time DESC LEFT JOIN patients p ON cr.case_number = p.case_number
ORDER BY cr.case_number, cr.create_time
""") """)
records = cursor.fetchall() records = cursor.fetchall()
# 获取诊所配置
clinic_config = self._get_clinic_config()
# 按诊所分组数据 # 按诊所分组数据
clinic_data = {} clinic_data = {}
print(f"处理 {len(records)} 条记录...") print(f"处理 {len(records)} 条记录...")
print(f"诊所配置: {clinic_config}")
for record in records: for record in records:
case_number = record[0] case_number = record[0]
clinic_id = self._get_clinic_id_from_case(case_number, clinic_config) clinic_name = record[7] or '未知门诊' # 从patients表获取诊所名称
print(f"病例号 {case_number} -> 诊所ID {clinic_id}")
if clinic_id not in clinic_data: if clinic_name not in clinic_data:
# 获取诊所名称 clinic_data[clinic_name] = {
clinic_name = "未知诊所" 'records': [],
if clinic_id in clinic_config: 'unique_patients': set(), # 使用set来统计唯一患者
clinic_name = clinic_config[clinic_id].get('clinic_name', '未知诊所') 'patient_final_status': {}, # 记录每个患者的最终回访状态
else: 'total_count': 0,
# 如果配置中没有，使用硬编码的映射 'success_count': 0,
clinic_name_map = { 'failed_count': 0,
'clinic_xuexian': '学前街门诊', 'pending_count': 0
'clinic_dafeng': '大丰门诊',
'clinic_dongting': '东亭门诊',
'clinic_helai': '河埒门诊',
'clinic_hongdou': '红豆门诊',
'clinic_huishan': '惠山门诊',
'clinic_mashan': '马山门诊',
'clinic_hospital': '通善口腔医院',
'clinic_xinwu': '新吴门诊'
}
clinic_name = clinic_name_map.get(clinic_id, '未知诊所')
clinic_data[clinic_id] = {
'clinic_name': clinic_name,
'records': []
} }
clinic_data[clinic_id]['records'].append({ # 添加记录
clinic_data[clinic_name]['records'].append({
'case_number': case_number, 'case_number': case_number,
'callback_methods': json.loads(record[1]) if record[1] else [], 'callback_methods': record[1],
'callback_result': record[2], 'callback_result': record[2],
'callback_record': record[3], 'callback_record': record[3],
'operator': record[4], 'operator': record[4],
'create_time': record[5], 'create_time': record[5],
'update_time': record[6] 'update_time': record[6]
}) })
# 统计唯一患者数
clinic_data[clinic_name]['unique_patients'].add(case_number)
# 统计记录总数
clinic_data[clinic_name]['total_count'] += 1
# 记录每个患者的回访状态（按时间顺序，后面的会覆盖前面的）
clinic_data[clinic_name]['patient_final_status'][case_number] = record[2]
print(f"分组后的诊所数据: {len(clinic_data)} 个诊所") # 统计每个诊所的患者最终回访状态
for clinic_id, data in clinic_data.items(): for clinic_name in clinic_data:
print(f" {clinic_id}: {data['clinic_name']} - {len(data['records'])} 条记录") clinic_data[clinic_name]['unique_patient_count'] = len(clinic_data[clinic_name]['unique_patients'])
# 重置计数
clinic_data[clinic_name]['success_count'] = 0
clinic_data[clinic_name]['failed_count'] = 0
clinic_data[clinic_name]['pending_count'] = 0
# 统计每个患者的最终回访状态
for final_status in clinic_data[clinic_name]['patient_final_status'].values():
if final_status == '成功':
clinic_data[clinic_name]['success_count'] += 1
elif final_status == '不成功':
clinic_data[clinic_name]['failed_count'] += 1
else:
clinic_data[clinic_name]['pending_count'] += 1
cursor.close()
connection.close() connection.close()
return clinic_data return clinic_data
except Exception as e: except Exception as e:
print(f"获取数据失败: {e}") print(f"获取诊所数据失败: {e}")
return {} return {}
def _get_clinic_config(self) -> Dict[str, Any]:
"""获取诊所配置"""
try:
# 导入诊所配置
import clinic_config
users = clinic_config.DEFAULT_USERS
# 创建诊所映射
clinic_mapping = {}
for user in users:
if user.get('clinic_id') and user.get('clinic_id') != 'admin':
clinic_mapping[user['clinic_id']] = {
'clinic_name': user.get('clinic_name', '未知诊所'),
'username': user.get('username', '')
}
return clinic_mapping
except ImportError:
# 如果无法导入，使用硬编码的诊所映射
return {
'clinic_xuexian': {'clinic_name': '学前街门诊', 'username': 'jinqin'},
'clinic_dafeng': {'clinic_name': '大丰门诊', 'username': 'chenlin'},
'clinic_dongting': {'clinic_name': '东亭门诊', 'username': 'dongting'},
'clinic_helai': {'clinic_name': '河埒门诊', 'username': 'helai'},
'clinic_hongdou': {'clinic_name': '红豆门诊', 'username': 'hongdou'},
'clinic_huishan': {'clinic_name': '惠山门诊', 'username': 'huishan'},
'clinic_mashan': {'clinic_name': '马山门诊', 'username': 'mashan'},
'clinic_hospital': {'clinic_name': '通善口腔医院', 'username': 'hospital'},
'clinic_xinwu': {'clinic_name': '新吴门诊', 'username': 'xinwu'}
}
def _get_clinic_id_from_case(self, case_number: str, clinic_config: Dict) -> str: def _get_clinic_id_from_case(self, case_number: str, clinic_config: Dict) -> str:
"""根据病例号判断诊所ID""" """根据病历号获取诊所ID - 已废弃，现在直接从patients表获取"""
# 根据病例号前缀判断诊所 # 这个方法已经不再使用，保留只是为了兼容性
if case_number.startswith('TS0G'): return 'unknown'
return 'clinic_dafeng'
elif case_number.startswith('TS0C'): def _get_clinic_config(self) -> Dict:
return 'clinic_dongting' """获取诊所配置 - 已废弃，现在直接从patients表获取"""
elif case_number.startswith('JY0A'): # 这个方法已经不再使用，保留只是为了兼容性
return 'clinic_helai' return {}
elif case_number.startswith('TS0B'):
return 'clinic_hongdou'
elif case_number.startswith('TS0E'):
return 'clinic_huishan'
elif case_number.startswith('TS0I'):
return 'clinic_mashan'
elif case_number.startswith('TS0F'):
return 'clinic_xinwu'
elif case_number.startswith('TS0M'):
return 'clinic_xuexian'
else:
return 'clinic_hospital'
def export_to_excel(self, output_path: str = None) -> str: def export_to_excel(self, output_path: str = None) -> str:
"""导出数据到Excel文件""" """导出数据到Excel文件"""
...@@ -196,12 +158,12 @@ class DataExporter: ...@@ -196,12 +158,12 @@ class DataExporter:
# 创建各诊所详细表 # 创建各诊所详细表
print(f"开始创建诊所详细表...") print(f"开始创建诊所详细表...")
for clinic_id, data in clinic_data.items(): for clinic_name, data in clinic_data.items():
if data['records']: if data['records']:
print(f"创建诊所表: {clinic_id} - {data['clinic_name']} ({len(data['records'])} 条记录)") print(f"创建诊所表: {clinic_name} - {data['total_count']} 条记录)")
self._create_clinic_sheet(wb, clinic_id, data) self._create_clinic_sheet(wb, clinic_name, data)
else: else:
print(f"跳过空诊所: {clinic_id} - {data['clinic_name']}") print(f"跳过空诊所: {clinic_name} - {data['total_count']} 条记录)")
print(f"Excel工作表列表: {wb.sheetnames}") print(f"Excel工作表列表: {wb.sheetnames}")
...@@ -232,7 +194,7 @@ class DataExporter: ...@@ -232,7 +194,7 @@ class DataExporter:
ws['A1'].alignment = title_alignment ws['A1'].alignment = title_alignment
# 设置列标题 # 设置列标题
headers = ["诊所名称", "总记录数", "成功", "不成功", "放弃回访", "成功率"] headers = ["诊所名称", "已回访患者数", "成功", "不成功", "放弃回访", "成功率"]
for col, header in enumerate(headers, 1): for col, header in enumerate(headers, 1):
cell = ws.cell(row=3, column=col, value=header) cell = ws.cell(row=3, column=col, value=header)
cell.font = Font(bold=True) cell.font = Font(bold=True)
...@@ -241,25 +203,27 @@ class DataExporter: ...@@ -241,25 +203,27 @@ class DataExporter:
# 填充数据 # 填充数据
row = 4 row = 4
total_records = 0 total_unique_patients = 0
total_success = 0 total_success = 0
for clinic_id, data in clinic_data.items(): for clinic_name, data in clinic_data.items():
records = data['records'] records = data['records']
if not records: if not records:
continue continue
success_count = sum(1 for r in records if r['callback_result'] == '成功') success_count = data['success_count']
unsuccessful_count = sum(1 for r in records if r['callback_result'] == '不成功') unsuccessful_count = data['failed_count']
abandon_count = sum(1 for r in records if r['callback_result'] == '放弃回访') abandon_count = data['pending_count']
unique_patient_count = data['unique_patient_count'] # 使用唯一患者数
total_records += len(records) total_unique_patients += unique_patient_count
total_success += success_count total_success += success_count
success_rate = (success_count / len(records)) * 100 if records else 0 # 计算成功率（基于唯一患者数）
success_rate = (success_count / unique_patient_count) * 100 if unique_patient_count > 0 else 0
ws.cell(row=row, column=1, value=data['clinic_name']) ws.cell(row=row, column=1, value=clinic_name)
ws.cell(row=row, column=2, value=len(records)) ws.cell(row=row, column=2, value=unique_patient_count) # 显示已回访患者数
ws.cell(row=row, column=3, value=success_count) ws.cell(row=row, column=3, value=success_count)
ws.cell(row=row, column=4, value=unsuccessful_count) ws.cell(row=row, column=4, value=unsuccessful_count)
ws.cell(row=row, column=5, value=abandon_count) ws.cell(row=row, column=5, value=abandon_count)
...@@ -268,10 +232,10 @@ class DataExporter: ...@@ -268,10 +232,10 @@ class DataExporter:
row += 1 row += 1
# 添加总计行 # 添加总计行
if total_records > 0: if total_unique_patients > 0:
total_success_rate = (total_success / total_records) * 100 total_success_rate = (total_success / total_unique_patients) * 100
ws.cell(row=row, column=1, value="总计") ws.cell(row=row, column=1, value="总计")
ws.cell(row=row, column=2, value=total_records) ws.cell(row=row, column=2, value=total_unique_patients) # 显示总已回访患者数
ws.cell(row=row, column=3, value=total_success) ws.cell(row=row, column=3, value=total_success)
ws.cell(row=row, column=6, value=f"{total_success_rate:.1f}%") ws.cell(row=row, column=6, value=f"{total_success_rate:.1f}%")
...@@ -288,9 +252,8 @@ class DataExporter: ...@@ -288,9 +252,8 @@ class DataExporter:
# 设置边框 # 设置边框
self._add_borders(ws, 3, row, 6) self._add_borders(ws, 3, row, 6)
def _create_clinic_sheet(self, wb: Workbook, clinic_id: str, data: Dict[str, Any]): def _create_clinic_sheet(self, wb: Workbook, clinic_name: str, data: Dict[str, Any]):
"""创建诊所详细表""" """创建诊所详细表"""
clinic_name = data['clinic_name']
sheet_name = clinic_name[:31] if len(clinic_name) > 31 else clinic_name # Excel工作表名限制31字符 sheet_name = clinic_name[:31] if len(clinic_name) > 31 else clinic_name # Excel工作表名限制31字符
ws = wb.create_sheet(sheet_name) ws = wb.create_sheet(sheet_name)
......
fix_all_clinics_patients.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复所有门诊患者画像样式问题
重新生成除了大丰门诊和学前街门诊之外的所有门诊患者画像，确保样式正确
"""
import os
import json
import sys
import traceback
import shutil
# 需要修复的门诊列表（排除大丰门诊和学前街门诊）
CLINICS_TO_FIX = [
'东亭门诊',
'河埒门诊',
'红豆门诊',
'惠山门诊',
'马山门诊',
'通善口腔医院',
'新吴门诊'
]
# 门诊ID映射
CLINIC_ID_MAPPING = {
'东亭门诊': 'clinic_dongting',
'河埒门诊': 'clinic_helai',
'红豆门诊': 'clinic_hongdou',
'惠山门诊': 'clinic_huishan',
'马山门诊': 'clinic_mashan',
'通善口腔医院': 'clinic_hospital',
'新吴门诊': 'clinic_xinwu'
}
def load_clinic_data(clinic_name):
"""加载指定门诊数据"""
try:
print(f"🔍 正在检查 {clinic_name} 数据文件...")
json_file = f'诊所患者json/{clinic_name}.json'
print(f"📁 数据文件路径: {json_file}")
if os.path.exists(json_file):
print(f"✅ 数据文件存在，大小: {os.path.getsize(json_file)} 字节")
with open(json_file, 'r', encoding='utf-8') as f:
print(f"📖 正在读取 {clinic_name} 数据文件...")
data = json.load(f)
print(f"✅ 成功加载 {clinic_name} 数据: {len(data)} 条记录")
return data
else:
print(f"❌ 未找到 {clinic_name} 数据文件: {json_file}")
return []
except Exception as e:
print(f"❌ 加载 {clinic_name} 数据失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return []
def fix_clinic_patients(clinic_name):
"""修复指定门诊的患者画像"""
print(f"\n🔧 开始修复 {clinic_name} 患者画像...")
# 加载数据
print(f"📊 步骤1: 加载 {clinic_name} 数据...")
data = load_clinic_data(clinic_name)
if not data:
print(f"❌ 无法加载 {clinic_name} 数据，跳过修复")
return False
# 合并患者数据
print(f"📊 步骤2: 合并 {clinic_name} 患者数据...")
try:
from generate_html import merge_patient_data
patients_data = merge_patient_data(data)
print(f"📊 合并后患者数量: {len(patients_data)}")
except Exception as e:
print(f"❌ 合并 {clinic_name} 患者数据失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return False
# 创建输出目录
print(f"📁 步骤3: 创建 {clinic_name} 输出目录...")
clinic_id = CLINIC_ID_MAPPING.get(clinic_name)
if not clinic_id:
print(f"❌ 未找到 {clinic_name} 的ID映射")
return False
output_dir = f"patient_profiles/{clinic_id}/patients"
os.makedirs(output_dir, exist_ok=True)
print(f"✅ 输出目录: {output_dir}")
# 重新生成每个患者的HTML
print(f"🔄 步骤4: 生成 {clinic_name} 患者画像...")
success_count = 0
error_count = 0
# 处理所有患者
all_patients = list(patients_data.items())
print(f"📊 开始处理 {clinic_name} 的所有 {len(all_patients)} 个患者...")
for i, (patient_id, records) in enumerate(all_patients, 1):
try:
print(f"🔄 正在生成患者 {patient_id} 的画像... ({i}/{len(all_patients)})")
# 生成HTML
from generate_html import generate_html
generate_html(patient_id, records)
# 检查文件是否生成成功
html_file = f"{patient_id}.html"
if os.path.exists(html_file):
# 目标文件路径
target_file = os.path.join(output_dir, html_file)
# 如果目标文件已存在，先删除
if os.path.exists(target_file):
print(f"🗑️ 删除已存在的文件: {target_file}")
os.remove(target_file)
# 移动文件到目标目录
shutil.move(html_file, target_file)
print(f"✅ 患者 {patient_id} 画像生成成功")
success_count += 1
else:
print(f"❌ 患者 {patient_id} 画像生成失败 - 文件未创建")
error_count += 1
except Exception as e:
print(f"❌ 生成患者 {patient_id} 画像时出错: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
error_count += 1
print(f"\n📈 {clinic_name} 修复完成!")
print(f"✅ 成功: {success_count} 个患者")
print(f"❌ 失败: {error_count} 个患者")
return success_count > 0
def fix_all_clinics():
"""修复所有门诊的患者画像"""
print("🚀 开始修复所有门诊患者画像...")
print("=" * 60)
total_success = 0
total_error = 0
failed_clinics = []
for clinic_name in CLINICS_TO_FIX:
print(f"\n{'='*20} {clinic_name} {'='*20}")
try:
success = fix_clinic_patients(clinic_name)
if success:
total_success += 1
else:
total_error += 1
failed_clinics.append(clinic_name)
except Exception as e:
print(f"❌ 修复 {clinic_name} 时发生异常: {e}")
total_error += 1
failed_clinics.append(clinic_name)
# 输出总结
print(f"\n{'='*60}")
print("📊 修复总结")
print(f"{'='*60}")
print(f"✅ 成功修复的门诊: {total_success}")
print(f"❌ 修复失败的门诊: {total_error}")
if failed_clinics:
print(f"🔍 修复失败的门诊列表:")
for clinic in failed_clinics:
print(f" - {clinic}")
print(f"\n🎯 修复完成！请检查 patient_profiles/ 目录下的各门诊文件夹")
return total_error == 0
def main():
"""主函数"""
print("🚀 所有门诊患者画像修复工具")
print("=" * 60)
print("📋 将修复以下门诊:")
for i, clinic in enumerate(CLINICS_TO_FIX, 1):
clinic_id = CLINIC_ID_MAPPING.get(clinic, '未知')
print(f" {i}. {clinic} -> {clinic_id}")
print(f"\n⏭️ 跳过以下门诊（已修复）:")
print(" - 大丰门诊 (clinic_dafeng)")
print(" - 学前街门诊 (clinic_xuexian)")
# 检查依赖
print("\n🔍 检查依赖...")
try:
import pandas as pd
print("✅ pandas 已安装")
except ImportError:
print("❌ pandas 未安装，请运行: pip install pandas")
return False
try:
import flask
print("✅ flask 已安装")
except ImportError:
print("❌ flask 未安装，请运行: pip install flask")
return False
# 确认操作
print(f"\n⚠️ 此操作将重新生成 {len(CLINICS_TO_FIX)} 个门诊的所有患者画像")
print("📁 输出目录: patient_profiles/")
# 执行修复
print("\n🚀 开始执行修复...")
success = fix_all_clinics()
if success:
print("\n🎉 所有门诊修复完成！")
print("📁 请检查以下目录:")
for clinic in CLINICS_TO_FIX:
clinic_id = CLINIC_ID_MAPPING.get(clinic)
if clinic_id:
print(f" - patient_profiles/{clinic_id}/patients/")
else:
print("\n💥 部分门诊修复失败，请检查错误信息")
return success
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\n\n👋 用户中断操作")
sys.exit(0)
except Exception as e:
print(f"\n💥 程序异常: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
sys.exit(1)
\ No newline at end of file
fix_all_patient_callback_containers.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量修复所有患者页面的回访记录容器
为所有患者HTML文件添加缺失的 callback-records-list 容器
"""
import os
import re
import glob
ROOT = os.path.dirname(os.path.abspath(__file__))
PATIENT_PROFILES_DIR = os.path.join(ROOT, 'patient_profiles')
def fix_patient_html(file_path):
"""修复单个患者HTML文件"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已经有 callback-records-list 容器
if 'id="callback-records-list"' in content:
return False # 已经修复过，跳过
# 查找需要修复的位置：<div class="p-6"> 后面的硬编码内容
pattern = r'(<div class="p-6">\s*)\n\s*<div class="mb-6 text-center py-8">\s*<i class="fas fa-phone-slash text-4xl text-gray-300 mb-3"></i>\s*<h3 class="text-lg font-medium text-gray-600 mb-2">暂无回访记录</h3>\s*<p class="text-gray-500 mb-4">该患者尚未进行过回访，请填写首次回访记录。</p>\s*</div>\s*(\n\s*<!-- 新建回访记录表单)'
replacement = r'''\1
<!-- 回访记录列表容器 -->
<div id="callback-records-list">
<div class="mb-6 text-center py-8">
<i class="fas fa-phone-slash text-4xl text-gray-300 mb-3"></i>
<h3 class="text-lg font-medium text-gray-600 mb-2">暂无回访记录</h3>
<p class="text-gray-500 mb-4">该患者尚未进行过回访，请填写首次回访记录。</p>
</div>
</div>
\2'''
# 执行替换
new_content, count = re.subn(pattern, replacement, content, flags=re.MULTILINE | re.DOTALL)
if count > 0:
# 保存修复后的文件
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
else:
# 如果没有匹配到，尝试更简单的模式
simple_pattern = r'(<div class="p-6">\s*)(.*?)(\s*<!-- 新建回访记录表单)'
def replace_func(match):
prefix = match.group(1)
middle = match.group(2)
suffix = match.group(3)
# 如果中间部分包含"暂无回访记录"但没有callback-records-list容器
if '暂无回访记录' in middle and 'callback-records-list' not in middle:
new_middle = '''
<!-- 回访记录列表容器 -->
<div id="callback-records-list">
<div class="mb-6 text-center py-8">
<i class="fas fa-phone-slash text-4xl text-gray-300 mb-3"></i>
<h3 class="text-lg font-medium text-gray-600 mb-2">暂无回访记录</h3>
<p class="text-gray-500 mb-4">该患者尚未进行过回访，请填写首次回访记录。</p>
</div>
</div>
'''
return prefix + new_middle + suffix
return match.group(0)
new_content, count = re.subn(simple_pattern, replace_func, content, flags=re.MULTILINE | re.DOTALL)
if count > 0:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
return False
except Exception as e:
print(f"修复文件失败 {file_path}: {e}")
return False
def main():
"""主函数"""
# 查找所有患者HTML文件
pattern = os.path.join(PATIENT_PROFILES_DIR, '*/patients/*.html')
html_files = glob.glob(pattern)
print(f"找到 {len(html_files)} 个患者HTML文件")
fixed_count = 0
skipped_count = 0
for file_path in html_files:
try:
if fix_patient_html(file_path):
fixed_count += 1
if fixed_count % 100 == 0:
print(f"已修复 {fixed_count} 个文件...")
else:
skipped_count += 1
except Exception as e:
print(f"处理文件失败 {file_path}: {e}")
print(f"\n修复完成:")
print(f"- 修复的文件: {fixed_count}")
print(f"- 跳过的文件: {skipped_count}")
print(f"- 总文件数: {len(html_files)}")
if __name__ == '__main__':
main()
\ No newline at end of file
fix_all_patient_pages.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复所有患者页面中的硬编码API URL
将 localhost:5000 替换为相对路径
"""
import os
import re
ROOT = os.path.dirname(os.path.abspath(__file__))
TARGET_DIR = os.path.join(ROOT, 'patient_profiles')
def fix_file(file_path):
"""修复单个文件"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
original = content
total_changes = 0
# 检查是否包含需要修复的内容
if 'localhost:5000' in content:
print(f"发现需要修复的文件: {file_path}")
# 使用简单的字符串替换
# 替换 POST 请求 - 单引号格式
content, count1 = re.subn(r"fetch\('http://localhost:5000(/api/[^']*)',", r"fetch('\1',", content)
total_changes += count1
# 替换 GET 请求 - 模板字符串格式
content, count2 = re.subn(r'fetch\(`http://localhost:5000(/api/[^`]+)`\)', r'fetch(`\1`)', content)
total_changes += count2
# 替换 GET 请求 - 单引号格式
content, count3 = re.subn(r"fetch\('http://localhost:5000(/api/[^']*)'\)", r"fetch('\1')", content)
total_changes += count3
if content != original:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(content)
print(f"✅ 修复 {file_path}: {total_changes} 处更改")
return total_changes
else:
print(f"⚠️ 文件 {file_path} 包含 localhost:5000 但正则表达式未匹配")
return 0
except Exception as e:
print(f"处理文件 {file_path} 时出错: {e}")
return 0
def main():
"""主函数"""
print("🔧 开始修复所有患者页面中的API URL...")
total_files = 0
changed_files = 0
total_changes = 0
for dirpath, dirnames, filenames in os.walk(TARGET_DIR):
for filename in filenames:
if filename.lower().endswith('.html'):
file_path = os.path.join(dirpath, filename)
total_files += 1
changes = fix_file(file_path)
if changes > 0:
changed_files += 1
total_changes += changes
print(f"\n📊 修复完成:")
print(f" - 总文件数: {total_files}")
print(f" - 修改文件数: {changed_files}")
print(f" - 总修改数: {total_changes}")
if changed_files > 0:
print(f"\n🎉 成功修复了 {changed_files} 个文件，共 {total_changes} 处更改")
else:
print("\n✅ 所有文件都是最新的，无需修复")
if __name__ == "__main__":
main()
\ No newline at end of file
fix_callback_records_initialization.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复回访记录初始化问题
在页面加载时调用updateCallbackRecords函数来加载回访记录
"""
import os
import re
import glob
ROOT = os.path.dirname(os.path.abspath(__file__))
PATIENT_PROFILES_DIR = os.path.join(ROOT, 'patient_profiles')
def fix_callback_records_initialization(file_path):
"""修复单个患者页面的回访记录初始化问题"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已经添加了页面加载时初始化回访记录的功能
if 'updateCallbackRecords(patientId)' in content and 'DOMContentLoaded' in content:
# 检查是否在DOMContentLoaded中调用了updateCallbackRecords
if re.search(r'DOMContentLoaded.*updateCallbackRecords', content, re.DOTALL):
return False # 已经修复过了
# 获取病历号
case_number = os.path.basename(file_path).replace('.html', '')
# 查找DOMContentLoaded事件监听器
dom_loaded_pattern = r'(document\.addEventListener\(\'DOMContentLoaded\', function\(\) \{)(.*?)(\}\);)'
match = re.search(dom_loaded_pattern, content, re.DOTALL)
if match:
# 在现有的DOMContentLoaded函数中添加初始化回访记录的代码
existing_code = match.group(2)
new_code = existing_code.rstrip() + f'''
// 页面加载时初始化回访记录
console.log('页面加载完成，开始初始化回访记录...');
updateCallbackRecords('{case_number}');'''
new_content = content.replace(match.group(0),
match.group(1) + new_code + match.group(3))
else:
# 如果没有找到DOMContentLoaded，添加一个新的
# 查找</script>标签的位置
script_end_pattern = r'(\s*</script>\s*</body>)'
script_match = re.search(script_end_pattern, content)
if script_match:
new_script = f'''
<script>
// 页面加载完成后初始化回访记录
document.addEventListener('DOMContentLoaded', function() {{
console.log('页面加载完成，开始初始化回访记录...');
updateCallbackRecords('{case_number}');
}});
</script>
{script_match.group(1)}'''
new_content = content.replace(script_match.group(0), new_script)
else:
# 如果找不到合适的位置，在</body>前添加
body_end_pattern = r'(\s*</body>)'
body_match = re.search(body_end_pattern, content)
if body_match:
new_script = f'''
<script>
// 页面加载完成后初始化回访记录
document.addEventListener('DOMContentLoaded', function() {{
console.log('页面加载完成，开始初始化回访记录...');
updateCallbackRecords('{case_number}');
}});
</script>
{body_match.group(1)}'''
new_content = content.replace(body_match.group(0), new_script)
else:
print(f"无法在文件 {file_path} 中找到合适的位置添加初始化代码")
return False
# 写回文件
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
print(f"✅ 已修复: {file_path}")
return True
except Exception as e:
print(f"❌ 修复失败 {file_path}: {e}")
return False
def main():
"""主函数：修复所有患者页面的回访记录初始化问题"""
print("🔧 开始修复回访记录初始化问题...")
# 查找所有患者页面
patient_files = []
for clinic_dir in glob.glob(os.path.join(PATIENT_PROFILES_DIR, 'clinic_*')):
patients_dir = os.path.join(clinic_dir, 'patients')
if os.path.exists(patients_dir):
patient_files.extend(glob.glob(os.path.join(patients_dir, '*.html')))
print(f"📁 找到 {len(patient_files)} 个患者页面")
fixed_count = 0
for file_path in patient_files:
if fix_callback_records_initialization(file_path):
fixed_count += 1
print(f"\n🎉 修复完成！")
print(f"📊 总计: {len(patient_files)} 个文件")
print(f"✅ 已修复: {fixed_count} 个文件")
print(f"⏭️ 跳过: {len(patient_files) - fixed_count} 个文件（已修复或无需修复）")
print(f"\n💡 修复说明:")
print(f" - 在页面加载时自动调用 updateCallbackRecords() 函数")
print(f" - 确保刷新页面后回访记录能正常显示")
print(f" - 添加了控制台日志便于调试")
if __name__ == '__main__':
main()
\ No newline at end of file
fix_clinic_auth.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量修复门诊页面认证检查代码
"""
import os
import re
def fix_clinic_auth_files():
"""修复所有门诊页面的认证检查代码"""
# 门诊目录列表
clinic_dirs = [
'clinic_xuexian',
'clinic_dafeng',
'clinic_dongting',
'clinic_helai',
'clinic_hongdou',
'clinic_huishan',
'clinic_mashan',
'clinic_hospital',
'clinic_xinwu'
]
# 需要修复的代码模式
old_auth_check = ''' // 检查用户登录状态
async function checkAuth() {
try {
const response = await fetch('/api/user-info');
const result = await response.json();
if (!result.success) {
// 未登录，重定向到登录页
window.location.href = '/login';
return;
}
// 显示用户信息
displayUserInfo(result.user);
// 检查页面访问权限
await checkPageAccess(result.user);
} catch (error) {
console.error('认证检查失败:', error);
window.location.href = '/login';
}
}'''
new_auth_check = ''' // 检查用户登录状态
async function checkAuth() {
try {
// 从localStorage或sessionStorage获取session_id
const sessionId = localStorage.getItem('session_id') || sessionStorage.getItem('session_id');
if (!sessionId) {
window.location.href = '/login';
return;
}
const response = await fetch('/api/user-info', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
session_id: sessionId
})
});
const result = await response.json();
if (!result.success) {
// 清除无效的session
localStorage.removeItem('session_id');
sessionStorage.removeItem('session_id');
window.location.href = '/login';
return;
}
// 显示用户信息
displayUserInfo(result.user);
// 检查页面访问权限
await checkPageAccess(result.user);
} catch (error) {
console.error('认证检查失败:', error);
window.location.href = '/login';
}
}'''
# 需要修复的登出代码模式
old_logout = ''' function logout() {
if (confirm('确定要登出吗？')) {
fetch('/api/logout', {method: 'POST'})
.then(() => window.location.href = '/login')
.catch(() => window.location.href = '/login');
}
}'''
new_logout = ''' function logout() {
if (confirm('确定要登出吗？')) {
fetch('/api/auth/logout', {method: 'POST'})
.then(() => window.location.href = '/login')
.catch(() => window.location.href = '/login');
}
}'''
fixed_count = 0
for clinic_dir in clinic_dirs:
file_path = f'patient_profiles/{clinic_dir}/index.html'
if not os.path.exists(file_path):
print(f"⚠️ 文件不存在: {file_path}")
continue
try:
# 读取文件内容
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
original_content = content
# 修复认证检查代码
if old_auth_check in content:
content = content.replace(old_auth_check, new_auth_check)
print(f"✅ 修复认证检查: {clinic_dir}")
else:
print(f"⚠️ 未找到认证检查代码: {clinic_dir}")
# 修复登出代码
if old_logout in content:
content = content.replace(old_logout, new_logout)
print(f"✅ 修复登出代码: {clinic_dir}")
else:
print(f"⚠️ 未找到登出代码: {clinic_dir}")
# 如果内容有变化，写回文件
if content != original_content:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(content)
fixed_count += 1
print(f"✅ 已修复: {clinic_dir}")
else:
print(f"ℹ️ 无需修复: {clinic_dir}")
except Exception as e:
print(f"❌ 修复失败 {clinic_dir}: {e}")
print(f"\n🎉 修复完成！共修复了 {fixed_count} 个文件")
if __name__ == "__main__":
print("开始批量修复门诊页面认证检查代码...")
fix_clinic_auth_files()
\ No newline at end of file
fix_clinic_jump.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复诊所跳跃问题
解决红豆门诊数据丢失和通善口腔医院跳过前89个患者的问题
"""
import os
import pickle
import shutil
from datetime import datetime
def fix_clinic_jump():
"""修复诊所跳跃问题"""
print("🔧 修复诊所跳跃问题...")
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
# 1. 备份当前文件
backup_file = f"progress_saves/before_fix_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pkl"
shutil.copy2(session_file, backup_file)
print(f"✅ 已创建备份: {os.path.basename(backup_file)}")
# 2. 读取当前状态
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print("\n📊 当前问题状态:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
# 3. 分析问题
print("\n🔍 问题分析:")
print(" 1. 红豆门诊数据完全丢失")
print(" 2. 通善口腔医院从第90个患者开始，跳过了前89个")
print(" 3. 需要重新处理红豆门诊和通善口腔医院的前89个患者")
# 4. 修复策略
print("\n🔧 修复策略:")
# 方案选择
print("请选择修复方案:")
print("1. 重新处理红豆门诊 (推荐)")
print("2. 重新处理通善口腔医院前89个患者")
print("3. 同时修复两个诊所")
while True:
try:
choice = input("请选择方案 (1-3): ").strip()
if choice == "1":
fix_red_clinic(state_data)
break
elif choice == "2":
fix_tongshan_clinic(state_data)
break
elif choice == "3":
fix_both_clinics(state_data)
break
else:
print("请输入1-3")
except KeyboardInterrupt:
print("\n取消操作")
return
# 5. 保存修复后的状态
with open(session_file, 'wb') as f:
pickle.dump(state_data, f)
print("\n✅ 修复完成！")
except Exception as e:
print(f"❌ 修复失败: {e}")
import traceback
traceback.print_exc()
def fix_red_clinic(state_data):
"""修复红豆门诊"""
print("\n🔧 修复红豆门诊...")
# 将当前诊所设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0 # 从头开始
# 清空当前诊所的回调数据
state_data['current_clinic_callbacks'] = []
# 确保红豆门诊不在已完成列表中
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
# 如果红豆门诊在all_results中，移除它
if 'all_results' in state_data and '红豆门诊' in state_data['all_results']:
del state_data['all_results']['红豆门诊']
print(" ✅ 设置当前诊所为红豆门诊")
print(" ✅ 重置患者索引为0")
print(" ✅ 清空临时数据")
print(" ✅ 从已完成列表中移除红豆门诊")
def fix_tongshan_clinic(state_data):
"""修复通善口腔医院"""
print("\n🔧 修复通善口腔医院...")
# 将当前诊所设置为通善口腔医院
state_data['current_clinic'] = '通善口腔医院'
state_data['current_patient_index'] = 0 # 从头开始
# 清空当前诊所的回调数据
state_data['current_clinic_callbacks'] = []
# 确保通善口腔医院不在已完成列表中
if '通善口腔医院' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('通善口腔医院')
# 如果通善口腔医院在all_results中，移除它
if 'all_results' in state_data and '通善口腔医院' in state_data['all_results']:
del state_data['all_results']['通善口腔医院']
print(" ✅ 设置当前诊所为通善口腔医院")
print(" ✅ 重置患者索引为0")
print(" ✅ 清空临时数据")
print(" ✅ 从已完成列表中移除通善口腔医院")
def fix_both_clinics(state_data):
"""同时修复两个诊所"""
print("\n🔧 同时修复红豆门诊和通善口腔医院...")
# 修复红豆门诊
fix_red_clinic(state_data)
# 注意：这里我们选择先处理红豆门诊
# 因为根据您的描述，红豆门诊应该先处理
print("\n📋 处理顺序:")
print(" 1. 先处理红豆门诊 (从头开始)")
print(" 2. 再处理通善口腔医院 (从头开始)")
print(" 3. 最后处理马山门诊")
def show_current_status():
"""显示当前状态"""
print("\n📊 当前诊所处理状态:")
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
success_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'success'])
error_count = len([cb for cb in current_callbacks if cb.get('callback_type') == 'error'])
print(f" - 当前诊所已处理: {len(current_callbacks)} 个患者")
print(f" - ✅ 成功: {success_count} 个")
print(f" - ❌ 失败: {error_count} 个")
# 显示最后几个患者
if len(current_callbacks) > 0:
print(f"\n📋 最后5个处理的患者:")
last_5 = current_callbacks[-5:] if len(current_callbacks) >= 5 else current_callbacks
for i, cb in enumerate(last_5):
status = "✅" if cb.get('callback_type') == 'success' else "❌"
print(f" {len(current_callbacks) - len(last_5) + i + 1}. {cb.get('patient_name', '未知')} ({cb.get('patient_id', '未知')}) {status}")
else:
print(" - 当前诊所无处理记录")
except Exception as e:
print(f"❌ 读取状态失败: {e}")
if __name__ == "__main__":
print("="*60)
print("诊所跳跃问题修复工具")
print("="*60)
# 显示当前状态
show_current_status()
# 询问是否修复
print("\n🔧 是否要修复诊所跳跃问题？")
confirm = input("确认修复？(Y/n): ").strip().lower()
if confirm in ['', 'y', 'yes']:
fix_clinic_jump()
else:
print("取消修复")
\ No newline at end of file
fix_clinic_state.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复诊所处理状态
手动调整会话状态，让系统重新处理红豆门诊
"""
import os
import pickle
import shutil
from datetime import datetime
def fix_clinic_state():
"""修复红豆门诊的处理状态"""
print("🔧 修复红豆门诊处理状态...")
progress_dir = "progress_saves"
session_file = os.path.join(progress_dir, "session_20250805_232912.pkl")
backup_file = os.path.join(progress_dir, f"session_20250805_232912_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pkl")
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
# 1. 备份原文件
shutil.copy2(session_file, backup_file)
print(f"✅ 已创建备份: {os.path.basename(backup_file)}")
# 2. 读取当前状态
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print("\n📊 当前状态:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
# 3. 修复状态
print("\n🔧 修复操作:")
# 将当前诊所设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0 # 从头开始处理红豆门诊
# 清空当前诊所的回调数据（如果有的话）
state_data['current_clinic_callbacks'] = []
# 如果红豆门诊在all_results中，移除它（重新处理）
if 'all_results' in state_data and '红豆门诊' in state_data['all_results']:
del state_data['all_results']['红豆门诊']
print(" ✅ 清除红豆门诊的旧结果数据")
# 确保红豆门诊不在已完成列表中
if 'completed_clinics' in state_data and '红豆门诊' in state_data['completed_clinics']:
state_data['completed_clinics'].remove('红豆门诊')
print(" ✅ 从已完成列表中移除红豆门诊")
# 更新保存时间戳
state_data['save_timestamp'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
state_data['last_save_time'] = datetime.now()
# 4. 保存修复后的状态
with open(session_file, 'wb') as f:
pickle.dump(state_data, f)
print(" ✅ 设置当前诊所为红豆门诊")
print(" ✅ 重置患者索引为0")
print(" ✅ 清空临时回调数据")
print("\n📊 修复后状态:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
# 5. 验证修复结果
print("\n🔍 验证修复结果:")
selected_clinics = state_data.get('generation_config', {}).get('selected_clinics', [])
completed_clinics = state_data.get('completed_clinics', [])
current_clinic = state_data.get('current_clinic')
if current_clinic == '红豆门诊':
print(" ✅ 当前诊所已设置为红豆门诊")
else:
print(f" ❌ 当前诊所设置错误: {current_clinic}")
if '红豆门诊' not in completed_clinics:
print(" ✅ 红豆门诊不在已完成列表中")
else:
print(" ❌ 红豆门诊仍在已完成列表中")
remaining_clinics = [c for c in selected_clinics if c not in completed_clinics]
print(f" 📋 剩余待处理诊所: {remaining_clinics}")
print("\n✅ 修复完成！现在可以重新启动生成器，系统将从红豆门诊开始处理。")
except Exception as e:
print(f"❌ 修复失败: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
fix_clinic_state()
\ No newline at end of file
fix_dafeng_patients.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复大丰门诊患者画像样式问题
重新生成大丰门诊的患者画像，确保样式正确
"""
import os
import json
import sys
import traceback
import shutil
def load_dafeng_data():
"""加载大丰门诊数据"""
try:
print("🔍 正在检查数据文件...")
# 尝试从诊所患者json目录加载
json_file = '诊所患者json/大丰门诊.json'
print(f"📁 数据文件路径: {json_file}")
if os.path.exists(json_file):
print(f"✅ 数据文件存在，大小: {os.path.getsize(json_file)} 字节")
with open(json_file, 'r', encoding='utf-8') as f:
print("📖 正在读取数据文件...")
data = json.load(f)
print(f"✅ 成功加载大丰门诊数据: {len(data)} 条记录")
return data
else:
print(f"❌ 未找到大丰门诊数据文件: {json_file}")
return []
except Exception as e:
print(f"❌ 加载大丰门诊数据失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return []
def fix_dafeng_patients():
"""修复大丰门诊患者画像"""
print("🔧 开始修复大丰门诊患者画像...")
# 加载数据
print("📊 步骤1: 加载数据...")
data = load_dafeng_data()
if not data:
print("❌ 无法加载数据，修复失败")
return False
# 合并患者数据
print("📊 步骤2: 合并患者数据...")
try:
from generate_html import merge_patient_data
patients_data = merge_patient_data(data)
print(f"📊 合并后患者数量: {len(patients_data)}")
except Exception as e:
print(f"❌ 合并患者数据失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return False
# 创建输出目录
print("📁 步骤3: 创建输出目录...")
output_dir = "patient_profiles/clinic_dafeng/patients"
os.makedirs(output_dir, exist_ok=True)
print(f"✅ 输出目录: {output_dir}")
# 重新生成每个患者的HTML
print("🔄 步骤4: 生成患者画像...")
success_count = 0
error_count = 0
# 处理所有患者
all_patients = list(patients_data.items())
print(f"📊 开始处理所有 {len(all_patients)} 个患者...")
for i, (patient_id, records) in enumerate(all_patients, 1):
try:
print(f"🔄 正在生成患者 {patient_id} 的画像... ({i}/{len(all_patients)})")
# 生成HTML
from generate_html import generate_html
generate_html(patient_id, records)
# 检查文件是否生成成功
html_file = f"{patient_id}.html"
if os.path.exists(html_file):
# 目标文件路径
target_file = os.path.join(output_dir, html_file)
# 如果目标文件已存在，先删除
if os.path.exists(target_file):
print(f"🗑️ 删除已存在的文件: {target_file}")
os.remove(target_file)
# 移动文件到目标目录
shutil.move(html_file, target_file)
print(f"✅ 患者 {patient_id} 画像生成成功")
success_count += 1
else:
print(f"❌ 患者 {patient_id} 画像生成失败 - 文件未创建")
error_count += 1
except Exception as e:
print(f"❌ 生成患者 {patient_id} 画像时出错: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
error_count += 1
print(f"\n📈 修复完成!")
print(f"✅ 成功: {success_count} 个患者")
print(f"❌ 失败: {error_count} 个患者")
return success_count > 0
def main():
"""主函数"""
print("🚀 大丰门诊患者画像修复工具")
print("=" * 50)
# 检查依赖
print("🔍 检查依赖...")
try:
import pandas as pd
print("✅ pandas 已安装")
except ImportError:
print("❌ pandas 未安装，请运行: pip install pandas")
return False
try:
import flask
print("✅ flask 已安装")
except ImportError:
print("❌ flask 未安装，请运行: pip install flask")
return False
# 执行修复
print("\n🚀 开始执行修复...")
success = fix_dafeng_patients()
if success:
print("\n🎉 修复完成！请检查 patient_profiles/clinic_dafeng/patients/ 目录")
else:
print("\n💥 修复失败，请检查错误信息")
return success
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\n\n👋 用户中断操作")
sys.exit(0)
except Exception as e:
print(f"\n💥 程序异常: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
sys.exit(1)
\ No newline at end of file
fix_database_encoding.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修复数据库编码问题的脚本
"""
import os
import sys
from callback_record_mysql import MySQLCallbackRecordManager
def fix_database_encoding():
"""修复数据库编码问题"""
try:
# 从环境变量获取数据库配置
db_config = {
'host': os.getenv('DB_HOST', 'localhost'),
'port': int(os.getenv('DB_PORT', 3306)),
'user': os.getenv('DB_USER', 'callback_user'),
'password': os.getenv('DB_PASSWORD', 'dev_password_123'),
'database': os.getenv('DB_NAME', 'callback_system'),
'charset': 'utf8mb4'
}
print("正在连接数据库...")
db_manager = MySQLCallbackRecordManager(**db_config)
# 测试连接
if not db_manager.test_connection():
print("数据库连接失败")
return False
print("数据库连接成功")
# 重新初始化数据库（这会删除并重新创建表）
print("正在重新初始化数据库...")
db_manager.init_database()
print("数据库编码问题修复完成")
return True
except Exception as e:
print(f"修复数据库编码失败: {e}")
return False
if __name__ == "__main__":
success = fix_database_encoding()
if success:
print("✅ 数据库编码修复成功")
else:
print("❌ 数据库编码修复失败")
sys.exit(1)
\ No newline at end of file
fix_database_encoding_final.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
最终数据库编码修复脚本
"""
import os
import sys
import pymysql
from callback_record_mysql import MySQLCallbackRecordManager, CallbackRecord
def fix_database_encoding_final():
"""最终修复数据库编码问题"""
try:
# 从环境变量获取数据库配置
db_config = {
'host': os.getenv('DB_HOST', 'localhost'),
'port': int(os.getenv('DB_PORT', 3306)),
'user': os.getenv('DB_USER', 'callback_user'),
'password': os.getenv('DB_PASSWORD', 'dev_password_123'),
'database': os.getenv('DB_NAME', 'callback_system'),
'charset': 'utf8mb4'
}
print("正在连接数据库...")
# 直接测试数据库连接
conn = pymysql.connect(
host=db_config['host'],
port=db_config['port'],
user=db_config['user'],
password=db_config['password'],
database=db_config['database'],
charset='utf8mb4',
use_unicode=True,
init_command='SET NAMES utf8mb4'
)
with conn.cursor() as cursor:
# 设置会话字符集
cursor.execute("SET NAMES utf8mb4")
cursor.execute("SET CHARACTER SET utf8mb4")
cursor.execute("SET character_set_connection=utf8mb4")
# 检查当前字符集设置
cursor.execute("SHOW VARIABLES LIKE 'character_set%'")
charset_vars = cursor.fetchall()
print("当前字符集设置:")
for var, value in charset_vars:
print(f" {var}: {value}")
# 清理测试数据
cursor.execute("DELETE FROM callback_records WHERE case_number LIKE 'TEST%'")
print("已清理测试数据")
# 测试插入中文数据
test_data = {
'case_number': 'TEST_FINAL',
'callback_methods': ['打电话', '发短信'],
'callback_result': '成功',
'callback_record': '回访方式: 打电话, 发短信, 回访结果: 成功',
'operator': '系统用户'
}
sql = """
INSERT INTO callback_records
(case_number, callback_methods, callback_record, callback_result, operator)
VALUES (%s, %s, %s, %s, %s)
"""
import json
cursor.execute(sql, (
test_data['case_number'],
json.dumps(test_data['callback_methods'], ensure_ascii=False),
test_data['callback_record'],
test_data['callback_result'],
test_data['operator']
))
conn.commit()
print("测试数据插入成功")
# 验证数据
cursor.execute("SELECT * FROM callback_records WHERE case_number = 'TEST_FINAL'")
result = cursor.fetchone()
if result:
print("验证数据:")
print(f" 病历号: {result[1]}")
print(f" 回访方式: {result[2]}")
print(f" 回访记录: {result[3]}")
print(f" 回访结果: {result[4]}")
print(f" 操作员: {result[5]}")
# 检查是否有问号
if '?' in str(result):
print("⚠️ 警告: 数据中仍然包含问号字符")
else:
print("✅ 数据编码正常")
else:
print("❌ 未找到测试数据")
conn.close()
# 使用数据库管理器测试
print("\n使用数据库管理器测试...")
db_manager = MySQLCallbackRecordManager(**db_config)
if not db_manager.test_connection():
print("数据库管理器连接失败")
return False
print("数据库管理器连接成功")
# 测试保存记录
record = CallbackRecord(
case_number='TEST_MANAGER',
callback_methods=['打电话'],
callback_record='回访方式: 打电话, 回访结果: 成功',
callback_result='成功',
operator='系统用户'
)
record_id = db_manager.save_record(record)
print(f"记录保存成功，ID: {record_id}")
# 测试获取记录
records = db_manager.get_records_by_case_number('TEST_MANAGER')
if records:
record_dict = records[0].to_dict()
print("获取的记录:")
print(f" 病历号: {record_dict['case_number']}")
print(f" 回访方式: {record_dict['callback_methods']}")
print(f" 回访结果: {record_dict['callback_result']}")
print(f" 操作员: {record_dict['operator']}")
if '?' in str(record_dict):
print("⚠️ 警告: 数据中仍然包含问号字符")
else:
print("✅ 数据库管理器编码正常")
else:
print("❌ 未找到记录")
print("\n✅ 数据库编码修复完成")
return True
except Exception as e:
print(f"❌ 修复失败: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
fix_database_encoding_final()
\ No newline at end of file
fix_patient_profiles_api_base.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import re
ROOT = os.path.dirname(os.path.abspath(__file__))
TARGET_DIR = os.path.join(ROOT, 'patient_profiles')
# 两种模式：POST 保存接口 和 GET 查询接口（处理单引号和模板字符串两种写法）
PATTERNS = [
(re.compile(r"fetch\('http://localhost:5000(/api/[^']*)'\)"), r"fetch('\1')"),
(re.compile(r"fetch\(`http://localhost:5000(/api/[^`]+)`\)"), r"fetch(`\1`)")
]
changed_files = 0
changed_spans = 0
for dirpath, _, filenames in os.walk(TARGET_DIR):
for fn in filenames:
if not fn.lower().endswith('.html'):
continue
fp = os.path.join(dirpath, fn)
try:
with open(fp, 'r', encoding='utf-8') as f:
content = f.read()
original = content
for pattern, repl in PATTERNS:
content, n = pattern.subn(repl, content)
changed_spans += n
if content != original:
with open(fp, 'w', encoding='utf-8') as f:
f.write(content)
changed_files += 1
except Exception as e:
print(f"跳过 {fp}: {e}")
print(f"已更新文件: {changed_files}, 替换片段: {changed_spans}")
\ No newline at end of file
force_fix.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
强制修复脚本
直接修改会话文件，强制设置为红豆门诊
"""
import os
import pickle
import shutil
from datetime import datetime
def force_fix():
"""强制修复"""
print("🔧 强制修复 - 直接设置为红豆门诊...")
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
# 1. 备份当前文件
backup_file = f"progress_saves/force_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pkl"
shutil.copy2(session_file, backup_file)
print(f"✅ 已创建备份: {os.path.basename(backup_file)}")
# 2. 读取当前状态
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print(f"\n📊 修复前状态:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
# 3. 保存通善口腔医院数据
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
if 'all_results' not in state_data:
state_data['all_results'] = {}
state_data['all_results']['通善口腔医院_已处理'] = current_callbacks
print(f" ✅ 保存了通善口腔医院 {len(current_callbacks)} 个患者的处理结果")
# 4. 强制设置为红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
# 5. 确保诊所状态正确
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
if '通善口腔医院' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('通善口腔医院')
# 6. 更新时间戳
state_data['save_timestamp'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
state_data['last_save_time'] = datetime.now()
# 7. 保存修复后的状态
with open(session_file, 'wb') as f:
pickle.dump(state_data, f)
print(f"\n📊 修复后状态:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
print("\n✅ 强制修复完成！")
print("📋 现在系统将:")
print(" 1. 从红豆门诊开始处理")
print(" 2. 通善口腔医院已处理的数据已保存")
print(" 3. 后续会按顺序处理所有诊所")
except Exception as e:
print(f"❌ 强制修复失败: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
print("="*60)
print("强制修复工具")
print("="*60)
confirm = input("确认强制修复？这将直接修改会话状态 (Y/n): ").strip().lower()
if confirm in ['', 'y', 'yes']:
force_fix()
else:
print("取消修复")
\ No newline at end of file
generate_all_hashes.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
为所有用户生成正确的密码哈希
"""
import hashlib
def hash_password(password: str, salt: str) -> str:
"""生成密码哈希"""
password_bytes = (password + salt).encode('utf-8')
# 进行10000轮哈希增强安全性
for _ in range(10000):
password_bytes = hashlib.sha256(password_bytes).digest()
return password_bytes.hex()
def main():
"""主函数"""
print("=== 生成所有用户的密码哈希 ===")
# 用户列表
users = [
("admin", "admin123", "admin_salt"),
("jinqin", "jinqin123", "jinqin_salt"),
("renshanshan", "renshanshan123", "renshanshan_salt"),
("shaojun", "shaojun123", "shaojun_salt"),
("litingting", "litingting123", "litingting_salt"),
("maqiuyi", "maqiuyi123", "maqiuyi_salt"),
("tangqimin", "tangqimin123", "tangqimin_salt"),
("yueling", "yueling123", "yueling_salt"),
("jijunlin", "jijunlin123", "jijunlin_salt"),
("zhouliping", "zhouliping123", "zhouliping_salt"),
("feimiaomiao", "feimiaomiao123", "feimiaomiao_salt"),
("chenxinyu", "chenxinyu123", "chenxinyu_salt"),
("yanghong", "yanghong123", "yanghong_salt"),
("panjinli", "panjinli123", "panjinli_salt"),
("chenlin", "chenlin123", "chenlin_salt"),
]
print("USE callback_system;")
print()
print("UPDATE users SET password_hash = CASE username")
for username, password, salt in users:
hash_value = hash_password(password, salt)
print(f" WHEN '{username}' THEN '{hash_value}'")
print("END WHERE username IN (")
usernames = [f"'{user[0]}'" for user in users]
print(", ".join(usernames))
print(");")
if __name__ == "__main__":
main()
\ No newline at end of file
generate_clinic_json.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
诊所患者数据转换脚本
读取诊所患者目录中的Excel文件，为每个诊所生成对应的JSON文件
只处理每个Excel文件的第一个sheet
"""
import pandas as pd
import json
import os
from pathlib import Path
import logging
# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
def convert_excel_to_json(excel_file_path, output_dir):
"""
将Excel文件的第一个sheet转换为JSON文件
Args:
excel_file_path (str): Excel文件路径
output_dir (str): 输出目录
Returns:
bool: 转换是否成功
"""
try:
# 获取文件名（不含扩展名）
file_name = Path(excel_file_path).stem
# 跳过临时文件
if file_name.startswith('~$'):
logger.info(f"跳过临时文件: {file_name}")
return True
logger.info(f"正在处理: {file_name}")
# 读取Excel文件的第一个sheet
df = pd.read_excel(excel_file_path, sheet_name=0)
# 处理NaN值，转换为None
df = df.where(pd.notnull(df), None)
# 处理时间戳列，转换为字符串格式
for col in df.columns:
if df[col].dtype == 'datetime64[ns]':
df[col] = df[col].dt.strftime('%Y-%m-%d %H:%M:%S')
elif pd.api.types.is_datetime64_any_dtype(df[col]):
df[col] = df[col].astype(str)
# 转换为字典列表
data = df.to_dict('records')
# 创建输出文件路径
json_file_path = os.path.join(output_dir, f"{file_name}.json")
# 写入JSON文件
with open(json_file_path, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
logger.info(f"成功生成: {json_file_path} (包含 {len(data)} 条记录)")
return True
except Exception as e:
logger.error(f"处理文件 {excel_file_path} 时出错: {str(e)}")
return False
def main():
"""主函数"""
# 定义路径
input_dir = "诊所患者目录"
output_dir = "诊所患者json"
# 创建输出目录
os.makedirs(output_dir, exist_ok=True)
# 获取所有Excel文件
excel_files = []
for file_name in os.listdir(input_dir):
if file_name.endswith('.xlsx') and not file_name.startswith('~$'):
excel_files.append(os.path.join(input_dir, file_name))
if not excel_files:
logger.warning("未找到Excel文件")
return
logger.info(f"找到 {len(excel_files)} 个Excel文件")
# 处理每个Excel文件
success_count = 0
for excel_file in excel_files:
if convert_excel_to_json(excel_file, output_dir):
success_count += 1
logger.info(f"处理完成！成功转换 {success_count}/{len(excel_files)} 个文件")
# 生成汇总信息
summary_info = {
"转换时间": pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S"),
"总文件数": len(excel_files),
"成功转换": success_count,
"输出目录": output_dir,
"转换的文件": []
}
# 统计每个文件的记录数
for json_file in os.listdir(output_dir):
if json_file.endswith('.json') and json_file != 'conversion_summary.json':
json_path = os.path.join(output_dir, json_file)
try:
with open(json_path, 'r', encoding='utf-8') as f:
data = json.load(f)
summary_info["转换的文件"].append({
"文件名": json_file,
"记录数": len(data)
})
except Exception as e:
logger.error(f"读取文件 {json_file} 统计信息时出错: {str(e)}")
# 保存汇总信息
summary_path = os.path.join(output_dir, 'conversion_summary.json')
with open(summary_path, 'w', encoding='utf-8') as f:
json.dump(summary_info, f, ensure_ascii=False, indent=2)
logger.info(f"汇总信息已保存到: {summary_path}")
if __name__ == "__main__":
main()
\ No newline at end of file
generate_complete_hashes.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
生成完整的密码哈希SQL
"""
import hashlib
def hash_password(password: str, salt: str) -> str:
"""生成密码哈希"""
password_bytes = (password + salt).encode('utf-8')
# 进行10000轮哈希增强安全性
for _ in range(10000):
password_bytes = hashlib.sha256(password_bytes).digest()
return password_bytes.hex()
def main():
"""主函数"""
print("=== 生成完整的密码哈希SQL ===")
# 用户列表
users = [
("admin", "admin123", "admin_salt"),
("jinqin", "jinqin123", "jinqin_salt"),
("renshanshan", "renshanshan123", "renshanshan_salt"),
("shaojun", "shaojun123", "shaojun_salt"),
("litingting", "litingting123", "litingting_salt"),
("maqiuyi", "maqiuyi123", "maqiuyi_salt"),
("tangqimin", "tangqimin123", "tangqimin_salt"),
("yueling", "yueling123", "yueling_salt"),
("jijunlin", "jijunlin123", "jijunlin_salt"),
("zhouliping", "zhouliping123", "zhouliping_salt"),
("feimiaomiao", "feimiaomiao123", "feimiaomiao_salt"),
("chenxinyu", "chenxinyu123", "chenxinyu_salt"),
("yanghong", "yanghong123", "yanghong_salt"),
("panjinli", "panjinli123", "panjinli_salt"),
("chenlin", "chenlin123", "chenlin_salt"),
]
print("USE callback_system;")
print()
print("UPDATE users SET password_hash = CASE username")
for username, password, salt in users:
hash_value = hash_password(password, salt)
print(f" WHEN '{username}' THEN '{hash_value}'")
print("END WHERE username IN (")
usernames = [f"'{user[0]}'" for user in users]
print(", ".join(usernames))
print(");")
if __name__ == "__main__":
main()
\ No newline at end of file
generate_html.py deleted 100644 → 0
This source diff could not be displayed because it is too large. You can view the blob instead.
generate_password_hash.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
生成密码哈希
"""
import hashlib
def hash_password(password: str, salt: str) -> str:
"""生成密码哈希"""
password_bytes = (password + salt).encode('utf-8')
# 进行10000轮哈希增强安全性
for _ in range(10000):
password_bytes = hashlib.sha256(password_bytes).digest()
return password_bytes.hex()
def main():
"""主函数"""
print("=== 生成密码哈希 ===")
# 用户列表
users = [
("admin", "admin123", "admin_salt"),
("jinqin", "jinqin123", "jinqin_salt"),
("renshanshan", "renshanshan123", "renshanshan_salt"),
("shaojun", "shaojun123", "shaojun_salt"),
("litingting", "litingting123", "litingting_salt"),
("maqiuyi", "maqiuyi123", "maqiuyi_salt"),
("tangqimin", "tangqimin123", "tangqimin_salt"),
("yueling", "yueling123", "yueling_salt"),
("jijunlin", "jijunlin123", "jijunlin_salt"),
("zhouliping", "zhouliping123", "zhouliping_salt"),
("feimiaomiao", "feimiaomiao123", "feimiaomiao_salt"),
("chenxinyu", "chenxinyu123", "chenxinyu_salt"),
("yanghong", "yanghong123", "yanghong_salt"),
("panjinli", "panjinli123", "panjinli_salt"),
("chenlin", "chenlin123", "chenlin_salt"),
]
print("UPDATE users SET password_hash = CASE username")
for username, password, salt in users:
hash_value = hash_password(password, salt)
print(f" WHEN '{username}' THEN '{hash_value}'")
print("END WHERE username IN (")
usernames = [f"'{user[0]}'" for user in users]
print(", ".join(usernames))
print(");")
if __name__ == "__main__":
main()
\ No newline at end of file
import_patients_from_json.py 0 → 100644
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
从诊所患者JSON文件导入数据到数据库
确保患者和诊所的对应关系正确
"""
import os
import json
import pymysql
from datetime import datetime
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3307,
'user': 'callback_user',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4'
}
def connect_database():
"""连接数据库"""
try:
connection = pymysql.connect(**DB_CONFIG)
print("✅ 数据库连接成功")
return connection
except Exception as e:
print(f"❌ 数据库连接失败: {e}")
return None
def create_patients_table(connection):
"""创建或更新patients表"""
try:
with connection.cursor() as cursor:
# 删除现有表（如果存在）
cursor.execute("DROP TABLE IF EXISTS patients")
# 创建新的patients表
create_table_sql = """
CREATE TABLE patients (
patient_id INT AUTO_INCREMENT PRIMARY KEY,
case_number VARCHAR(50) UNIQUE NOT NULL,
patient_name VARCHAR(100),
patient_phone VARCHAR(20),
gender VARCHAR(10),
age INT,
clinic_name VARCHAR(100) NOT NULL,
diagnosis JSON,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_case_number (case_number),
INDEX idx_clinic_name (clinic_name),
INDEX idx_patient_name (patient_name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
"""
cursor.execute(create_table_sql)
connection.commit()
print("✅ patients表创建成功")
except Exception as e:
print(f"❌ 创建patients表失败: {e}")
connection.rollback()
def import_clinic_patients(connection, clinic_name, json_file_path):
"""导入单个门诊的患者数据"""
try:
if not os.path.exists(json_file_path):
print(f"⚠️ JSON文件不存在: {json_file_path}")
return 0
with open(json_file_path, 'r', encoding='utf-8') as f:
patients_data = json.load(f)
if not isinstance(patients_data, list):
print(f"⚠️ JSON文件格式错误: {json_file_path}")
return 0
imported_count = 0
with connection.cursor() as cursor:
for patient in patients_data:
try:
# 提取患者信息（使用中文字段名）
case_number = patient.get('病历号', '')
patient_name = patient.get('姓名', '')
patient_phone = '' # JSON中没有电话字段
gender = patient.get('性别', '')
age = patient.get('年龄')
diagnosis = {
'医生诊断': patient.get('医生诊断', ''),
'上次就诊诊断': patient.get('上次就诊诊断', ''),
'漏诊项': patient.get('漏诊项', ''),
'缺失牙': patient.get('缺失牙', []),
'牙槽骨吸收': patient.get('牙槽骨吸收', ''),
'恒牙萌出空间不足': patient.get('恒牙萌出空间不足', '')
}
if not case_number:
continue
# 插入患者数据
insert_sql = """
INSERT INTO patients (case_number, patient_name, patient_phone, gender, age, clinic_name, diagnosis)
VALUES (%s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
patient_name = VALUES(patient_name),
patient_phone = VALUES(patient_phone),
gender = VALUES(gender),
age = VALUES(age),
clinic_name = VALUES(clinic_name),
diagnosis = VALUES(diagnosis),
updated_at = CURRENT_TIMESTAMP
"""
cursor.execute(insert_sql, (
case_number,
patient_name,
patient_phone,
gender,
age,
clinic_name,
json.dumps(diagnosis, ensure_ascii=False)
))
imported_count += 1
except Exception as e:
print(f"⚠️ 导入患者 {case_number} 失败: {e}")
continue
connection.commit()
print(f"✅ {clinic_name}: 成功导入 {imported_count} 个患者")
return imported_count
except Exception as e:
print(f"❌ 导入 {clinic_name} 患者数据失败: {e}")
connection.rollback()
return 0
def main():
"""主函数"""
print("🚀 开始从JSON文件导入患者数据...")
# 连接数据库
connection = connect_database()
if not connection:
return
try:
# 创建patients表
create_patients_table(connection)
# 定义门诊和对应的JSON文件
clinics = [
('学前街门诊', '学前街门诊.json'), # 根目录文件
('大丰门诊', '诊所患者json/大丰门诊.json'),
('东亭门诊', '诊所患者json/东亭门诊.json'),
('河埒门诊', '诊所患者json/河埒门诊.json'),
('红豆门诊', '诊所患者json/红豆门诊.json'),
('惠山门诊', '诊所患者json/惠山门诊.json'),
('马山门诊', '诊所患者json/马山门诊.json'),
('通善口腔医院', '诊所患者json/通善口腔医院.json'),
('新吴门诊', '诊所患者json/新吴门诊.json')
]
total_imported = 0
# 导入每个门诊的患者数据
for clinic_name, json_file in clinics:
print(f"\n📋 正在导入 {clinic_name}...")
count = import_clinic_patients(connection, clinic_name, json_file)
total_imported += count
# 验证导入结果
with connection.cursor() as cursor:
cursor.execute("SELECT COUNT(*) as total FROM patients")
total_patients = cursor.fetchone()[0]
cursor.execute("SELECT clinic_name, COUNT(*) as count FROM patients GROUP BY clinic_name ORDER BY count DESC")
clinic_counts = cursor.fetchall()
print(f"\n🎉 导入完成！")
print(f"📊 总患者数: {total_patients}")
print(f"📋 各门诊患者分布:")
for clinic_name, count in clinic_counts:
print(f" {clinic_name}: {count} 人")
except Exception as e:
print(f"❌ 导入过程出错: {e}")
connection.rollback()
finally:
connection.close()
print("\n✅ 数据库连接已关闭")
if __name__ == "__main__":
main()
\ No newline at end of file
requirements.txt
...@@ -4,6 +4,7 @@ Flask-CORS==4.0.0 ...@@ -4,6 +4,7 @@ Flask-CORS==4.0.0
# 数据库 # 数据库
PyMySQL==1.1.0 PyMySQL==1.1.0
cryptography==41.0.7
# 数据处理 # 数据处理
pandas==2.1.4 pandas==2.1.4
......
safe_import_patients.py 0 → 100644
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
安全的患者数据导入脚本
不删除现有数据，只添加或更新缺失的数据
确保生产环境数据安全
"""
import os
import json
import pymysql
from datetime import datetime
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3307,
'user': 'callback_user',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4'
}
def connect_database():
"""连接数据库"""
try:
connection = pymysql.connect(**DB_CONFIG)
print("✅ 数据库连接成功")
return connection
except Exception as e:
print(f"❌ 数据库连接失败: {e}")
return None
def backup_existing_data(connection):
"""备份现有患者数据"""
try:
with connection.cursor() as cursor:
# 检查现有数据
cursor.execute("SELECT COUNT(*) FROM patients")
existing_count = cursor.fetchone()[0]
print(f"📊 现有患者数据: {existing_count} 条")
if existing_count > 0:
# 备份现有数据到临时表
backup_table = f"patients_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
cursor.execute(f"CREATE TABLE {backup_table} AS SELECT * FROM patients")
connection.commit()
print(f"✅ 现有数据已备份到表: {backup_table}")
# 显示现有数据的诊所分布
cursor.execute("SELECT clinic_name, COUNT(*) as count FROM patients GROUP BY clinic_name ORDER BY count DESC")
clinic_distribution = cursor.fetchall()
print("📋 现有数据诊所分布:")
for clinic_name, count in clinic_distribution:
print(f" {clinic_name}: {count} 人")
return existing_count
except Exception as e:
print(f"❌ 备份数据失败: {e}")
connection.rollback()
return 0
def ensure_patients_table(connection):
"""确保patients表存在，如果不存在则创建"""
try:
with connection.cursor() as cursor:
# 检查表是否存在
cursor.execute("SHOW TABLES LIKE 'patients'")
table_exists = cursor.fetchone()
if not table_exists:
print("📝 patients表不存在，正在创建...")
create_table_sql = """
CREATE TABLE patients (
patient_id INT AUTO_INCREMENT PRIMARY KEY,
case_number VARCHAR(50) UNIQUE NOT NULL,
patient_name VARCHAR(100),
patient_phone VARCHAR(20),
gender VARCHAR(10),
age INT,
clinic_name VARCHAR(100) NOT NULL,
diagnosis JSON,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_case_number (case_number),
INDEX idx_clinic_name (clinic_name),
INDEX idx_patient_name (patient_name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
"""
cursor.execute(create_table_sql)
connection.commit()
print("✅ patients表创建成功")
else:
print("✅ patients表已存在")
except Exception as e:
print(f"❌ 创建patients表失败: {e}")
connection.rollback()
def safe_import_clinic_patients(connection, clinic_name, json_file_path):
"""安全导入单个门诊的患者数据"""
try:
if not os.path.exists(json_file_path):
print(f"⚠️ JSON文件不存在: {json_file_path}")
return 0, 0, 0
with open(json_file_path, 'r', encoding='utf-8') as f:
patients_data = json.load(f)
if not isinstance(patients_data, list):
print(f"⚠️ JSON文件格式错误: {json_file_path}")
return 0, 0, 0
added_count = 0
updated_count = 0
skipped_count = 0
with connection.cursor() as cursor:
for patient in patients_data:
try:
# 提取患者信息（使用中文字段名）
case_number = patient.get('病历号', '')
patient_name = patient.get('姓名', '')
patient_phone = '' # JSON中没有电话字段
gender = patient.get('性别', '')
age = patient.get('年龄')
diagnosis = {
'医生诊断': patient.get('医生诊断', ''),
'上次就诊诊断': patient.get('上次就诊诊断', ''),
'漏诊项': patient.get('漏诊项', ''),
'缺失牙': patient.get('缺失牙', []),
'牙槽骨吸收': patient.get('牙槽骨吸收', ''),
'恒牙萌出空间不足': patient.get('恒牙萌出空间不足', '')
}
if not case_number:
skipped_count += 1
continue
# 检查患者是否已存在
cursor.execute("SELECT patient_id FROM patients WHERE case_number = %s", (case_number,))
existing_patient = cursor.fetchone()
if existing_patient:
# 患者已存在，更新信息（保留created_at）
update_sql = """
UPDATE patients SET
patient_name = %s,
patient_phone = %s,
gender = %s,
age = %s,
clinic_name = %s,
diagnosis = %s,
updated_at = CURRENT_TIMESTAMP
WHERE case_number = %s
"""
cursor.execute(update_sql, (
patient_name,
patient_phone,
gender,
age,
clinic_name,
json.dumps(diagnosis, ensure_ascii=False),
case_number
))
updated_count += 1
else:
# 患者不存在，插入新记录
insert_sql = """
INSERT INTO patients (case_number, patient_name, patient_phone, gender, age, clinic_name, diagnosis)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
cursor.execute(insert_sql, (
case_number,
patient_name,
patient_phone,
gender,
age,
clinic_name,
json.dumps(diagnosis, ensure_ascii=False)
))
added_count += 1
except Exception as e:
print(f"⚠️ 处理患者 {case_number} 失败: {e}")
skipped_count += 1
continue
connection.commit()
print(f"✅ {clinic_name}: 新增 {added_count} 个患者，更新 {updated_count} 个患者，跳过 {skipped_count} 个患者")
return added_count, updated_count, skipped_count
except Exception as e:
print(f"❌ 导入 {clinic_name} 患者数据失败: {e}")
connection.rollback()
return 0, 0, 0
def verify_import_results(connection):
"""验证导入结果"""
try:
with connection.cursor() as cursor:
# 统计总患者数
cursor.execute("SELECT COUNT(*) as total FROM patients")
total_patients = cursor.fetchone()[0]
# 统计各诊所患者分布
cursor.execute("SELECT clinic_name, COUNT(*) as count FROM patients GROUP BY clinic_name ORDER BY count DESC")
clinic_counts = cursor.fetchall()
# 检查是否有重复的病历号
cursor.execute("SELECT case_number, COUNT(*) as count FROM patients GROUP BY case_number HAVING count > 1")
duplicates = cursor.fetchall()
print(f"\n🎉 导入完成！")
print(f"📊 总患者数: {total_patients}")
print(f"📋 各门诊患者分布:")
for clinic_name, count in clinic_counts:
print(f" {clinic_name}: {count} 人")
if duplicates:
print(f"⚠️ 发现重复病历号: {len(duplicates)} 个")
for case_number, count in duplicates:
print(f" {case_number}: {count} 次")
else:
print("✅ 无重复病历号")
except Exception as e:
print(f"❌ 验证结果失败: {e}")
def main():
"""主函数"""
print("🚀 开始安全导入患者数据...")
print("⚠️ 注意：此脚本不会删除任何现有数据！")
# 连接数据库
connection = connect_database()
if not connection:
return
try:
# 备份现有数据
existing_count = backup_existing_data(connection)
# 确保patients表存在
ensure_patients_table(connection)
# 定义门诊和对应的JSON文件
clinics = [
('学前街门诊', '学前街门诊.json'), # 根目录文件
('大丰门诊', '诊所患者json/大丰门诊.json'),
('东亭门诊', '诊所患者json/东亭门诊.json'),
('河埒门诊', '诊所患者json/河埒门诊.json'),
('红豆门诊', '诊所患者json/红豆门诊.json'),
('惠山门诊', '诊所患者json/惠山门诊.json'),
('马山门诊', '诊所患者json/马山门诊.json'),
('通善口腔医院', '诊所患者json/通善口腔医院.json'),
('新吴门诊', '诊所患者json/新吴门诊.json')
]
total_added = 0
total_updated = 0
total_skipped = 0
# 导入每个门诊的患者数据
for clinic_name, json_file in clinics:
print(f"\n📋 正在处理 {clinic_name}...")
added, updated, skipped = safe_import_clinic_patients(connection, clinic_name, json_file)
total_added += added
total_updated += updated
total_skipped += skipped
# 验证导入结果
verify_import_results(connection)
print(f"\n📈 导入统计:")
print(f" 新增患者: {total_added}")
print(f" 更新患者: {total_updated}")
print(f" 跳过患者: {total_skipped}")
print(f" 原有患者: {existing_count}")
if existing_count > 0:
print(f"\n✅ 所有原有数据已保留！")
print(f"📋 数据已备份到临时表中")
except Exception as e:
print(f"❌ 导入过程出错: {e}")
connection.rollback()
finally:
connection.close()
print("\n✅ 数据库连接已关闭")
if __name__ == "__main__":
main()
\ No newline at end of file
simple_backup.py 0 → 100644
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
简单的数据库备份工具
无需特殊权限，通过应用程序直接备份
"""
import os
import sys
import pymysql
import json
from datetime import datetime
import zipfile
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3307,
'user': 'callback_user',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4'
}
def create_backup_directory():
"""创建备份目录"""
backup_dir = "database_backups"
if not os.path.exists(backup_dir):
os.makedirs(backup_dir)
print(f"✅ 创建备份目录: {backup_dir}")
return backup_dir
def backup_database(backup_dir):
"""备份数据库"""
try:
print("🔌 连接数据库...")
connection = pymysql.connect(**DB_CONFIG)
cursor = connection.cursor()
# 生成备份文件名
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
backup_file = os.path.join(backup_dir, f"production_backup_{timestamp}.sql")
print(f"📋 开始备份数据库: {DB_CONFIG['database']}")
# 获取所有表名
cursor.execute("SHOW TABLES")
tables = [table[0] for table in cursor.fetchall()]
print(f"📊 发现 {len(tables)} 个表")
with open(backup_file, 'w', encoding='utf-8') as f:
# 写入备份头部信息
f.write(f"-- 患者画像回访话术系统数据库备份\n")
f.write(f"-- 备份时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"-- 数据库: {DB_CONFIG['database']}\n")
f.write(f"-- 表数量: {len(tables)}\n\n")
# 备份每个表
for i, table_name in enumerate(tables, 1):
print(f" [{i}/{len(tables)}] 备份表: {table_name}")
# 获取表结构
cursor.execute(f"SHOW CREATE TABLE `{table_name}`")
create_table_sql = cursor.fetchone()[1]
f.write(f"\n-- 表结构: {table_name}\n")
f.write(f"DROP TABLE IF EXISTS `{table_name}`;\n")
f.write(f"{create_table_sql};\n\n")
# 获取表数据
cursor.execute(f"SELECT COUNT(*) FROM `{table_name}`")
row_count = cursor.fetchone()[0]
if row_count > 0:
f.write(f"-- 表数据: {table_name} ({row_count} 行)\n")
# 分批获取数据避免内存问题
batch_size = 1000
offset = 0
while offset < row_count:
cursor.execute(f"SELECT * FROM `{table_name}` LIMIT {batch_size} OFFSET {offset}")
rows = cursor.fetchall()
for row in rows:
# 构建INSERT语句
values = []
for value in row:
if value is None:
values.append('NULL')
elif isinstance(value, (int, float)):
values.append(str(value))
else:
# 转义字符串
escaped_value = str(value).replace("'", "''").replace("\\", "\\\\")
values.append(f"'{escaped_value}'")
f.write(f"INSERT INTO `{table_name}` VALUES ({', '.join(values)});\n")
offset += batch_size
print(f" ✅ 已备份 {min(offset, row_count)}/{row_count} 行")
f.write("\n")
else:
print(f" ⚠️ 表 {table_name} 无数据")
connection.close()
# 获取备份文件大小
file_size = os.path.getsize(backup_file)
size_mb = file_size / (1024 * 1024)
print(f"✅ 数据库备份完成!")
print(f"📁 备份文件: {backup_file}")
print(f"📏 文件大小: {size_mb:.2f} MB")
return backup_file
except Exception as e:
print(f"❌ 数据库备份失败: {e}")
if 'connection' in locals():
connection.close()
return None
def create_backup_zip(backup_file, backup_dir):
"""创建备份压缩包"""
try:
# 生成压缩包文件名
backup_name = os.path.basename(backup_file)
zip_name = backup_name.replace('.sql', '.zip')
zip_path = os.path.join(backup_dir, zip_name)
print(f"📦 创建压缩包: {zip_name}")
with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
# 添加备份文件
zipf.write(backup_file, backup_name)
# 添加备份信息
info = {
'backup_time': datetime.now().isoformat(),
'database': DB_CONFIG['database'],
'backup_file': backup_name,
'backup_size': os.path.getsize(backup_file),
'compressed_size': os.path.getsize(zip_path)
}
zipf.writestr('backup_info.json', json.dumps(info, ensure_ascii=False, indent=2))
# 获取压缩包大小
zip_size = os.path.getsize(zip_path)
zip_size_mb = zip_size / (1024 * 1024)
print(f"✅ 压缩包创建完成!")
print(f"📁 压缩包: {zip_path}")
print(f"📏 压缩后大小: {zip_size_mb:.2f} MB")
return zip_path
except Exception as e:
print(f"❌ 创建压缩包失败: {e}")
return None
def cleanup_old_backups(backup_dir, keep_days=7):
"""清理旧备份文件"""
try:
print(f"🧹 清理 {keep_days} 天前的旧备份文件...")
current_time = datetime.now()
deleted_count = 0
for filename in os.listdir(backup_dir):
file_path = os.path.join(backup_dir, filename)
# 检查文件修改时间
file_time = datetime.fromtimestamp(os.path.getmtime(file_path))
days_old = (current_time - file_time).days
if days_old > keep_days:
os.remove(file_path)
print(f" 🗑️ 删除旧文件: {filename}")
deleted_count += 1
if deleted_count > 0:
print(f"✅ 清理完成，删除了 {deleted_count} 个旧文件")
else:
print("✅ 无需清理，所有备份文件都是最新的")
except Exception as e:
print(f"⚠️ 清理旧备份失败: {e}")
def show_backup_list(backup_dir):
"""显示备份文件列表"""
try:
print(f"\n📋 备份文件列表 ({backup_dir}):")
print("-" * 80)
files = []
for filename in os.listdir(backup_dir):
if filename.endswith(('.sql', '.zip')):
file_path = os.path.join(backup_dir, filename)
file_size = os.path.getsize(file_path)
file_time = datetime.fromtimestamp(os.path.getmtime(file_path))
files.append((filename, file_size, file_time))
if not files:
print("暂无备份文件")
return
# 按时间排序
files.sort(key=lambda x: x[2], reverse=True)
for filename, file_size, file_time in files:
size_mb = file_size / (1024 * 1024)
time_str = file_time.strftime("%Y-%m-%d %H:%M:%S")
file_type = "📦" if filename.endswith('.zip') else "🗄️"
print(f"{file_type} {filename}")
print(f" 📅 创建时间: {time_str}")
print(f" 📏 文件大小: {size_mb:.2f} MB")
print()
except Exception as e:
print(f"❌ 显示备份列表失败: {e}")
def main():
"""主函数"""
print("🚀 患者画像回访话术系统 - 数据库备份工具")
print("=" * 60)
try:
# 创建备份目录
backup_dir = create_backup_directory()
# 备份数据库
backup_file = backup_database(backup_dir)
if not backup_file:
print("❌ 备份失败，程序退出")
return
# 创建压缩包
zip_file = create_backup_zip(backup_file, backup_dir)
if zip_file:
# 删除原始SQL文件（保留压缩包）
os.remove(backup_file)
print(f"🗑️ 已删除原始SQL文件，保留压缩包")
# 清理旧备份
cleanup_old_backups(backup_dir)
# 显示备份列表
show_backup_list(backup_dir)
print("\n🎉 备份流程完成!")
print(f"💡 提示: 备份文件保存在 {backup_dir} 目录中")
print(f"💡 提示: 建议将备份文件复制到安全位置保存")
except KeyboardInterrupt:
print("\n\n⚠️ 用户中断操作")
except Exception as e:
print(f"\n❌ 备份过程出错: {e}")
if __name__ == "__main__":
main()
\ No newline at end of file
smart_fix.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
智能修复方案
保留已处理的数据，只修复缺失的部分
"""
import os
import pickle
import shutil
from datetime import datetime
def smart_fix():
"""智能修复方案"""
print("🧠 智能修复方案")
print("="*60)
session_file = "progress_saves/session_20250805_232912.pkl"
if not os.path.exists(session_file):
print("❌ 未找到会话文件")
return
try:
# 1. 备份当前文件
backup_file = f"progress_saves/smart_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pkl"
shutil.copy2(session_file, backup_file)
print(f"✅ 已创建备份: {os.path.basename(backup_file)}")
# 2. 读取当前状态
with open(session_file, 'rb') as f:
state_data = pickle.load(f)
print("\n📊 当前状态分析:")
print(f" - 当前诊所: {state_data.get('current_clinic', '未知')}")
print(f" - 当前患者索引: {state_data.get('current_patient_index', 0)}")
print(f" - 已完成诊所: {state_data.get('completed_clinics', [])}")
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
print(f" - 当前诊所已处理: {len(current_callbacks)} 个患者")
# 3. 智能修复策略
print("\n🎯 智能修复策略:")
if state_data.get('current_clinic') == '通善口腔医院':
print(" 📍 当前正在处理通善口腔医院")
print(" 📍 建议：先完成通善口腔医院，再单独处理红豆门诊")
# 方案选择
print("\n🔧 请选择修复方案:")
print("1. 继续完成通善口腔医院，稍后单独处理红豆门诊")
print("2. 立即修复，重新处理红豆门诊和通善口腔医院前89个")
print("3. 混合方案：保存通善口腔医院数据，先处理红豆门诊")
while True:
try:
choice = input("请选择方案 (1-3): ").strip()
if choice == "1":
continue_current_processing(state_data)
break
elif choice == "2":
immediate_fix(state_data)
break
elif choice == "3":
hybrid_fix(state_data)
break
else:
print("请输入1-3")
except KeyboardInterrupt:
print("\n取消操作")
return
# 4. 保存修复后的状态
with open(session_file, 'wb') as f:
pickle.dump(state_data, f)
print("\n✅ 智能修复完成！")
except Exception as e:
print(f"❌ 修复失败: {e}")
import traceback
traceback.print_exc()
def continue_current_processing(state_data):
"""继续当前处理"""
print("\n🔄 继续当前处理...")
print(" ✅ 保持当前状态不变")
print(" 📋 建议处理顺序:")
print(" 1. 完成通善口腔医院剩余患者")
print(" 2. 处理马山门诊")
print(" 3. 最后单独处理红豆门诊")
print(" 💡 这样可以最大化保存已处理的数据")
def immediate_fix(state_data):
"""立即修复"""
print("\n🔧 立即修复...")
# 保存通善口腔医院已处理的数据
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
if 'all_results' not in state_data:
state_data['all_results'] = {}
state_data['all_results']['通善口腔医院'] = current_callbacks
print(f" ✅ 保存了通善口腔医院 {len(current_callbacks)} 个患者的处理结果")
# 设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
# 确保红豆门诊不在已完成列表中
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
print(" ✅ 设置当前诊所为红豆门诊")
print(" ✅ 重置患者索引为0")
print(" 📋 处理顺序: 红豆门诊 → 通善口腔医院(前89个) → 马山门诊")
def hybrid_fix(state_data):
"""混合修复方案"""
print("\n🔧 混合修复方案...")
# 保存通善口腔医院已处理的数据
current_callbacks = state_data.get('current_clinic_callbacks', [])
if current_callbacks:
if 'all_results' not in state_data:
state_data['all_results'] = {}
state_data['all_results']['通善口腔医院'] = current_callbacks
print(f" ✅ 保存了通善口腔医院 {len(current_callbacks)} 个患者的处理结果")
# 将通善口腔医院标记为已完成
if '通善口腔医院' not in state_data.get('completed_clinics', []):
state_data.setdefault('completed_clinics', []).append('通善口腔医院')
# 设置回红豆门诊
state_data['current_clinic'] = '红豆门诊'
state_data['current_patient_index'] = 0
state_data['current_clinic_callbacks'] = []
# 确保红豆门诊不在已完成列表中
if '红豆门诊' in state_data.get('completed_clinics', []):
state_data['completed_clinics'].remove('红豆门诊')
print(" ✅ 保存通善口腔医院数据并标记为完成")
print(" ✅ 设置当前诊所为红豆门诊")
print(" 📋 处理顺序: 红豆门诊 → 马山门诊")
print(" 💡 通善口腔医院数据已保存，无需重新处理")
# 显示通善口腔医院的详细状态
total_patients = 536 # 通善口腔医院总患者数
processed_patients = len(current_callbacks)
missing_front = 89 # 前89个缺失
missing_back = total_patients - processed_patients - missing_front # 后422个未处理
print(f"\n📊 通善口腔医院详细状态:")
print(f" - 总患者数: {total_patients} 个")
print(f" - 已处理: {processed_patients} 个 (第90-{90+processed_patients-1}个)")
print(f" - 前89个缺失: {missing_front} 个 (第1-89个)")
print(f" - 后422个未处理: {missing_back} 个 (第{90+processed_patients}-{total_patients}个)")
print(f" ⚠️ 注意: 通善口腔医院还有 {missing_front + missing_back} 个患者需要处理")
if __name__ == "__main__":
smart_fix()
\ No newline at end of file
start_auth_server.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
认证服务器启动脚本
自动检查环境、安装依赖、初始化数据库并启动服务器
"""
import os
import sys
import subprocess
import time
from pathlib import Path
def print_banner():
"""显示启动横幅"""
print("=" * 60)
print(" 回访记录系统 - 认证服务器启动器")
print("=" * 60)
print()
def check_python_version():
"""检查Python版本"""
print("🐍 检查Python版本...")
if sys.version_info < (3, 7):
print("❌ 错误：需要Python 3.7或更高版本")
print(f" 当前版本：{sys.version}")
return False
print(f"✅ Python版本检查通过：{sys.version.split()[0]}")
return True
def check_dependencies():
"""检查并安装依赖包"""
print("\n📦 检查依赖包...")
required_packages = [
'pymysql',
'flask',
'flask-cors',
'configparser'
]
missing_packages = []
for package in required_packages:
try:
__import__(package.replace('-', '_'))
print(f"✅ {package} 已安装")
except ImportError:
missing_packages.append(package)
print(f"❌ {package} 未安装")
if missing_packages:
print(f"\n🔧 安装缺失的依赖包：{', '.join(missing_packages)}")
try:
subprocess.check_call([
sys.executable, '-m', 'pip', 'install'
] + missing_packages)
print("✅ 依赖包安装完成")
except subprocess.CalledProcessError as e:
print(f"❌ 依赖包安装失败：{e}")
print("\n请手动安装依赖包：")
print(f"pip install {' '.join(missing_packages)}")
return False
return True
def check_database_config():
"""检查数据库配置"""
print("\n🗄️ 检查数据库配置...")
config_file = Path("database_config.ini")
if not config_file.exists():
print("⚠️ 数据库配置文件不存在，将创建默认配置")
try:
from database_config import DatabaseConfig
config_manager = DatabaseConfig()
print("✅ 默认数据库配置已创建")
print("📝 请编辑 database_config.ini 文件，配置您的MySQL连接信息")
return False
except Exception as e:
print(f"❌ 创建数据库配置失败：{e}")
return False
try:
from database_config import DatabaseConfig
config_manager = DatabaseConfig()
if config_manager.validate_config():
print("✅ 数据库配置验证通过")
return True
else:
print("❌ 数据库配置无效")
print("📝 请编辑 database_config.ini 文件，检查配置项")
return False
except Exception as e:
print(f"❌ 数据库配置检查失败：{e}")
return False
def test_database_connection():
"""测试数据库连接"""
print("\n🔗 测试数据库连接...")
try:
from user_manager import create_user_manager
user_manager = create_user_manager()
if user_manager and user_manager.test_connection():
print("✅ 数据库连接测试成功")
return True
else:
print("❌ 数据库连接测试失败")
print("\n请检查：")
print("1. MySQL服务是否正在运行")
print("2. 数据库配置是否正确")
print("3. 数据库用户是否有足够权限")
print("4. 防火墙是否允许连接")
return False
except Exception as e:
print(f"❌ 数据库连接测试失败：{e}")
return False
def check_required_files():
"""检查必需的文件"""
print("\n📁 检查必需文件...")
required_files = [
'auth_server.py',
'user_manager.py',
'session_manager.py',
'database_config.py',
'login.html',
'auth_client.js'
]
missing_files = []
for file_path in required_files:
if not Path(file_path).exists():
missing_files.append(file_path)
print(f"❌ {file_path} 文件缺失")
else:
print(f"✅ {file_path} 文件存在")
if missing_files:
print(f"\n❌ 缺失必需文件：{', '.join(missing_files)}")
return False
return True
def start_server():
"""启动认证服务器"""
print("\n🚀 启动认证服务器...")
try:
# 导入并启动服务器
from auth_server import main
main()
except KeyboardInterrupt:
print("\n👋 服务器已停止")
except Exception as e:
print(f"❌ 服务器启动失败：{e}")
return False
return True
def show_usage_info():
"""显示使用说明"""
print("\n" + "=" * 60)
print("🎉 系统已准备就绪！")
print("=" * 60)
print()
print("📱 访问地址：")
print(" 🔐 登录页面：http://localhost:5000/login")
print(" 📋 患者索引页：http://localhost:5000/patient_profiles/ (登录后默认页面)")
print(" 📊 系统仪表盘：http://localhost:5000/dashboard.html")
print(" 👥 用户管理：http://localhost:5000/user_management.html")
print()
print("👤 默认管理员账户：")
print(" 用户名：admin")
print(" 密码：admin123")
print(" ⚠️ 请登录后立即修改密码！")
print()
print("🔧 管理命令：")
print(" 配置数据库：python database_config.py")
print(" 查看数据库：python view_database.py")
print(" 用户管理：python user_manager.py")
print()
print("📝 注意事项：")
print(" 1. 确保MySQL服务正在运行")
print(" 2. 首次使用请配置数据库连接")
print(" 3. 建议定期备份数据库")
print(" 4. 生产环境请修改默认密码")
print()
def main():
"""主函数"""
print_banner()
# 检查Python版本
if not check_python_version():
return False
# 检查依赖包
if not check_dependencies():
return False
# 检查必需文件
if not check_required_files():
return False
# 检查数据库配置
if not check_database_config():
print("\n💡 提示：请按以下步骤配置数据库：")
print(" 1. 启动MySQL服务")
print(" 2. 编辑 database_config.ini 文件")
print(" 3. 重新运行此脚本")
return False
# 测试数据库连接
if not test_database_connection():
return False
# 显示使用说明
show_usage_info()
# 启动服务器
return start_server()
if __name__ == "__main__":
try:
success = main()
if not success:
print("\n❌ 启动失败，请检查上述错误信息")
sys.exit(1)
except KeyboardInterrupt:
print("\n👋 启动已取消")
sys.exit(0)
except Exception as e:
print(f"\n💥 未知错误：{e}")
sys.exit(1)
\ No newline at end of file
start_callback_api.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
启动SQLite回访记录API服务器
"""
from callback_record_model import create_flask_api
if __name__ == "__main__":
app = create_flask_api()
if app:
print("🚀 启动SQLite回访记录API服务器...")
print("📡 API端点:")
print(" - POST /api/callback-records 保存回访记录")
print(" - GET /api/callback-records/<case> 获取回访记录")
print(" - GET /api/callback-records/statistics 获取统计信息")
print("🌐 服务器地址: http://localhost:5000")
print("按 Ctrl+C 停止服务器")
print("-" * 50)
app.run(host='0.0.0.0', port=5000, debug=True)
else:
print("❌ API服务器启动失败，请检查依赖")
\ No newline at end of file
start_docker.py
#!/usr/bin/env python3 #!/usr/bin/env python3
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
""" """
Docker环境启动脚本 Docker启动文件
自动检测环境并启动相应的服务 在Docker容器中启动患者画像回访话术系统
""" """
import os import os
import sys import sys
import time
from docker_database_config import DockerDatabaseConfig
def wait_for_database(config_manager, max_retries=30, retry_interval=2): # 添加当前目录到Python路径
""" sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
等待数据库服务启动
Args:
config_manager: 数据库配置管理器
max_retries: 最大重试次数
retry_interval: 重试间隔（秒）
Returns:
bool: 数据库连接成功返回True
"""
print("等待数据库服务启动...")
for i in range(max_retries):
try:
if config_manager.test_connection():
print("✅ 数据库连接成功！")
return True
except Exception as e:
print(f"尝试 {i+1}/{max_retries}: 数据库连接失败 - {e}")
if i < max_retries - 1:
print(f"等待 {retry_interval} 秒后重试...")
time.sleep(retry_interval)
print("❌ 数据库连接失败，已达到最大重试次数")
return False
def check_environment():
"""检查运行环境"""
print("=== 检查运行环境 ===")
# 检查Python版本
python_version = sys.version_info
print(f"Python版本: {python_version.major}.{python_version.minor}.{python_version.micro}")
if python_version < (3, 6):
print("❌ Python版本过低，需要3.6或更高版本")
return False
# 检查必需的Python包
required_packages = ['flask', 'pymysql', 'pandas']
missing_packages = []
for package in required_packages:
try:
__import__(package)
print(f"✅ {package} - 已安装")
except ImportError:
print(f"❌ {package} - 未安装")
missing_packages.append(package)
if missing_packages:
print(f"\n请安装缺失的包: pip install {' '.join(missing_packages)}")
return False
# 检查环境变量
print("\n=== 环境变量检查 ===")
env_vars = ['DB_HOST', 'DB_USER', 'DB_PASSWORD', 'DB_NAME']
for var in env_vars:
value = os.getenv(var)
if value:
# 密码只显示前几位
if 'PASSWORD' in var:
display_value = value[:3] + '*' * (len(value) - 3) if len(value) > 3 else '***'
else:
display_value = value
print(f"✅ {var} = {display_value}")
else:
print(f"⚠️ {var} = 未设置")
return True
def initialize_database():
"""初始化数据库"""
print("\n=== 初始化数据库 ===")
try:
# 导入数据库管理模块
from database_manager import DatabaseManager
config_manager = DockerDatabaseConfig()
db_config = config_manager.get_mysql_config()
db_manager = DatabaseManager(db_config)
if db_manager.initialize_database():
print("✅ 数据库初始化成功")
return True
else:
print("❌ 数据库初始化失败")
return False
except ImportError as e:
print(f"⚠️ 数据库管理模块未找到: {e}")
print("跳过数据库初始化...")
return True
except Exception as e:
print(f"❌ 数据库初始化失败: {e}")
return False
def start_flask_app(): # 导入并启动应用
"""启动Flask应用""" from auth_system import app
print("\n=== 启动Flask应用 ===")
# 设置Flask环境变量
os.environ['FLASK_ENV'] = os.getenv('FLASK_ENV', 'production')
os.environ['FLASK_DEBUG'] = os.getenv('FLASK_DEBUG', '0')
try:
# 根据启动参数选择不同的服务器
server_type = os.getenv('SERVER_TYPE', 'auth_system')
if server_type == 'callback_api':
print("启动回访API服务器...")
from callback_api_server import main
elif server_type == 'auth_server':
print("启动认证服务器...")
from auth_server import main
else:
print("启动认证系统服务器（推荐）...")
from auth_system import app, DEFAULT_USERS
# 设置Flask应用
app.secret_key = os.getenv('SECRET_KEY', 'dev_secret_key_2024')
def main():
"""启动认证系统"""
print("🚀 启动患者画像系统认证服务器...")
print("📋 系统信息:")
print(f" - 用户数量: {len(DEFAULT_USERS)}")
print(f" - 门诊数量: {len(set(user.get('clinic_id') for user in DEFAULT_USERS if user.get('clinic_id') != 'admin'))}")
print(f" - 访问地址: http://localhost:5000")
print("✅ 认证系统已就绪!")
app.run(host='0.0.0.0', port=5000, debug=False, threaded=True)
# 启动服务器
main()
except ImportError as e:
print(f"❌ 导入服务器模块失败: {e}")
return False
except Exception as e:
print(f"❌ 启动服务器失败: {e}")
return False
def main(): if __name__ == "__main__":
"""主函数""" # 获取端口配置
print("🚀 患者画像回访话术系统 - Docker启动") port = int(os.environ.get('PORT', 5000))
print("=" * 50) host = os.environ.get('HOST', '0.0.0.0')
debug = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'
# 检查运行环境
if not check_environment():
print("\n❌ 环境检查失败，程序退出")
sys.exit(1)
# 初始化数据库配置
config_manager = DockerDatabaseConfig()
# 等待数据库服务
if not wait_for_database(config_manager):
print("\n❌ 数据库服务不可用，程序退出")
sys.exit(1)
# 初始化数据库 print(f"🚀 启动患者画像回访话术系统...")
if not initialize_database(): print(f"📍 监听地址: {host}:{port}")
print("\n⚠️ 数据库初始化失败，但继续启动服务") print(f"🔧 调试模式: {debug}")
# 启动Flask应用 # 启动Flask应用
print("\n🎯 一切就绪，启动Web服务...") app.run(
start_flask_app() host=host,
port=port,
if __name__ == "__main__": debug=debug,
try: threaded=True
main() )
except KeyboardInterrupt: \ No newline at end of file
print("\n\n👋 收到停止信号，正在关闭服务...")
sys.exit(0)
except Exception as e:
print(f"\n💥 启动失败: {e}")
sys.exit(1)
\ No newline at end of file
test_admin_flow.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试admin登录和门诊选择功能
"""
import requests
import time
def test_admin_login_and_clinic_selection():
"""测试admin登录和门诊选择"""
base_url = "http://localhost:4003"
print("🧪 测试admin登录和门诊选择功能...")
print(f"📡 测试地址: {base_url}")
session = requests.Session()
# 1. 测试admin登录
print("\n1️⃣ 测试admin登录...")
try:
login_data = {
'username': 'admin',
'password': 'admin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
print(f"✅ admin登录成功")
print(f"📋 重定向到: {redirect_url}")
# 2. 访问管理员仪表板
print("\n2️⃣ 访问管理员仪表板...")
dashboard_response = session.get(f"{base_url}{redirect_url}")
if dashboard_response.status_code == 200:
print("✅ 管理员仪表板访问成功")
content = dashboard_response.text
# 检查是否包含门诊选择链接
if "查看患者画像" in content:
print("✅ 管理员仪表板包含门诊选择链接")
# 3. 测试门诊选择 - 选择大丰门诊
print("\n3️⃣ 测试门诊选择 - 选择大丰门诊...")
clinic_url = f"{base_url}/patient_profiles/clinic_dafeng/index.html"
clinic_response = session.get(clinic_url)
if clinic_response.status_code == 200:
print("✅ 大丰门诊患者索引页访问成功")
if "患者画像" in clinic_response.text or "患者列表" in clinic_response.text:
print("✅ 大丰门诊患者索引页内容正确")
else:
print("⚠️ 大丰门诊患者索引页内容可能有问题")
else:
print(f"❌ 大丰门诊患者索引页访问失败，状态码: {clinic_response.status_code}")
else:
print("❌ 管理员仪表板缺少门诊选择链接")
else:
print(f"❌ 管理员仪表板访问失败，状态码: {dashboard_response.status_code}")
else:
print(f"❌ admin登录失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ admin登录测试失败: {e}")
def test_clinic_selection_links():
"""测试所有门诊选择链接"""
base_url = "http://localhost:4003"
print("\n4️⃣ 测试所有门诊选择链接...")
# 先登录admin
session = requests.Session()
login_data = {
'username': 'admin',
'password': 'admin123'
}
session.post(f"{base_url}/login", data=login_data)
# 测试所有门诊
clinics = [
('clinic_xuexian', '学前街门诊'),
('clinic_dafeng', '大丰门诊'),
('clinic_dongting', '东亭门诊'),
('clinic_helai', '河埒门诊'),
('clinic_hongdou', '红豆门诊'),
('clinic_huishan', '惠山门诊'),
('clinic_mashan', '马山门诊'),
('clinic_hospital', '通善口腔医院'),
('clinic_xinwu', '新吴门诊')
]
for clinic_id, clinic_name in clinics:
print(f"\n 测试 {clinic_name} ({clinic_id})...")
try:
clinic_url = f"{base_url}/patient_profiles/{clinic_id}/index.html"
response = session.get(clinic_url)
if response.status_code == 200:
print(f" ✅ {clinic_name} 患者索引页访问成功")
else:
print(f" ❌ {clinic_name} 患者索引页访问失败，状态码: {response.status_code}")
except Exception as e:
print(f" ❌ {clinic_name} 测试失败: {e}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - Admin登录和门诊选择测试")
print("=" * 60)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试admin登录和门诊选择
test_admin_login_and_clinic_selection()
# 测试所有门诊选择链接
test_clinic_selection_links()
print("\n🎉 Admin功能测试完成！")
print("📋 总结:")
print(" - admin登录后应该到门诊管理页面")
print(" - admin可以选择任意门诊进入患者索引页")
print(" - 所有门诊的患者索引页都应该可以访问")
\ No newline at end of file
test_browser_simulation.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
模拟浏览器行为测试
检查session在页面导航中的保持，以及患者详情页面的访问
"""
import requests
import time
import re
def test_full_user_flow():
"""测试完整的用户流程"""
base_url = "http://localhost:4003"
print("🧪 测试完整的用户流程...")
print(f"📡 测试地址: {base_url}")
# 创建session，模拟浏览器
session = requests.Session()
# 1. 登录
print("\n1️⃣ 用户登录...")
try:
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
print(f"✅ 登录成功，重定向到: {redirect_url}")
# 检查session cookie
print(f"🍪 Session cookies: {session.cookies.get_dict()}")
# 2. 访问患者索引页
print("\n2️⃣ 访问患者索引页...")
index_response = session.get(f"{base_url}{redirect_url}")
if index_response.status_code == 200:
print("✅ 患者索引页访问成功")
# 3. 尝试访问患者详情页
print("\n3️⃣ 尝试访问患者详情页...")
# 从患者索引页中提取第一个患者链接
patient_links = re.findall(r'href="(patients/[^"]+)"', index_response.text)
if patient_links:
first_patient = patient_links[0]
patient_url = f"{base_url}/patient_profiles/clinic_dafeng/{first_patient}"
print(f"📋 尝试访问: {patient_url}")
patient_response = session.get(patient_url)
if patient_response.status_code == 200:
if "患者画像回访话术系统 - 登录" in patient_response.text:
print("❌ 访问患者详情页被重定向到登录页")
print("🔍 这就是导致闪退的原因！")
else:
print("✅ 患者详情页访问成功")
else:
print(f"❌ 患者详情页访问失败，状态码: {patient_response.status_code}")
else:
print("❌ 未找到患者链接")
else:
print(f"❌ 患者索引页访问失败，状态码: {index_response.status_code}")
else:
print(f"❌ 登录失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 测试失败: {e}")
def test_session_persistence():
"""测试session持久性"""
base_url = "http://localhost:4003"
print("\n4️⃣ 测试session持久性...")
session = requests.Session()
# 登录
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
session.post(f"{base_url}/login", data=login_data)
# 检查session信息
print(f"🍪 登录后的cookies: {session.cookies.get_dict()}")
# 测试API调用
user_info_response = session.get(f"{base_url}/api/user-info")
if user_info_response.status_code == 200:
user_info = user_info_response.json()
print(f"👤 用户信息: {user_info}")
if user_info.get('authenticated'):
print("✅ Session有效，用户已认证")
else:
print("❌ Session无效，用户未认证")
else:
print(f"❌ 用户信息API调用失败，状态码: {user_info_response.status_code}")
def test_direct_patient_access():
"""测试直接访问患者详情页"""
base_url = "http://localhost:4003"
print("\n5️⃣ 测试直接访问患者详情页...")
session = requests.Session()
# 登录
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
session.post(f"{base_url}/login", data=login_data)
# 直接访问患者详情页
patient_url = f"{base_url}/patient_profiles/clinic_dafeng/patients/TS0G040774.html"
response = session.get(patient_url)
print(f"📋 直接访问患者详情页: {patient_url}")
print(f"📊 响应状态码: {response.status_code}")
print(f"📄 响应长度: {len(response.text)} 字符")
if "患者画像回访话术系统 - 登录" in response.text:
print("❌ 直接访问被重定向到登录页")
elif "患者画像" in response.text or "回访话术" in response.text:
print("✅ 直接访问患者详情页成功")
else:
print("⚠️ 响应内容不确定")
print(f"📄 响应内容开头: {response.text[:200]}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - 浏览器行为模拟测试")
print("=" * 60)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试完整用户流程
test_full_user_flow()
# 测试session持久性
test_session_persistence()
# 测试直接访问患者详情页
test_direct_patient_access()
print("\n🎉 浏览器行为模拟测试完成！")
print("📋 如果患者详情页访问被重定向到登录页，这就是闪退的原因")
\ No newline at end of file
test_callback_display.html deleted 100644 → 0
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>回访话术显示测试</title>
<script src="https://cdn.tailwindcss.com"></script>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
<style>
.callback-section {
transition: all 0.3s ease;
}
.callback-section:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
}
.section-header {
font-family: 'PingFang SC', 'Microsoft YaHei', sans-serif;
}
.section-content {
line-height: 1.8;
}
</style>
</head>
<body class="bg-gray-50 min-h-screen">
<div class="container mx-auto px-4 py-8">
<div class="mb-8">
<h1 class="text-3xl font-bold text-gray-800 mb-2">回访话术显示测试</h1>
<p class="text-gray-600">测试Dify生成的回访话术在患者画像页面中的显示效果</p>
</div>
<!-- 回访话术模块 -->
<div id="callback-content" class="mt-8">
<section class="scroll-trigger">
<div class="bg-white rounded-xl shadow-lg overflow-hidden border-l-4 border-green-500">
<div class="bg-green-600 px-6 py-3 text-white">
<h2 class="text-xl font-bold flex items-center">
<i class="fas fa-phone mr-3"></i>
回访话术 <span class="text-sm ml-2 font-normal">Callback Script</span>
</h2>
</div>
<div class="p-6">
<!-- 患者信息概览 -->
<div class="mb-6 grid grid-cols-1 md:grid-cols-3 gap-4 bg-gray-50 p-4 rounded-lg">
<div>
<span class="font-medium text-gray-600">患者姓名：</span>
<span class="text-gray-800">张测试</span>
</div>
<div>
<span class="font-medium text-gray-600">年龄性别：</span>
<span class="text-gray-800">35岁 男</span>
</div>
<div>
<span class="font-medium text-gray-600">生成时间：</span>
<span class="text-gray-800">2025-07-29 15:26:32</span>
</div>
</div>
<!-- 回访话术四个模块 -->
<div class="space-y-6">
<!-- 第一部分：开场白 -->
<div class="callback-section">
<div class="section-header bg-blue-100 px-4 py-2 rounded-t-lg border-l-4 border-blue-500">
<h3 class="font-bold text-blue-800 flex items-center">
<i class="fas fa-handshake mr-2"></i>
第一部分：开场白
</h3>
</div>
<div class="section-content bg-blue-50 p-4 rounded-b-lg border border-blue-200">
<div class="text-gray-800 leading-relaxed">
<p class="mb-2 text-gray-800 leading-relaxed">您好，周先生，我是江苏瑞泰通善口腔红豆门诊的回访专员。</p>
<p class="mb-2 text-gray-800 leading-relaxed">陈淼医生特意交代我来关注您的后续情况。</p>
<p class="mb-2 text-gray-800 leading-relaxed">（如果是熟悉患者可说：陈淼医生上次还和我提起您呢。）</p>
<p class="mb-2 text-gray-800 leading-relaxed">您自从6月15号检查后，口腔情况怎么样？</p>
</div>
</div>
</div>
<!-- 第二部分：告知漏诊项目 -->
<div class="callback-section">
<div class="section-header bg-yellow-100 px-4 py-2 rounded-t-lg border-l-4 border-yellow-500">
<h3 class="font-bold text-yellow-800 flex items-center">
<i class="fas fa-exclamation-triangle mr-2"></i>
第二部分：告知漏诊项目
</h3>
</div>
<div class="section-content bg-yellow-50 p-4 rounded-b-lg border border-yellow-200">
<div class="text-gray-800 leading-relaxed">
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节1 - 现状描述（短句1）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">在您上次检查中，我们发现了有几颗缺失牙的情况。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节2 - 健康提醒（短句2）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">如果缺失牙问题不及时处理，可能会出现邻牙倾斜、对牙伸长的情况。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节3 - 个人化关怀（短句3）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">您现在35岁，正值事业关键期，及时修复不仅能保护好邻牙，恢复正常的咀嚼功能，对个人形象也很有帮助。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节4 - 专业建议（短句4）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">陈淼医生建议您关注一下这个问题。</p>
</div>
</div>
</div>
<!-- 第三部分：复查建议 -->
<div class="callback-section">
<div class="section-header bg-green-100 px-4 py-2 rounded-t-lg border-l-4 border-green-500">
<h3 class="font-bold text-green-800 flex items-center">
<i class="fas fa-calendar-check mr-2"></i>
第三部分：复查建议
</h3>
</div>
<div class="section-content bg-green-50 p-4 rounded-b-lg border border-green-200">
<div class="text-gray-800 leading-relaxed">
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节1 - 复查重要性（短句1）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">为了您的口腔健康，建议您抽空来院复查一下。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节2 - 健康维护（短句2）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">这是我们给您的健康维护建议，让陈淼医生帮您再仔细看看具体情况。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节3 - 检查说明（短句3）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">复查检查大概需要30分钟的时间，主要是了解一下您缺失牙牙区的现状。</p>
<h4 class="font-semibold text-gray-700 mt-3 mb-1">小节4 - 引导预约（短句4）：</h4>
<p class="mb-2 text-gray-800 leading-relaxed">建议尽快来看看，陈淼医生【时间段1】和【时间段2】这两个时间段有空（根据具体排班描述时间段），您看哪个时间比较方便？</p>
</div>
</div>
</div>
<!-- 第四部分：结束回访语 -->
<div class="callback-section">
<div class="section-header bg-purple-100 px-4 py-2 rounded-t-lg border-l-4 border-purple-500">
<h3 class="font-bold text-purple-800 flex items-center">
<i class="fas fa-check-circle mr-2"></i>
第四部分：结束回访语
</h3>
</div>
<div class="section-content bg-purple-50 p-4 rounded-b-lg border border-purple-200">
<div class="text-gray-800 leading-relaxed">
<div class="mb-4">
<h4 class="font-semibold text-gray-700 mb-2">预约成功：</h4>
<ul class="list-disc ml-6 space-y-1">
<li class="text-gray-800">好的，那我们【具体预约时间】见。</li>
<li class="text-gray-800">那不打扰您了，祝您生活愉快！</li>
</ul>
</div>
<div class="mb-4">
<h4 class="font-semibold text-gray-700 mb-2">预约不成功：</h4>
<ul class="list-disc ml-6 space-y-1">
<li class="text-gray-800">好的，那我下个星期再跟您联系。</li>
<li class="text-gray-800">那不打扰您了，祝您生活愉快！</li>
</ul>
</div>
<div>
<h4 class="font-semibold text-gray-700 mb-2">附加：赠送礼品（见机行事）</h4>
<ul class="list-disc ml-6 space-y-1">
<li class="text-gray-800">我们为回访患者准备了小礼品。</li>
<li class="text-gray-800">到时候来检查可以领取，表示我们对您的感谢。</li>
</ul>
</div>
</div>
</div>
</div>
</div>
<!-- 使用提示 -->
<div class="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
<p class="text-sm text-blue-700">
<i class="fas fa-info-circle mr-2"></i>
<strong>使用提示：</strong>此话术为Dify AI智能生成，严格按照4模块结构设计，请一线回访人员根据实际情况灵活调整使用。
</p>
</div>
</div>
</div>
</section>
</div>
</div>
<script>
// 添加动画效果
document.addEventListener('DOMContentLoaded', function() {
const sections = document.querySelectorAll('.callback-section');
sections.forEach((section, index) => {
setTimeout(() => {
section.style.opacity = '1';
section.style.transform = 'translateY(0)';
}, index * 200);
});
});
</script>
</body>
</html>
\ No newline at end of file
test_docker_deployment.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Docker部署测试脚本
用于验证Docker环境是否正确部署
"""
import requests
import time
import sys
import subprocess
import json
def run_command(command, capture_output=True):
"""
执行命令并返回结果
Args:
command: 要执行的命令
capture_output: 是否捕获输出
Returns:
tuple: (returncode, stdout, stderr)
"""
try:
result = subprocess.run(
command,
shell=True,
capture_output=capture_output,
text=True,
timeout=30
)
return result.returncode, result.stdout, result.stderr
except subprocess.TimeoutExpired:
return -1, "", "命令执行超时"
except Exception as e:
return -1, "", str(e)
def check_docker_installation():
"""检查Docker是否安装"""
print("=== 检查Docker环境 ===")
# 检查Docker
returncode, stdout, stderr = run_command("docker --version")
if returncode == 0:
print(f"✅ Docker: {stdout.strip()}")
else:
print("❌ Docker未安装或无法访问")
return False
# 检查Docker Compose
returncode, stdout, stderr = run_command("docker-compose --version")
if returncode == 0:
print(f"✅ Docker Compose: {stdout.strip()}")
else:
print("❌ Docker Compose未安装或无法访问")
return False
# 检查Docker登录状态
returncode, stdout, stderr = run_command("docker info")
if returncode == 0:
print("✅ Docker服务正常运行")
# 检查是否有登录信息
if "Username" in stdout or "Registry" in stdout:
print("✅ Docker Hub已登录")
else:
print("⚠️ Docker Hub未登录，但可能仍可拉取公共镜像")
else:
print("❌ Docker服务异常")
return False
return True
def check_docker_services():
"""检查Docker服务状态"""
print("\n=== 检查Docker服务状态 ===")
# 检查容器状态
returncode, stdout, stderr = run_command("docker-compose -p patient-callback-system ps")
if returncode == 0:
print("容器状态:")
print(stdout)
# 检查是否有running状态的容器
if "Up" in stdout:
print("✅ 检测到运行中的容器")
return True
else:
print("⚠️ 未检测到运行中的容器")
return False
else:
print("❌ 无法获取容器状态")
print(f"错误: {stderr}")
return False
def test_web_service(base_url="http://localhost:5000", max_retries=10, retry_interval=5):
"""
测试Web服务
Args:
base_url: 基础URL
max_retries: 最大重试次数
retry_interval: 重试间隔
Returns:
bool: 测试通过返回True
"""
print(f"\n=== 测试Web服务 ({base_url}) ===")
test_urls = [
"/",
"/login",
"/patient_profiles/",
"/api/"
]
for i in range(max_retries):
try:
# 测试主页
response = requests.get(base_url, timeout=10)
if response.status_code == 200:
print(f"✅ 主页访问成功 (状态码: {response.status_code})")
break
else:
print(f"⚠️ 主页返回状态码: {response.status_code}")
except requests.exceptions.RequestException as e:
print(f"尝试 {i+1}/{max_retries}: 连接失败 - {e}")
if i < max_retries - 1:
print(f"等待 {retry_interval} 秒后重试...")
time.sleep(retry_interval)
else:
print("❌ Web服务连接失败")
return False
# 测试其他页面
success_count = 0
for url in test_urls:
try:
full_url = base_url + url
response = requests.get(full_url, timeout=10)
if response.status_code in [200, 302, 401]: # 允许重定向和需要认证的页面
print(f"✅ {url} - 状态码: {response.status_code}")
success_count += 1
else:
print(f"⚠️ {url} - 状态码: {response.status_code}")
except requests.exceptions.RequestException as e:
print(f"❌ {url} - 连接失败: {e}")
if success_count >= len(test_urls) * 0.75: # 75%的页面正常即认为测试通过
print(f"✅ Web服务测试通过 ({success_count}/{len(test_urls)})")
return True
else:
print(f"❌ Web服务测试失败 ({success_count}/{len(test_urls)})")
return False
def test_database_connection():
"""测试数据库连接"""
print("\n=== 测试数据库连接 ===")
# 通过容器执行数据库连接测试
command = "docker-compose -p patient-callback-system exec -T mysql mysqladmin ping -h localhost"
returncode, stdout, stderr = run_command(command)
if returncode == 0:
print("✅ MySQL服务正常运行")
# 测试数据库连接
test_command = """docker-compose -p patient-callback-system exec -T mysql mysql -u callback_user -pcallback_pass_2024 callback_system -e "SELECT 1 as test;" """
returncode, stdout, stderr = run_command(test_command)
if returncode == 0:
print("✅ 数据库连接测试成功")
return True
else:
print(f"❌ 数据库连接测试失败: {stderr}")
return False
else:
print(f"❌ MySQL服务异常: {stderr}")
return False
def get_service_logs():
"""获取服务日志"""
print("\n=== 获取服务日志 ===")
services = ["patient_callback_app", "mysql"]
for service in services:
print(f"\n--- {service} 日志 (最近20行) ---")
command = f"docker-compose -p patient-callback-system logs --tail=20 {service}"
returncode, stdout, stderr = run_command(command)
if returncode == 0:
print(stdout)
else:
print(f"无法获取 {service} 日志: {stderr}")
def comprehensive_test():
"""综合测试"""
print("🚀 患者画像回访话术系统 - Docker部署测试")
print("=" * 60)
test_results = []
# 1. 检查Docker环境
result = check_docker_installation()
test_results.append(("Docker环境", result))
if not result:
print("\n❌ Docker环境检查失败，无法继续测试")
return False
# 2. 检查服务状态
result = check_docker_services()
test_results.append(("Docker服务", result))
# 3. 测试Web服务
result = test_web_service()
test_results.append(("Web服务", result))
# 4. 测试数据库连接
result = test_database_connection()
test_results.append(("数据库连接", result))
# 5. 显示测试结果
print("\n" + "=" * 60)
print("📊 测试结果汇总")
print("=" * 60)
success_count = 0
for test_name, success in test_results:
status = "✅ 通过" if success else "❌ 失败"
print(f"{test_name:<15} {status}")
if success:
success_count += 1
print(f"\n总体测试结果: {success_count}/{len(test_results)} 项通过")
if success_count == len(test_results):
print("🎉 所有测试通过！Docker部署成功！")
print("\n🌐 您可以通过以下地址访问系统:")
print(" 主应用: http://localhost:5000")
print(" 登录页面: http://localhost:5000/login")
print(" 患者画像: http://localhost:5000/patient_profiles/")
return True
else:
print("⚠️ 部分测试失败，请查看详细日志")
get_service_logs()
return False
def main():
"""主函数"""
try:
success = comprehensive_test()
if not success:
print("\n🔧 故障排除建议:")
print("1. 确保Docker和Docker Compose已正确安装")
print("2. 检查端口5000和3306是否被占用")
print("3. 运行 'docker-compose logs' 查看详细错误")
print("4. 尝试重新启动服务: 'docker-compose down && docker-compose up -d'")
sys.exit(1)
except KeyboardInterrupt:
print("\n\n👋 测试被用户中断")
sys.exit(0)
except Exception as e:
print(f"\n💥 测试过程中发生错误: {e}")
sys.exit(1)
if __name__ == "__main__":
# 检查是否安装了requests库
try:
import requests
except ImportError:
print("❌ 缺少requests库，请安装: pip install requests")
sys.exit(1)
main()
\ No newline at end of file
test_encoding.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试字符编码的脚本
"""
import os
import sys
from callback_record_mysql import MySQLCallbackRecordManager, CallbackRecord
def test_encoding():
"""测试字符编码"""
try:
# 从环境变量获取数据库配置
db_config = {
'host': os.getenv('DB_HOST', 'localhost'),
'port': int(os.getenv('DB_PORT', 3306)),
'user': os.getenv('DB_USER', 'callback_user'),
'password': os.getenv('DB_PASSWORD', 'dev_password_123'),
'database': os.getenv('DB_NAME', 'callback_system'),
'charset': 'utf8mb4'
}
print("正在连接数据库...")
db_manager = MySQLCallbackRecordManager(**db_config)
# 测试连接
if not db_manager.test_connection():
print("数据库连接失败")
return False
print("数据库连接成功")
# 创建测试记录
test_record = CallbackRecord(
case_number="TEST_ENCODING",
callback_methods=["打电话", "发短信"],
callback_record="回访方式: 打电话, 回访结果: 成功",
callback_result="成功",
operator="测试用户"
)
print(f"测试记录: {test_record.to_dict()}")
# 保存记录
record_id = db_manager.save_record(test_record)
print(f"记录保存成功，ID: {record_id}")
# 读取记录
records = db_manager.get_records_by_case_number("TEST_ENCODING")
if records:
record = records[0]
print(f"读取的记录: {record.to_dict()}")
# 检查字符编码
print(f"callback_result 原始值: {repr(record.callback_result)}")
print(f"callback_result 显示值: {record.callback_result}")
print(f"callback_record 原始值: {repr(record.callback_record)}")
print(f"callback_record 显示值: {record.callback_record}")
# 检查是否为问号
if '?' in record.callback_result or '?' in record.callback_record:
print("❌ 检测到问号字符，编码有问题")
return False
else:
print("✅ 字符编码正常")
return True
else:
print("❌ 无法读取保存的记录")
return False
except Exception as e:
print(f"测试编码失败: {e}")
return False
if __name__ == "__main__":
success = test_encoding()
if success:
print("✅ 字符编码测试成功")
else:
print("❌ 字符编码测试失败")
sys.exit(1)
\ No newline at end of file
test_export.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试导出功能
"""
import requests
import json
def test_export_api():
"""测试导出API"""
base_url = "http://localhost:4002"
# 1. 测试登录
print("=== 测试登录 ===")
login_data = {
"username": "admin",
"password": "admin123"
}
login_response = requests.post(f"{base_url}/api/login", json=login_data)
print(f"登录状态: {login_response.status_code}")
if login_response.status_code != 200:
print("登录失败")
return
login_result = login_response.json()
print(f"登录结果: {login_result}")
# 2. 测试导出API
print("\n=== 测试导出API ===")
# 获取session_id
login_result = login_response.json()
session_id = login_result.get('session_id')
if not session_id:
print("未获取到session_id")
return
print(f"获取到session_id: {session_id}")
# 设置session cookie - 尝试不同的cookie名称
cookies = {
'session': session_id,
'session_id': session_id
}
# 也尝试在headers中传递
headers = {
'Cookie': f'session={session_id}'
}
# 调用导出API - 尝试不同的方式
print("尝试方式1: 使用cookies参数")
export_response = requests.get(f"{base_url}/api/export-data", cookies=cookies)
print(f"方式1结果: {export_response.status_code}")
if export_response.status_code != 200:
print("尝试方式2: 使用headers中的Cookie")
export_response = requests.get(f"{base_url}/api/export-data", headers=headers)
print(f"方式2结果: {export_response.status_code}")
if export_response.status_code != 200:
print("尝试方式3: 直接设置Cookie header")
export_response = requests.get(f"{base_url}/api/export-data", headers={'Cookie': f'session={session_id}'})
print(f"方式3结果: {export_response.status_code}")
print(f"导出API状态: {export_response.status_code}")
if export_response.status_code == 200:
export_result = export_response.json()
print(f"导出结果: {json.dumps(export_result, indent=2, ensure_ascii=False)}")
if export_result.get('success'):
filename = export_result.get('filename')
download_url = export_result.get('download_url')
print(f"文件名: {filename}")
print(f"下载链接: {download_url}")
# 测试下载
print("\n=== 测试文件下载 ===")
download_response = requests.get(f"{base_url}{download_url}", cookies=cookies)
print(f"下载状态: {download_response.status_code}")
if download_response.status_code == 200:
# 保存文件
with open(filename, 'wb') as f:
f.write(download_response.content)
print(f"文件已保存: {filename}")
# 检查文件大小
import os
file_size = os.path.getsize(filename)
print(f"文件大小: {file_size} 字节")
if file_size > 1000: # 大于1KB说明有数据
print("✅ 导出成功！文件包含数据")
else:
print("❌ 文件太小，可能没有数据")
else:
print(f"下载失败: {download_response.text}")
else:
print(f"导出失败: {export_result.get('message')}")
else:
print(f"导出API调用失败: {export_response.text}")
if __name__ == "__main__":
test_export_api()
\ No newline at end of file
test_export_direct.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
直接测试导出模块
"""
from export_data import DataExporter
import os
def test_export_direct():
"""直接测试导出模块"""
print("=== 直接测试导出模块 ===")
try:
# 创建导出器
exporter = DataExporter()
print("✅ 导出器创建成功")
# 获取数据
print("\n=== 获取数据 ===")
clinic_data = exporter.get_clinic_data()
print(f"获取到诊所数据: {len(clinic_data)} 个诊所")
for clinic_id, data in clinic_data.items():
print(f" {clinic_id}: {data['clinic_name']} - {len(data['records'])} 条记录")
# 导出到Excel
print("\n=== 导出到Excel ===")
output_file = exporter.export_to_excel()
print(f"导出文件: {output_file}")
# 检查文件
if os.path.exists(output_file):
file_size = os.path.getsize(output_file)
print(f"文件大小: {file_size} 字节")
if file_size > 1000:
print("✅ 导出成功！文件包含数据")
else:
print("❌ 文件太小，可能没有数据")
else:
print("❌ 文件未生成")
except Exception as e:
print(f"❌ 测试失败: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
test_export_direct()
\ No newline at end of file
test_javascript_apis.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试JavaScript API端点
验证患者索引页中JavaScript代码调用的API端点是否正常工作
"""
import requests
import json
import time
def test_javascript_apis():
"""测试JavaScript API端点"""
base_url = "http://localhost:4003"
print("🧪 测试JavaScript API端点...")
print(f"📡 测试地址: {base_url}")
# 创建session并登录
session = requests.Session()
print("\n1️⃣ 用户登录...")
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
login_response = session.post(f"{base_url}/login", data=login_data)
if login_response.status_code == 200 or login_response.status_code == 302:
print("✅ 登录成功")
# 测试 /api/user-info (POST方法)
print("\n2️⃣ 测试 /api/user-info (POST方法)...")
try:
user_info_data = {
'session_id': 'dummy_session_id' # 实际上我们使用Flask session
}
response = session.post(
f"{base_url}/api/user-info",
json=user_info_data,
headers={'Content-Type': 'application/json'}
)
print(f"📊 状态码: {response.status_code}")
if response.status_code == 200:
result = response.json()
print(f"📄 响应: {json.dumps(result, ensure_ascii=False, indent=2)}")
if result.get('success'):
print("✅ /api/user-info (POST) 工作正常")
else:
print("❌ /api/user-info (POST) 返回失败")
else:
print(f"❌ /api/user-info (POST) 请求失败")
except Exception as e:
print(f"❌ /api/user-info (POST) 测试异常: {e}")
# 测试 /api/user-info (GET方法)
print("\n3️⃣ 测试 /api/user-info (GET方法)...")
try:
response = session.get(f"{base_url}/api/user-info")
print(f"📊 状态码: {response.status_code}")
if response.status_code == 200:
result = response.json()
print(f"📄 响应: {json.dumps(result, ensure_ascii=False, indent=2)}")
if result.get('success'):
print("✅ /api/user-info (GET) 工作正常")
else:
print("❌ /api/user-info (GET) 返回失败")
else:
print(f"❌ /api/user-info (GET) 请求失败")
except Exception as e:
print(f"❌ /api/user-info (GET) 测试异常: {e}")
# 测试 /api/check-access/{clinic_id}
print("\n4️⃣ 测试 /api/check-access/clinic_dafeng...")
try:
response = session.get(f"{base_url}/api/check-access/clinic_dafeng")
print(f"📊 状态码: {response.status_code}")
if response.status_code == 200:
result = response.json()
print(f"📄 响应: {json.dumps(result, ensure_ascii=False, indent=2)}")
if result.get('has_access'):
print("✅ /api/check-access 工作正常，有访问权限")
else:
print("⚠️ /api/check-access 工作正常，但无访问权限")
else:
print(f"❌ /api/check-access 请求失败")
except Exception as e:
print(f"❌ /api/check-access 测试异常: {e}")
# 测试 /api/auth/logout
print("\n5️⃣ 测试 /api/auth/logout...")
try:
response = session.post(f"{base_url}/api/auth/logout")
print(f"📊 状态码: {response.status_code}")
if response.status_code == 200:
result = response.json()
print(f"📄 响应: {json.dumps(result, ensure_ascii=False, indent=2)}")
if result.get('success'):
print("✅ /api/auth/logout 工作正常")
else:
print("❌ /api/auth/logout 返回失败")
else:
print(f"❌ /api/auth/logout 请求失败")
except Exception as e:
print(f"❌ /api/auth/logout 测试异常: {e}")
else:
print(f"❌ 登录失败，状态码: {login_response.status_code}")
def test_admin_apis():
"""测试管理员API端点"""
base_url = "http://localhost:4003"
print("\n6️⃣ 测试管理员API端点...")
# 创建session并以管理员身份登录
session = requests.Session()
login_data = {
'username': 'admin',
'password': 'admin123'
}
login_response = session.post(f"{base_url}/login", data=login_data)
if login_response.status_code == 200 or login_response.status_code == 302:
print("✅ 管理员登录成功")
# 测试管理员访问其他门诊
print("\n7️⃣ 测试管理员访问其他门诊权限...")
test_clinics = ['clinic_dafeng', 'clinic_xuexian', 'clinic_dongting']
for clinic_id in test_clinics:
try:
response = session.get(f"{base_url}/api/check-access/{clinic_id}")
if response.status_code == 200:
result = response.json()
access_status = "✅ 有权限" if result.get('has_access') else "❌ 无权限"
print(f" {clinic_id}: {access_status}")
else:
print(f" {clinic_id}: ❌ 请求失败 ({response.status_code})")
except Exception as e:
print(f" {clinic_id}: ❌ 异常 ({e})")
else:
print(f"❌ 管理员登录失败，状态码: {login_response.status_code}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - JavaScript API测试")
print("=" * 60)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试JavaScript API端点
test_javascript_apis()
# 测试管理员API端点
test_admin_apis()
print("\n🎉 JavaScript API测试完成！")
print("📋 如果所有API都正常工作，患者索引页就不会闪退了")
\ No newline at end of file
test_login.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试登录功能
"""
import requests
import json
def test_login(username, password):
"""测试登录功能"""
url = "http://localhost:5000/api/auth/login"
data = {
"username": username,
"password": password
}
try:
response = requests.post(url, json=data)
result = response.json()
print(f"测试用户: {username}")
print(f"响应状态: {response.status_code}")
print(f"响应内容: {json.dumps(result, ensure_ascii=False, indent=2)}")
print("-" * 50)
return result.get('success', False)
except Exception as e:
print(f"测试失败: {e}")
return False
def main():
"""主函数"""
print("=== 登录功能测试 ===")
# 测试管理员账号
print("\n1. 测试管理员账号")
admin_success = test_login("admin", "admin123")
# 测试门诊用户账号
print("\n2. 测试门诊用户账号")
clinic_success = test_login("jinqin", "jinqin123")
# 测试错误密码
print("\n3. 测试错误密码")
wrong_success = test_login("admin", "wrong_password")
# 总结
print("\n=== 测试结果 ===")
print(f"管理员登录: {'✅ 成功' if admin_success else '❌ 失败'}")
print(f"门诊用户登录: {'✅ 成功' if clinic_success else '❌ 失败'}")
print(f"错误密码测试: {'✅ 正确拒绝' if not wrong_success else '❌ 错误接受'}")
if admin_success and clinic_success and not wrong_success:
print("\n🎉 所有测试通过！登录功能正常。")
else:
print("\n⚠️ 部分测试失败，需要进一步检查。")
if __name__ == "__main__":
main()
\ No newline at end of file
test_login_fix.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试登录修复
验证登录后是否能正常访问仪表板
"""
import requests
import time
def test_login_flow():
"""测试登录流程"""
base_url = "http://localhost:4003"
print("🧪 开始测试登录流程...")
print(f"📡 测试地址: {base_url}")
# 创建会话
session = requests.Session()
# 1. 访问主页，应该重定向到登录页
print("\n1️⃣ 测试主页重定向...")
try:
response = session.get(base_url, allow_redirects=False)
if response.status_code == 302:
print("✅ 主页正确重定向到登录页")
else:
print(f"❌ 主页重定向失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 访问主页失败: {e}")
return False
# 2. 访问登录页
print("\n2️⃣ 测试登录页面...")
try:
response = session.get(f"{base_url}/login")
if response.status_code == 200:
print("✅ 登录页面访问成功")
else:
print(f"❌ 登录页面访问失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 访问登录页失败: {e}")
return False
# 3. 测试管理员登录
print("\n3️⃣ 测试管理员登录...")
try:
login_data = {
'username': 'admin',
'password': 'admin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
print("✅ 管理员登录成功")
redirect_url = response.headers.get('Location', '')
print(f"📋 重定向到: {redirect_url}")
# 4. 访问管理员仪表板
print("\n4️⃣ 测试管理员仪表板...")
dashboard_response = session.get(f"{base_url}{redirect_url}")
if dashboard_response.status_code == 200:
print("✅ 管理员仪表板访问成功")
if "管理员仪表板" in dashboard_response.text:
print("✅ 仪表板内容正确")
else:
print("⚠️ 仪表板内容可能有问题")
else:
print(f"❌ 管理员仪表板访问失败，状态码: {dashboard_response.status_code}")
else:
print(f"❌ 管理员登录失败，状态码: {response.status_code}")
print(f"📄 响应内容: {response.text[:200]}")
except Exception as e:
print(f"❌ 管理员登录测试失败: {e}")
return False
# 5. 测试门诊用户登录
print("\n5️⃣ 测试门诊用户登录...")
try:
session = requests.Session() # 创建新会话
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
print("✅ 门诊用户登录成功")
redirect_url = response.headers.get('Location', '')
print(f"📋 重定向到: {redirect_url}")
# 6. 访问门诊仪表板
print("\n6️⃣ 测试门诊仪表板...")
clinic_response = session.get(f"{base_url}{redirect_url}")
if clinic_response.status_code == 200:
print("✅ 门诊仪表板访问成功")
if "大丰门诊" in clinic_response.text:
print("✅ 门诊仪表板内容正确")
else:
print("⚠️ 门诊仪表板内容可能有问题")
else:
print(f"❌ 门诊仪表板访问失败，状态码: {clinic_response.status_code}")
else:
print(f"❌ 门诊用户登录失败，状态码: {response.status_code}")
print(f"📄 响应内容: {response.text[:200]}")
except Exception as e:
print(f"❌ 门诊用户登录测试失败: {e}")
return False
print("\n🎉 所有测试完成！")
return True
def test_api_endpoints():
"""测试API端点"""
base_url = "http://localhost:4003"
print("\n🔧 测试API端点...")
# 测试用户信息API
try:
response = requests.get(f"{base_url}/api/user-info")
if response.status_code == 200:
data = response.json()
if not data.get('authenticated'):
print("✅ 用户信息API正常（未登录状态）")
else:
print("⚠️ 用户信息API返回已登录状态")
else:
print(f"❌ 用户信息API失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 用户信息API测试失败: {e}")
# 测试登出API
try:
response = requests.post(f"{base_url}/api/logout")
if response.status_code == 200:
print("✅ 登出API正常")
else:
print(f"❌ 登出API失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 登出API测试失败: {e}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - 登录修复测试")
print("=" * 50)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试登录流程
success = test_login_flow()
# 测试API端点
test_api_endpoints()
if success:
print("\n✅ 登录修复测试通过！")
print("🎯 现在可以正常使用系统了：")
print(" - 访问 http://localhost:4003")
print(" - 使用测试账号登录")
print(" - 查看仪表板功能")
else:
print("\n❌ 登录修复测试失败！")
print("🔧 请检查服务状态和配置")
\ No newline at end of file
test_login_flow.html deleted 100644 → 0
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>登录流程测试</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 0 auto;
padding: 20px;
background-color: #f5f5f5;
}
.test-section {
background: white;
padding: 20px;
margin: 20px 0;
border-radius: 8px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.test-button {
background: #007bff;
color: white;
border: none;
padding: 10px 20px;
border-radius: 4px;
cursor: pointer;
margin: 5px;
}
.test-button:hover {
background: #0056b3;
}
.result {
margin-top: 10px;
padding: 10px;
border-radius: 4px;
}
.success {
background: #d4edda;
color: #155724;
border: 1px solid #c3e6cb;
}
.error {
background: #f8d7da;
color: #721c24;
border: 1px solid #f5c6cb;
}
.info {
background: #d1ecf1;
color: #0c5460;
border: 1px solid #bee5eb;
}
</style>
</head>
<body>
<h1>登录流程测试</h1>
<div class="test-section">
<h2>1. 检查当前登录状态</h2>
<button class="test-button" onclick="checkCurrentStatus()">检查登录状态</button>
<div id="statusResult"></div>
</div>
<div class="test-section">
<h2>2. 测试登录API</h2>
<button class="test-button" onclick="testLogin()">测试登录 (admin/admin123)</button>
<div id="loginResult"></div>
</div>
<div class="test-section">
<h2>3. 测试用户信息API</h2>
<button class="test-button" onclick="testUserInfo()">获取用户信息</button>
<div id="userInfoResult"></div>
</div>
<div class="test-section">
<h2>4. 测试登出API</h2>
<button class="test-button" onclick="testLogout()">测试登出</button>
<div id="logoutResult"></div>
</div>
<div class="test-section">
<h2>5. 页面跳转测试</h2>
<button class="test-button" onclick="testRedirect()">测试跳转到患者画像</button>
<button class="test-button" onclick="testLoginPage()">测试跳转到登录页</button>
</div>
<div class="test-section">
<h2>6. 清除所有会话</h2>
<button class="test-button" onclick="clearAllSessions()">清除会话</button>
<div id="clearResult"></div>
</div>
<script>
function showResult(elementId, message, type = 'info') {
const element = document.getElementById(elementId);
element.innerHTML = `<div class="result ${type}">${message}</div>`;
}
function checkCurrentStatus() {
const sessionId = localStorage.getItem('session_id') || sessionStorage.getItem('session_id');
const userInfo = localStorage.getItem('user_info') || sessionStorage.getItem('user_info');
let message = `Session ID: ${sessionId ? '存在' : '不存在'}<br>`;
message += `User Info: ${userInfo ? '存在' : '不存在'}<br>`;
if (userInfo) {
try {
const user = JSON.parse(userInfo);
message += `用户名: ${user.username}<br>`;
message += `角色: ${user.role}<br>`;
} catch (e) {
message += `用户信息解析失败: ${e.message}`;
}
}
showResult('statusResult', message, sessionId ? 'success' : 'error');
}
async function testLogin() {
try {
const response = await fetch('/api/auth/login', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
username: 'admin',
password: 'admin123',
remember_me: true
})
});
const result = await response.json();
if (result.success) {
// 保存会话信息
localStorage.setItem('session_id', result.session_id);
localStorage.setItem('user_info', JSON.stringify(result.user));
showResult('loginResult',
`登录成功！<br>Session ID: ${result.session_id}<br>用户: ${result.user.username}<br>角色: ${result.user.role}`,
'success');
} else {
showResult('loginResult', `登录失败: ${result.message}`, 'error');
}
} catch (error) {
showResult('loginResult', `网络错误: ${error.message}`, 'error');
}
}
async function testUserInfo() {
try {
const sessionId = localStorage.getItem('session_id') || sessionStorage.getItem('session_id');
if (!sessionId) {
showResult('userInfoResult', '没有找到session_id', 'error');
return;
}
const response = await fetch('/api/user-info', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
session_id: sessionId
})
});
const result = await response.json();
if (result.success) {
showResult('userInfoResult',
`获取用户信息成功！<br>用户名: ${result.user.username}<br>角色: ${result.user.role}`,
'success');
} else {
showResult('userInfoResult', `获取用户信息失败: ${result.message}`, 'error');
}
} catch (error) {
showResult('userInfoResult', `网络错误: ${error.message}`, 'error');
}
}
async function testLogout() {
try {
const sessionId = localStorage.getItem('session_id') || sessionStorage.getItem('session_id');
if (!sessionId) {
showResult('logoutResult', '没有找到session_id', 'error');
return;
}
const response = await fetch('/api/auth/logout', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
session_id: sessionId
})
});
const result = await response.json();
if (result.success) {
// 清除本地存储
localStorage.removeItem('session_id');
localStorage.removeItem('user_info');
sessionStorage.removeItem('session_id');
sessionStorage.removeItem('user_info');
showResult('logoutResult', '登出成功！', 'success');
} else {
showResult('logoutResult', `登出失败: ${result.message}`, 'error');
}
} catch (error) {
showResult('logoutResult', `网络错误: ${error.message}`, 'error');
}
}
function testRedirect() {
window.open('/patient_profiles/', '_blank');
}
function testLoginPage() {
window.open('/login', '_blank');
}
function clearAllSessions() {
localStorage.removeItem('session_id');
localStorage.removeItem('user_info');
sessionStorage.removeItem('session_id');
sessionStorage.removeItem('user_info');
showResult('clearResult', '所有会话已清除', 'success');
}
// 页面加载时检查状态
window.addEventListener('load', checkCurrentStatus);
</script>
</body>
</html>
\ No newline at end of file
test_login_redirect.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试登录重定向逻辑
验证管理员和普通用户的登录后重定向是否正确
"""
import requests
import time
def test_login_redirects():
"""测试登录重定向"""
base_url = "http://localhost:4003"
print("🧪 开始测试登录重定向逻辑...")
print(f"📡 测试地址: {base_url}")
# 测试管理员登录
print("\n1️⃣ 测试管理员登录重定向...")
session = requests.Session()
try:
# 管理员登录
login_data = {
'username': 'admin',
'password': 'admin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
print(f"✅ 管理员登录成功")
print(f"📋 重定向到: {redirect_url}")
if redirect_url == '/admin/dashboard':
print("✅ 管理员重定向正确 - 到门诊索引页")
else:
print(f"❌ 管理员重定向错误 - 期望: /admin/dashboard, 实际: {redirect_url}")
# 访问重定向页面
dashboard_response = session.get(f"{base_url}{redirect_url}")
if dashboard_response.status_code == 200:
print("✅ 管理员仪表板访问成功")
if "门诊管理" in dashboard_response.text:
print("✅ 管理员仪表板内容正确 - 显示门诊索引")
else:
print("⚠️ 管理员仪表板内容可能有问题")
else:
print(f"❌ 管理员仪表板访问失败，状态码: {dashboard_response.status_code}")
else:
print(f"❌ 管理员登录失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 管理员登录测试失败: {e}")
# 测试普通用户登录
print("\n2️⃣ 测试普通用户登录重定向...")
session = requests.Session() # 创建新会话
try:
# 普通用户登录
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
print(f"✅ 普通用户登录成功")
print(f"📋 重定向到: {redirect_url}")
if '/patient_profiles/clinic_dafeng/index.html' in redirect_url:
print("✅ 普通用户重定向正确 - 到患者索引页")
else:
print(f"❌ 普通用户重定向错误 - 期望包含: /patient_profiles/clinic_dafeng/index.html, 实际: {redirect_url}")
# 访问重定向页面
patient_response = session.get(f"{base_url}{redirect_url}")
if patient_response.status_code == 200:
print("✅ 患者索引页访问成功")
if "患者画像" in patient_response.text or "患者列表" in patient_response.text:
print("✅ 患者索引页内容正确")
else:
print("⚠️ 患者索引页内容可能有问题")
else:
print(f"❌ 患者索引页访问失败，状态码: {patient_response.status_code}")
else:
print(f"❌ 普通用户登录失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 普通用户登录测试失败: {e}")
# 测试其他普通用户
print("\n3️⃣ 测试其他普通用户登录重定向...")
test_users = [
('zhangwei', 'zhangwei123', 'clinic_xuexian'),
('lihua', 'lihua123', 'clinic_dongting'),
('wangfang', 'wangfang123', 'clinic_huishan')
]
for username, password, expected_clinic in test_users:
print(f"\n 测试用户: {username}")
session = requests.Session()
try:
login_data = {
'username': username,
'password': password
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
expected_url = f'/patient_profiles/{expected_clinic}/index.html'
if expected_url in redirect_url:
print(f" ✅ {username} 重定向正确 - 到 {expected_clinic} 患者索引页")
else:
print(f" ❌ {username} 重定向错误 - 期望: {expected_url}, 实际: {redirect_url}")
else:
print(f" ❌ {username} 登录失败，状态码: {response.status_code}")
except Exception as e:
print(f" ❌ {username} 登录测试失败: {e}")
def test_dashboard_content():
"""测试仪表板内容"""
base_url = "http://localhost:4003"
print("\n4️⃣ 测试仪表板内容...")
# 测试管理员仪表板
session = requests.Session()
try:
# 先登录
login_data = {
'username': 'admin',
'password': 'admin123'
}
session.post(f"{base_url}/login", data=login_data)
# 访问管理员仪表板
response = session.get(f"{base_url}/admin/dashboard")
if response.status_code == 200:
content = response.text
if "门诊管理" in content and "门诊列表" in content:
print("✅ 管理员仪表板显示门诊索引页")
else:
print("❌ 管理员仪表板内容不正确")
else:
print(f"❌ 管理员仪表板访问失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 管理员仪表板测试失败: {e}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - 登录重定向测试")
print("=" * 60)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试登录重定向
test_login_redirects()
# 测试仪表板内容
test_dashboard_content()
print("\n🎉 登录重定向测试完成！")
print("📋 总结:")
print(" - 管理员登录后应该到门诊索引页")
print(" - 普通用户登录后应该到患者索引页")
print(" - 不再显示诊所看板页")
\ No newline at end of file
test_new_callback_system.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试新的回访记录系统
验证数据库结构和功能是否正常
"""
from callback_record_model import CallbackRecordManager, CallbackRecord
from datetime import datetime
import json
def test_new_callback_system():
"""测试新的回访记录系统"""
print("🔧 测试新的回访记录系统...")
# 初始化数据库管理器
manager = CallbackRecordManager()
# 测试数据
test_cases = [
{
"case_number": "TEST001",
"callback_methods": ["打电话", "发微信"],
"callback_success": True,
"next_appointment_time": "2025-02-15 10:00",
"failure_reason": None,
"ai_feedback_type": None,
"callback_status": "已回访",
"operator": "测试用户A"
},
{
"case_number": "TEST002",
"callback_methods": ["打电话"],
"callback_success": False,
"next_appointment_time": None,
"failure_reason": "患者电话无人接听",
"ai_feedback_type": "AI生成话术过于专业患者难懂",
"callback_status": "已回访",
"operator": "测试用户B"
},
{
"case_number": "TEST003",
"callback_methods": ["发短信", "视频通话"],
"callback_success": True,
"next_appointment_time": "2025-02-20 14:30",
"failure_reason": None,
"ai_feedback_type": None,
"callback_status": "已回访",
"operator": "测试用户C"
}
]
print("📝 插入测试数据...")
for i, data in enumerate(test_cases, 1):
try:
# 创建回访记录
record = CallbackRecord(
case_number=data["case_number"],
callback_methods=data["callback_methods"],
callback_success=data["callback_success"],
operator=data["operator"],
next_appointment_time=data["next_appointment_time"],
failure_reason=data["failure_reason"],
ai_feedback_type=data["ai_feedback_type"],
callback_status=data["callback_status"]
)
# 保存到数据库
result = manager.save_record(record)
print(f"✅ 测试用例 {i}: {data['case_number']} - 成功保存，ID: {result.record_id}")
except Exception as e:
print(f"❌ 测试用例 {i}: {data['case_number']} - 保存失败: {e}")
print("\n📋 查询所有记录...")
try:
all_records = manager.get_all_records()
print(f"✅ 成功查询到 {len(all_records)} 条记录")
for record in all_records[-3:]: # 显示最后3条记录
print(f" 🔸 ID: {record.record_id}, 患者: {record.case_number}, "
f"成功: {'是' if record.callback_success else '否'}, "
f"状态: {record.callback_status}")
if record.callback_success and record.next_appointment_time:
print(f" 📅 预约时间: {record.next_appointment_time}")
elif not record.callback_success and record.failure_reason:
print(f" ❌ 失败原因: {record.failure_reason}")
if record.ai_feedback_type:
print(f" 🤖 AI反馈: {record.ai_feedback_type}")
except Exception as e:
print(f"❌ 查询记录失败: {e}")
print("\n📊 按患者查询记录...")
for case_num in ["TEST001", "TEST002", "TEST003"]:
try:
patient_records = manager.get_records_by_case_number(case_num)
print(f"✅ {case_num}: {len(patient_records)} 条记录")
except Exception as e:
print(f"❌ {case_num}: 查询失败 - {e}")
print("\n🎯 测试完成！")
def test_api_compatibility():
"""测试API兼容性"""
print("\n🔌 测试API数据格式兼容性...")
manager = CallbackRecordManager()
# 模拟前端API调用的数据格式
api_data = {
"caseNumber": "API_TEST001",
"callbackMethods": ["打电话", "发微信"],
"callbackSuccess": True,
"nextAppointmentTime": "2025-02-25 16:00",
"failureReason": None,
"aiFeedbackType": None,
"callbackStatus": "已回访",
"operator": "API测试用户"
}
try:
result = manager.create_record(api_data)
print(f"✅ API格式数据保存成功: {result}")
except Exception as e:
print(f"❌ API格式数据保存失败: {e}")
if __name__ == "__main__":
test_new_callback_system()
test_api_compatibility()
\ No newline at end of file
test_patient_index_access.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试患者索引页访问
验证登录后访问患者索引页是否正常，不会闪退回登录页
"""
import requests
import time
def test_patient_index_access():
"""测试患者索引页访问"""
base_url = "http://localhost:4003"
print("🧪 测试患者索引页访问...")
print(f"📡 测试地址: {base_url}")
# 测试普通用户登录后访问患者索引页
print("\n1️⃣ 测试普通用户登录后访问患者索引页...")
session = requests.Session()
try:
# 普通用户登录
login_data = {
'username': 'chenlin',
'password': 'chenlin123'
}
response = session.post(f"{base_url}/login", data=login_data, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
print(f"✅ 普通用户登录成功")
print(f"📋 重定向到: {redirect_url}")
# 访问患者索引页
print("\n2️⃣ 访问患者索引页...")
patient_response = session.get(f"{base_url}{redirect_url}")
if patient_response.status_code == 200:
print("✅ 患者索引页访问成功")
content = patient_response.text
if "患者画像" in content or "患者列表" in content:
print("✅ 患者索引页内容正确")
else:
print("⚠️ 患者索引页内容可能有问题")
# 检查是否包含用户信息注入
if "window.userInfo" in content:
print("✅ 用户信息注入成功")
else:
print("⚠️ 用户信息注入可能有问题")
else:
print(f"❌ 患者索引页访问失败，状态码: {patient_response.status_code}")
print(f"📄 响应内容: {patient_response.text[:200]}")
else:
print(f"❌ 普通用户登录失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 普通用户登录测试失败: {e}")
def test_admin_patient_index_access():
"""测试admin访问患者索引页"""
base_url = "http://localhost:4003"
print("\n3️⃣ 测试admin访问患者索引页...")
session = requests.Session()
try:
# admin登录
login_data = {
'username': 'admin',
'password': 'admin123'
}
session.post(f"{base_url}/login", data=login_data)
# 直接访问大丰门诊患者索引页
clinic_url = f"{base_url}/patient_profiles/clinic_dafeng/index.html"
response = session.get(clinic_url)
if response.status_code == 200:
print("✅ admin访问患者索引页成功")
content = response.text
if "患者画像" in content or "患者列表" in content:
print("✅ admin访问的患者索引页内容正确")
else:
print("⚠️ admin访问的患者索引页内容可能有问题")
# 检查是否包含用户信息注入
if "window.userInfo" in content:
print("✅ admin用户信息注入成功")
else:
print("⚠️ admin用户信息注入可能有问题")
else:
print(f"❌ admin访问患者索引页失败，状态码: {response.status_code}")
except Exception as e:
print(f"❌ admin访问患者索引页测试失败: {e}")
def test_unauthorized_access():
"""测试未授权访问"""
base_url = "http://localhost:4003"
print("\n4️⃣ 测试未授权访问...")
# 不登录直接访问患者索引页
session = requests.Session()
try:
clinic_url = f"{base_url}/patient_profiles/clinic_dafeng/index.html"
response = session.get(clinic_url, allow_redirects=False)
if response.status_code == 302:
redirect_url = response.headers.get('Location', '')
if '/login' in redirect_url:
print("✅ 未授权访问正确重定向到登录页")
else:
print(f"❌ 未授权访问重定向错误: {redirect_url}")
else:
print(f"❌ 未授权访问处理错误，状态码: {response.status_code}")
except Exception as e:
print(f"❌ 未授权访问测试失败: {e}")
if __name__ == "__main__":
print("🚀 患者画像回访话术系统 - 患者索引页访问测试")
print("=" * 60)
# 等待服务启动
print("⏳ 等待服务启动...")
time.sleep(2)
# 测试患者索引页访问
test_patient_index_access()
# 测试admin访问患者索引页
test_admin_patient_index_access()
# 测试未授权访问
test_unauthorized_access()
print("\n🎉 患者索引页访问测试完成！")
print("📋 总结:")
print(" - 登录后访问患者索引页应该正常显示")
print(" - 不应该闪退回登录页")
print(" - 未授权访问应该重定向到登录页")
\ No newline at end of file
test_patients_index.html deleted 100644 → 0
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>测试患者画像索引</title>
<script src="https://cdn.tailwindcss.com"></script>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<style>
.patient-card {
transition: all 0.3s ease;
}
.patient-card:hover {
transform: translateY(-4px);
box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
}
</style>
</head>
<body class="bg-gray-50 text-gray-900">
<!-- 页面标题 -->
<header class="bg-gradient-to-r from-purple-600 to-indigo-700 text-white py-12 mb-8">
<div class="container mx-auto px-4 text-center">
<h1 class="text-5xl font-bold mb-4">
<i class="fas fa-vials mr-4"></i>
测试患者画像系统
</h1>
<p class="text-xl text-purple-100">Test Patient Profile System</p>
<p class="text-purple-200 mt-2">用于测试回访记录功能和患者画像展示</p>
</div>
</header>
<main class="container mx-auto px-4 pb-12">
<!-- 系统说明 -->
<div class="bg-white rounded-xl shadow-lg p-6 mb-8">
<div class="flex items-center mb-4">
<i class="fas fa-info-circle text-blue-500 mr-3 text-2xl"></i>
<h2 class="text-2xl font-bold text-gray-800">系统说明</h2>
</div>
<div class="grid grid-cols-1 md:grid-cols-3 gap-6 text-sm">
<div class="bg-blue-50 p-4 rounded-lg">
<div class="font-semibold text-blue-700 mb-2 flex items-center">
<i class="fas fa-flask mr-2"></i>
测试环境
</div>
<div class="text-gray-700">专用于功能测试和演示</div>
</div>
<div class="bg-green-50 p-4 rounded-lg">
<div class="font-semibold text-green-700 mb-2 flex items-center">
<i class="fas fa-database mr-2"></i>
数据库支持
</div>
<div class="text-gray-700">支持SQLite和MySQL双数据库</div>
</div>
<div class="bg-purple-50 p-4 rounded-lg">
<div class="font-semibold text-purple-700 mb-2 flex items-center">
<i class="fas fa-robot mr-2"></i>
AI回访话术
</div>
<div class="text-gray-700">智能生成个性化回访内容</div>
</div>
</div>
</div>
<!-- 测试患者列表 -->
<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
<!-- 测试患者1：张测试 -->
<div class="patient-card bg-white rounded-xl shadow-lg overflow-hidden">
<div class="bg-gradient-to-r from-blue-500 to-blue-600 text-white p-6">
<div class="flex items-center justify-between">
<div>
<h3 class="text-2xl font-bold">张测试</h3>
<p class="text-blue-100">35岁 男性</p>
</div>
<div class="text-4xl opacity-80">
<i class="fas fa-male"></i>
</div>
</div>
</div>
<div class="p-6">
<div class="space-y-3 mb-6">
<div class="flex items-center">
<i class="fas fa-id-card text-gray-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">病历号：</span>
<span class="text-blue-600 font-mono">TEST_PATIENT_001</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-exclamation-triangle text-red-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">漏诊项目：</span>
<span class="text-red-600">缺牙未修复、牙槽骨吸收</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-phone text-green-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">功能：</span>
<span class="text-green-600">完整回访表单</span>
</span>
</div>
</div>
<div class="space-y-2">
<a href="patient_profiles/TEST_PATIENT_001.html"
class="block w-full bg-blue-500 hover:bg-blue-600 text-white text-center py-3 px-4 rounded-lg font-medium transition-colors duration-200">
<i class="fas fa-eye mr-2"></i>
查看完整患者画像
</a>
<div class="text-xs text-gray-500 text-center">
包含：基本信息 + 漏诊信息 + 回访话术 + 记录表单
</div>
</div>
</div>
</div>
<!-- 测试患者2：李测试 -->
<div class="patient-card bg-white rounded-xl shadow-lg overflow-hidden">
<div class="bg-gradient-to-r from-pink-500 to-pink-600 text-white p-6">
<div class="flex items-center justify-between">
<div>
<h3 class="text-2xl font-bold">李测试</h3>
<p class="text-pink-100">28岁 女性</p>
</div>
<div class="text-4xl opacity-80">
<i class="fas fa-female"></i>
</div>
</div>
</div>
<div class="p-6">
<div class="space-y-3 mb-6">
<div class="flex items-center">
<i class="fas fa-id-card text-gray-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">病历号：</span>
<span class="text-pink-600 font-mono">TEST_SIMPLE</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-exclamation-triangle text-red-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">漏诊项目：</span>
<span class="text-red-600">智齿阻生</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-mobile-alt text-green-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">特点：</span>
<span class="text-green-600">简洁版设计</span>
</span>
</div>
</div>
<div class="space-y-2">
<a href="patient_profiles/TEST_SIMPLE.html"
class="block w-full bg-pink-500 hover:bg-pink-600 text-white text-center py-3 px-4 rounded-lg font-medium transition-colors duration-200">
<i class="fas fa-eye mr-2"></i>
查看简洁患者画像
</a>
<div class="text-xs text-gray-500 text-center">
简化版：重点突出回访功能
</div>
</div>
</div>
</div>
<!-- 现有测试患者 -->
<div class="patient-card bg-white rounded-xl shadow-lg overflow-hidden">
<div class="bg-gradient-to-r from-green-500 to-green-600 text-white p-6">
<div class="flex items-center justify-between">
<div>
<h3 class="text-2xl font-bold">Dify测试</h3>
<p class="text-green-100">多患者展示</p>
</div>
<div class="text-4xl opacity-80">
<i class="fas fa-users"></i>
</div>
</div>
</div>
<div class="p-6">
<div class="space-y-3 mb-6">
<div class="flex items-center">
<i class="fas fa-robot text-gray-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">AI平台：</span>
<span class="text-green-600">Dify Agent</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-users text-blue-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">患者数量：</span>
<span class="text-blue-600">3位测试患者</span>
</span>
</div>
<div class="flex items-center">
<i class="fas fa-comments text-purple-400 mr-3"></i>
<span class="text-sm">
<span class="font-medium">功能：</span>
<span class="text-purple-600">回访话术展示</span>
</span>
</div>
</div>
<div class="space-y-2">
<a href="patient_profiles/dify_test_patients.html"
class="block w-full bg-green-500 hover:bg-green-600 text-white text-center py-3 px-4 rounded-lg font-medium transition-colors duration-200">
<i class="fas fa-eye mr-2"></i>
查看Dify测试页面
</a>
<div class="text-xs text-gray-500 text-center">
原有测试页面，包含回访记录表单
</div>
</div>
</div>
</div>
</div>
<!-- 功能说明 -->
<div class="mt-12 bg-white rounded-xl shadow-lg p-6">
<h2 class="text-2xl font-bold text-gray-800 mb-6 flex items-center">
<i class="fas fa-list-check mr-3 text-indigo-600"></i>
功能测试清单
</h2>
<div class="grid grid-cols-1 md:grid-cols-2 gap-6">
<div>
<h3 class="text-lg font-semibold text-gray-700 mb-4 flex items-center">
<i class="fas fa-check-circle mr-2 text-green-500"></i>
已实现功能
</h3>
<ul class="space-y-2 text-sm text-gray-600">
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
患者基本信息展示
</li>
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
漏诊信息显示
</li>
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
AI生成回访话术
</li>
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
回访记录表单
</li>
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
数据库保存功能
</li>
<li class="flex items-center">
<i class="fas fa-check text-green-500 mr-2"></i>
多次记录支持
</li>
</ul>
</div>
<div>
<h3 class="text-lg font-semibold text-gray-700 mb-4 flex items-center">
<i class="fas fa-cog mr-2 text-blue-500"></i>
测试要点
</h3>
<ul class="space-y-2 text-sm text-gray-600">
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
测试回访记录保存功能
</li>
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
验证字符计数和验证
</li>
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
检查回访方式选择
</li>
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
确认数据库记录
</li>
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
测试多次记录功能
</li>
<li class="flex items-center">
<i class="fas fa-arrow-right text-blue-500 mr-2"></i>
验证页面响应式设计
</li>
</ul>
</div>
</div>
</div>
<!-- 快速操作 -->
<div class="mt-8 bg-gradient-to-r from-indigo-50 to-purple-50 rounded-xl p-6 border border-indigo-200">
<h3 class="text-lg font-semibold text-gray-800 mb-4 flex items-center">
<i class="fas fa-rocket mr-2 text-indigo-600"></i>
快速操作
</h3>
<div class="flex flex-wrap gap-3">
<a href="callback_api_server.py" class="bg-indigo-600 hover:bg-indigo-700 text-white px-4 py-2 rounded-lg text-sm font-medium transition-colors">
<i class="fas fa-server mr-2"></i>
启动API服务器
</a>
<a href="patient_profiles/" class="bg-purple-600 hover:bg-purple-700 text-white px-4 py-2 rounded-lg text-sm font-medium transition-colors">
<i class="fas fa-folder mr-2"></i>
查看所有患者画像
</a>
<a href="database_config.py" class="bg-green-600 hover:bg-green-700 text-white px-4 py-2 rounded-lg text-sm font-medium transition-colors">
<i class="fas fa-database mr-2"></i>
配置数据库
</a>
</div>
</div>
</main>
<!-- Footer -->
<footer class="bg-gray-800 text-gray-300 py-8">
<div class="container mx-auto px-4 text-center">
<p class="text-sm mb-2">
<i class="fas fa-flask mr-2"></i>
测试患者画像系统 - 专用于功能测试和演示
</p>
<p class="text-xs text-gray-400">
江苏瑞泰通善口腔医院 | 患者回访管理系统
</p>
</div>
</footer>
<script>
// 添加一些交互效果
document.addEventListener('DOMContentLoaded', function() {
// 卡片悬停效果增强
const cards = document.querySelectorAll('.patient-card');
cards.forEach(card => {
card.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-8px) scale(1.02)';
});
card.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0) scale(1)';
});
});
});
</script>
</body>
</html>
\ No newline at end of file
test_regenerate_clinic.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试重新生成门诊患者索引页
"""
import os
import json
import sys
import shutil
from generate_html import generate_index_html, load_excel_data, merge_patient_data
def test_regenerate_clinic():
"""测试重新生成一个门诊的患者索引页"""
clinic_name = "东亭门诊"
clinic_id = "clinic_dongting"
print(f"🧪 测试重新生成 {clinic_name} 的患者索引页...")
# 加载门诊数据
try:
# 加载Excel数据
excel_file = "合并结果.xlsx"
data = load_excel_data(excel_file)
print(f"✅ 成功加载Excel数据，共 {len(data)} 条记录")
# 合并相同病历号的患者数据
patients_data = merge_patient_data(data)
print(f"✅ 成功合并数据，共 {len(patients_data)} 个患者")
except Exception as e:
print(f"❌ 加载数据失败: {e}")
return False
# 删除现有的患者索引页
output_dir = f"patient_profiles/{clinic_id}"
index_file = f"{output_dir}/index.html"
if os.path.exists(index_file):
print(f"🗑️ 删除现有的患者索引页: {index_file}")
os.remove(index_file)
# 重新生成患者索引页
try:
print(f"🔄 重新生成 {clinic_name} 的患者索引页...")
# 切换到输出目录
original_dir = os.getcwd()
os.chdir("patient_profiles")
# 生成索引页面
generate_index_html(patients_data)
# 返回原目录
os.chdir(original_dir)
print(f"✅ 成功重新生成 {clinic_name} 的患者索引页")
# 检查文件时间戳
if os.path.exists(index_file):
import time
mtime = os.path.getmtime(index_file)
print(f"📅 文件修改时间: {time.ctime(mtime)}")
return True
else:
print(f"❌ 患者索引页文件不存在: {index_file}")
return False
except Exception as e:
print(f"❌ 重新生成失败: {e}")
return False
if __name__ == "__main__":
print("🚀 测试重新生成门诊患者索引页")
print("=" * 50)
success = test_regenerate_clinic()
if success:
print("\n🎉 测试成功！")
print("📋 现在可以测试东亭门诊是否不再闪退了")
else:
print("\n❌ 测试失败！")
\ No newline at end of file
test_regenerate_dongting.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
重新生成东亭门诊患者索引页
"""
import os
import json
import sys
import shutil
import traceback
def load_clinic_data(clinic_name):
"""加载指定门诊数据"""
try:
print(f"🔍 正在检查 {clinic_name} 数据文件...")
json_file = f'诊所患者json/{clinic_name}.json'
print(f"📁 数据文件路径: {json_file}")
if os.path.exists(json_file):
print(f"✅ 数据文件存在，大小: {os.path.getsize(json_file)} 字节")
with open(json_file, 'r', encoding='utf-8') as f:
print(f"📖 正在读取 {clinic_name} 数据文件...")
data = json.load(f)
print(f"✅ 成功加载 {clinic_name} 数据: {len(data)} 条记录")
return data
else:
print(f"❌ 未找到 {clinic_name} 数据文件: {json_file}")
return []
except Exception as e:
print(f"❌ 加载 {clinic_name} 数据失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return []
def regenerate_dongting_index():
"""重新生成东亭门诊患者索引页"""
clinic_name = "东亭门诊"
clinic_id = "clinic_dongting"
print(f"🧪 重新生成 {clinic_name} 患者索引页...")
# 加载数据
print(f"📊 步骤1: 加载 {clinic_name} 数据...")
data = load_clinic_data(clinic_name)
if not data:
print(f"❌ 无法加载 {clinic_name} 数据")
return False
# 合并患者数据
print(f"📊 步骤2: 合并 {clinic_name} 患者数据...")
try:
from generate_html import merge_patient_data
patients_data = merge_patient_data(data)
print(f"📊 合并后患者数量: {len(patients_data)}")
except Exception as e:
print(f"❌ 合并 {clinic_name} 患者数据失败: {e}")
return False
# 删除现有的患者索引页
index_file = f"patient_profiles/{clinic_id}/index.html"
if os.path.exists(index_file):
print(f"🗑️ 删除现有的患者索引页: {index_file}")
os.remove(index_file)
# 重新生成患者索引页
try:
print(f"🔄 步骤3: 重新生成 {clinic_name} 患者索引页...")
# 确保目标目录存在
os.makedirs(f"patient_profiles/{clinic_id}", exist_ok=True)
# 生成索引页面到目标位置
from generate_html import generate_index_html
generate_index_html(patients_data, index_file)
# 检查文件时间戳
if os.path.exists(index_file):
import time
mtime = os.path.getmtime(index_file)
print(f"📅 文件修改时间: {time.ctime(mtime)}")
print(f"✅ 成功重新生成 {clinic_name} 患者索引页")
return True
else:
print(f"❌ 患者索引页文件不存在: {index_file}")
return False
except Exception as e:
print(f"❌ 重新生成失败: {e}")
print(f"🔍 详细错误信息: {traceback.format_exc()}")
return False
if __name__ == "__main__":
print("🚀 重新生成东亭门诊患者索引页")
print("=" * 50)
success = regenerate_dongting_index()
if success:
print("\n🎉 重新生成成功！")
print("📋 现在可以测试东亭门诊是否不再闪退了")
else:
print("\n❌ 重新生成失败！")
\ No newline at end of file
test_server.html deleted 100644 → 0
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>服务器测试</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 0 auto;
padding: 20px;
background-color: #f5f5f5;
}
.container {
background: white;
padding: 30px;
border-radius: 10px;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
h1 { color: #333; }
.status { padding: 10px; margin: 10px 0; border-radius: 5px; }
.success { background: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
.error { background: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
.info { background: #d1ecf1; color: #0c5460; border: 1px solid #bee5eb; }
button {
background: #007bff;
color: white;
border: none;
padding: 10px 20px;
border-radius: 5px;
cursor: pointer;
margin: 5px;
}
button:hover { background: #0056b3; }
.test-results { margin-top: 20px; }
pre { background: #f8f9fa; padding: 15px; border-radius: 5px; overflow-x: auto; }
</style>
</head>
<body>
<div class="container">
<h1>🔧 服务器连接测试</h1>
<div class="status info">
<strong>测试说明：</strong>
<ul>
<li>服务器地址：http://localhost:8080</li>
<li>点击下方按钮测试各个功能</li>
<li>如果看到这个页面，说明服务器基本功能正常</li>
</ul>
</div>
<h2>🧪 功能测试</h2>
<button onclick="testHealth()">测试健康检查</button>
<button onclick="testLogin()">测试登录功能</button>
<button onclick="testRedirect()">测试重定向</button>
<button onclick="testStaticFiles()">测试静态文件</button>
<div class="test-results" id="results"></div>
<h2>📱 快速导航</h2>
<button onclick="goToLogin()">前往登录页面</button>
<button onclick="goToPatientProfiles()">前往患者画像</button>
<button onclick="goToDashboard()">前往仪表盘</button>
</div>
<script>
const baseUrl = 'http://localhost:8080';
function showResult(title, success, message, data = null) {
const results = document.getElementById('results');
const statusClass = success ? 'success' : 'error';
const statusIcon = success ? '✅' : '❌';
let html = `
<div class="status ${statusClass}">
<h3>${statusIcon} ${title}</h3>
<p>${message}</p>
`;
if (data) {
html += `<pre>${JSON.stringify(data, null, 2)}</pre>`;
}
html += '</div>';
results.innerHTML = html + results.innerHTML;
}
async function testHealth() {
try {
const response = await fetch(`${baseUrl}/api/health`);
const data = await response.json();
if (response.ok) {
showResult('健康检查', true, `服务器状态：${data.status}`, data);
} else {
showResult('健康检查', false, `HTTP ${response.status}`, data);
}
} catch (error) {
showResult('健康检查', false, `请求失败：${error.message}`);
}
}
async function testLogin() {
try {
const response = await fetch(`${baseUrl}/api/auth/login`, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
username: 'admin',
password: 'admin123'
})
});
const data = await response.json();
if (response.ok && data.success) {
showResult('登录测试', true, `登录成功，用户：${data.user.username}`, data);
} else {
showResult('登录测试', false, data.message || '登录失败', data);
}
} catch (error) {
showResult('登录测试', false, `请求失败：${error.message}`);
}
}
async function testRedirect() {
try {
const response = await fetch(`${baseUrl}/`, {
method: 'GET',
redirect: 'manual'
});
if (response.status === 302) {
const location = response.headers.get('Location');
showResult('重定向测试', true, `正确重定向到：${location}`);
} else {
showResult('重定向测试', false, `意外的状态码：${response.status}`);
}
} catch (error) {
showResult('重定向测试', false, `请求失败：${error.message}`);
}
}
async function testStaticFiles() {
try {
const response = await fetch(`${baseUrl}/auth_client.js`);
if (response.ok) {
const content = await response.text();
const isJavaScript = content.includes('AuthClient') || content.includes('function');
if (isJavaScript) {
showResult('静态文件测试', true, 'JavaScript文件加载成功');
} else {
showResult('静态文件测试', false, '文件内容不正确');
}
} else {
showResult('静态文件测试', false, `HTTP ${response.status}`);
}
} catch (error) {
showResult('静态文件测试', false, `请求失败：${error.message}`);
}
}
function goToLogin() {
window.open(`${baseUrl}/login`, '_blank');
}
function goToPatientProfiles() {
window.open(`${baseUrl}/patient_profiles/`, '_blank');
}
function goToDashboard() {
window.open(`${baseUrl}/dashboard.html`, '_blank');
}
// 页面加载时自动测试健康检查
window.addEventListener('load', function() {
setTimeout(testHealth, 1000);
});
</script>
</body>
</html>
\ No newline at end of file
test_single_patient.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试生成单个患者的详情页
"""
import json
import os
from generate_html import generate_html, merge_patient_data, load_oral_callback_data
def test_single_patient():
"""测试生成单个患者的详情页"""
# 加载大丰门诊数据
with open('诊所患者json/大丰门诊.json', 'r', encoding='utf-8') as f:
clinic_data = json.load(f)
# 合并患者数据
patients_data = merge_patient_data(clinic_data)
# 选择特定患者
patient_id = 'TS0G040927'
if patient_id in patients_data:
print(f"找到患者 {patient_id}，开始生成详情页...")
# 测试回访话术数据加载
print("测试回访话术数据加载...")
oral_callback_data = load_oral_callback_data('大丰门诊')
print(f"加载的回访话术数据数量: {len(oral_callback_data)}")
# 检查特定患者的数据
patient_callback_data = oral_callback_data.get(patient_id)
if patient_callback_data:
print(f"找到患者 {patient_id} 的回访话术数据")
print(f" 患者姓名: {patient_callback_data.get('patient_name')}")
print(f" 回访类型: {patient_callback_data.get('callback_type')}")
else:
print(f"未找到患者 {patient_id} 的回访话术数据")
print(f"可用的患者ID前5个: {list(oral_callback_data.keys())[:5]}")
# 切换到输出目录
output_dir = f"patient_profiles/clinic_dafeng/patients"
os.makedirs(output_dir, exist_ok=True)
os.chdir(output_dir)
# 生成患者详情页
generate_html(patient_id, patients_data[patient_id], '大丰门诊')
print(f"患者 {patient_id} 的详情页生成完成！")
else:
print(f"未找到患者 {patient_id}")
if __name__ == "__main__":
test_single_patient()
\ No newline at end of file
test_user_info.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试用户信息接口
"""
import requests
import json
def test_user_info(session_id):
"""测试用户信息接口"""
url = "http://localhost:5000/api/user-info"
headers = {
'X-Session-ID': session_id
}
try:
response = requests.get(url, headers=headers)
result = response.json()
print(f"响应状态: {response.status_code}")
print(f"响应内容: {json.dumps(result, ensure_ascii=False, indent=2)}")
return result.get('success', False)
except Exception as e:
print(f"测试失败: {e}")
return False
def main():
"""主函数"""
print("=== 测试用户信息接口 ===")
# 先登录获取session_id
login_url = "http://localhost:5000/api/auth/login"
login_data = {
"username": "admin",
"password": "admin123"
}
try:
response = requests.post(login_url, json=login_data)
result = response.json()
if result.get('success'):
session_id = result.get('session_id')
print(f"登录成功，session_id: {session_id[:20]}...")
# 测试用户信息接口
print("\n测试用户信息接口:")
success = test_user_info(session_id)
if success:
print("\n✅ 用户信息接口测试成功！")
else:
print("\n❌ 用户信息接口测试失败！")
else:
print("登录失败，无法测试用户信息接口")
except Exception as e:
print(f"测试失败: {e}")
if __name__ == "__main__":
main()
\ No newline at end of file
update_all_index_dynamic_status.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量更新所有索引页面的动态状态更新功能
"""
import os
import re
import glob
ROOT = os.path.dirname(os.path.abspath(__file__))
PATIENT_PROFILES_DIR = os.path.join(ROOT, 'patient_profiles')
def update_index_dynamic_status(file_path):
"""更新索引页面的动态状态更新功能"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已经是最新版本
if 'bg-green-100, .bg-red-100' in content and 'data-callback-success' in content:
return False
# 查找并替换旧的动态状态更新代码
old_pattern = r'<script>\s*// 动态更新回访状态\s*async function updateCallbackStatus\(\) \{.*?\}\s*// 页面加载时更新状态\s*document\.addEventListener\(\'DOMContentLoaded\', updateCallbackStatus\);\s*// 每30秒更新一次状态\s*setInterval\(updateCallbackStatus, 30000\);\s*</script>'
new_script = '''
<script>
// 动态更新回访状态
async function updateCallbackStatus() {
try {
const clinicId = window.location.pathname.split('/')[2]; // 从URL获取门诊ID
const apiBase = window.API_BASE_URL || '';
const response = await fetch(`${apiBase}/api/callback-status/${clinicId}`);
const data = await response.json();
if (data.success && data.data) {
const statusMap = {};
data.data.forEach(item => {
statusMap[item.case_number] = item;
});
// 更新页面中的回访状态
document.querySelectorAll('.patient-card').forEach(card => {
const caseNumber = card.getAttribute('data-id');
const statusElement = card.querySelector('.bg-gray-100, .bg-green-100, .bg-red-100');
if (caseNumber && statusElement && statusMap[caseNumber]) {
const status = statusMap[caseNumber];
const isSuccess = status.callback_result === '成功';
// 更新data属性（用于筛选）
card.setAttribute('data-callback-status', status.callback_status);
card.setAttribute('data-callback-success', status.callback_result);
// 更新显示
if (status.callback_status === '已回访') {
statusElement.className = isSuccess ?
'bg-green-100 text-green-800 text-xs font-medium px-2.5 py-0.5 rounded-full' :
'bg-red-100 text-red-800 text-xs font-medium px-2.5 py-0.5 rounded-full';
statusElement.innerHTML = `<i class="fas fa-phone mr-1"></i>${status.callback_result}`;
} else {
// 未回访状态
statusElement.className = 'bg-gray-100 text-gray-800 text-xs font-medium px-2.5 py-0.5 rounded-full';
statusElement.innerHTML = `<i class="fas fa-phone mr-1"></i>未回访`;
}
}
});
// 重新应用筛选（如果当前有筛选条件）
const activeFilters = document.querySelector('#callbackStatusFilter').value ||
document.querySelector('#callbackSuccessFilter').value;
if (activeFilters) {
// 触发筛选事件
const event = new Event('change');
document.querySelector('#callbackStatusFilter').dispatchEvent(event);
document.querySelector('#callbackSuccessFilter').dispatchEvent(event);
}
}
} catch (error) {
console.error('更新回访状态失败:', error);
}
}
// 页面加载时更新状态
document.addEventListener('DOMContentLoaded', updateCallbackStatus);
// 每30秒更新一次状态
setInterval(updateCallbackStatus, 30000);
</script>'''
# 替换旧的脚本
new_content, count = re.subn(old_pattern, new_script, content, flags=re.DOTALL)
if count > 0:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
return False
except Exception as e:
print(f"更新文件失败 {file_path}: {e}")
return False
def main():
"""主函数"""
pattern = os.path.join(PATIENT_PROFILES_DIR, '*/index.html')
index_files = glob.glob(pattern)
print(f"找到 {len(index_files)} 个索引文件")
updated_count = 0
skipped_count = 0
for file_path in index_files:
try:
if update_index_dynamic_status(file_path):
updated_count += 1
print(f"✅ 已更新: {os.path.basename(file_path)}")
else:
skipped_count += 1
print(f"⏭️ 已跳过: {os.path.basename(file_path)}")
except Exception as e:
print(f"❌ 处理失败 {file_path}: {e}")
print(f"\n更新完成:")
print(f"- 更新的文件: {updated_count}")
print(f"- 跳过的文件: {skipped_count}")
print(f"- 总文件数: {len(index_files)}")
if __name__ == '__main__':
main()
\ No newline at end of file
update_all_patients.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量更新所有患者页面，应用新的回访记录显示逻辑
"""
import json
import os
import shutil
from collections import defaultdict
from generate_html import generate_html
def update_all_patients():
"""批量更新所有患者页面"""
print("🚀 批量更新所有患者页面...")
print("📋 应用新的回访记录显示逻辑（始终显示新建表单）")
print("-" * 50)
# 加载患者数据
print("📖 加载患者数据...")
with open('合并结果.json', encoding='utf-8') as f:
data = json.load(f)
# 按病历号分组患者记录
patients_dict = defaultdict(list)
for record in data:
case_number = record.get('病历号')
if case_number:
patients_dict[case_number].append(record)
print(f"✅ 共找到 {len(patients_dict)} 个患者")
# 确保patient_profiles目录存在
if not os.path.exists('patient_profiles'):
os.makedirs('patient_profiles')
print("📁 创建patient_profiles目录")
# 批量生成患者页面
success_count = 0
error_count = 0
for i, (case_number, records) in enumerate(patients_dict.items(), 1):
try:
print(f"🔄 ({i}/{len(patients_dict)}) 生成 {case_number}...", end=" ")
# 生成HTML页面
generate_html(case_number, records)
# 检查文件是否生成在根目录
root_file = f"{case_number}.html"
target_file = f"patient_profiles/{case_number}.html"
if os.path.exists(root_file):
# 移动到正确位置
if os.path.exists(target_file):
os.remove(target_file) # 删除旧文件
shutil.move(root_file, target_file)
if os.path.exists(target_file):
file_size = os.path.getsize(target_file)
print(f"✅ ({file_size} bytes)")
success_count += 1
else:
print("❌ 文件未生成")
error_count += 1
except Exception as e:
print(f"❌ 错误: {e}")
error_count += 1
print("-" * 50)
print(f"🎉 批量更新完成!")
print(f"✅ 成功: {success_count} 个患者")
print(f"❌ 失败: {error_count} 个患者")
print(f"📊 成功率: {success_count/(success_count+error_count)*100:.1f}%")
if error_count > 0:
print("⚠️ 如有失败，可能是由于数据问题或网络原因")
if __name__ == "__main__":
update_all_patients()
\ No newline at end of file
update_callback_script_style.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新患者详情页的回访话术样式
参考图片样式：柔和色彩，简洁布局
"""
import os
import json
import glob
import re
from datetime import datetime
def load_clinic_scripts(clinic_name):
"""加载指定门诊的话术数据"""
pattern = f"dify_callback_results/中间结果_{clinic_name}_*.json"
files = glob.glob(pattern)
if not files:
print(f"❌ 未找到 {clinic_name} 的话术文件")
return None
latest_file = max(files, key=os.path.getctime)
print(f"📁 使用文件: {latest_file}")
try:
with open(latest_file, 'r', encoding='utf-8') as f:
data = json.load(f)
return data
except Exception as e:
print(f"❌ 读取文件失败: {e}")
return None
def extract_selected_diagnosis(callback_script):
"""从话术中提取selected_diagnosis"""
try:
json_match = re.search(r'```json\s*(\{.*?\})\s*```', callback_script, re.DOTALL)
if json_match:
json_str = json_match.group(1)
json_data = json.loads(json_str)
return json_data.get('selected_diagnosis', '')
except:
pass
return ''
def parse_callback_script(callback_script):
"""解析回访话术内容，提取四个部分"""
parts = {
'part1': '', # 开场白
'part2': '', # 告知漏诊项目
'part3': '', # 复查建议
'part4': '' # 结束回访语
}
# 使用正则表达式分割内容
sections = re.split(r'═══\s*第[一二三四]部分[：:]\s*([^═]+)\s*═══', callback_script)
if len(sections) >= 9: # 应该有9个部分（4个标题+4个内容+开头）
parts['part1'] = sections[2].strip() if len(sections) > 2 else ''
parts['part2'] = sections[4].strip() if len(sections) > 4 else ''
parts['part3'] = sections[6].strip() if len(sections) > 6 else ''
parts['part4'] = sections[8].strip() if len(sections) > 8 else ''
return parts
def generate_clean_callback_html(patient_name, diagnosis, callback_script):
"""生成简洁优雅的回访话术HTML，参考图片样式"""
parts = parse_callback_script(callback_script)
# 提取JSON中的selected_diagnosis
selected_diagnosis = extract_selected_diagnosis(callback_script)
html = f'''
<!-- 简洁优雅的回访话术样式 -->
<div class="callback-sections">
<div class="callback-script-content">
<!-- 患者信息概览 -->
<div class="mb-6 flex justify-between items-center bg-gray-50 p-4 rounded-lg">
<div class="flex items-center">
<span class="font-medium text-gray-700 mr-4">优先诊断:</span>
<span class="text-blue-600 font-semibold">{diagnosis or selected_diagnosis}</span>
</div>
<div class="text-sm text-gray-500">
生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
</div>
</div>
<!-- 四个模块的回访话术 -->
<div class="space-y-4">
<!-- 第一部分：开场白 -->
<div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
<div class="bg-blue-50 px-4 py-3 border-b border-gray-200">
<div class="flex items-center">
<span class="text-blue-600 mr-2">💬</span>
<h4 class="text-gray-800 font-medium">第一部分: 开场白</h4>
</div>
</div>
<div class="p-4">
<ul class="space-y-2">
{format_bullet_points_clean(parts['part1'], 'blue')}
</ul>
</div>
</div>
<!-- 第二部分：告知漏诊项目 -->
<div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
<div class="bg-yellow-50 px-4 py-3 border-b border-gray-200">
<div class="flex items-center">
<span class="text-yellow-600 mr-2">⚠️</span>
<h4 class="text-gray-800 font-medium">第二部分: 告知漏诊项目</h4>
</div>
</div>
<div class="p-4">
<ul class="space-y-2">
{format_bullet_points_clean(parts['part2'], 'gray')}
</ul>
</div>
</div>
<!-- 第三部分：复查建议 -->
<div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
<div class="bg-green-50 px-4 py-3 border-b border-gray-200">
<div class="flex items-center">
<span class="text-green-600 mr-2">✅</span>
<h4 class="text-gray-800 font-medium">第三部分: 复查建议</h4>
</div>
</div>
<div class="p-4">
<ul class="space-y-2">
{format_bullet_points_clean(parts['part3'], 'gray')}
</ul>
</div>
</div>
<!-- 第四部分：结束回访语 -->
<div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
<div class="bg-purple-50 px-4 py-3 border-b border-gray-200">
<div class="flex items-center">
<span class="text-purple-600 mr-2">✅</span>
<h4 class="text-gray-800 font-medium">第四部分: 结束回访语</h4>
</div>
</div>
<div class="p-4">
<ul class="space-y-2">
{format_bullet_points_clean(parts['part4'], 'gray')}
</ul>
</div>
</div>
</div>
<!-- 使用提示 -->
<div class="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
<p class="text-sm text-blue-700">
<i class="fas fa-info-circle mr-2"></i>
<strong>使用提示：</strong>此话术为Dify AI智能生成，请根据实际情况灵活调整使用。建议按照四个模块的顺序进行回访。
</p>
</div>
</div>
</div>
'''
return html
def format_bullet_points_clean(text, color='gray'):
"""格式化文本为简洁的HTML列表项"""
if not text:
return '<li class="text-gray-400 italic">内容待补充</li>'
# 分割文本为行
lines = text.strip().split('\n')
formatted_lines = []
for line in lines:
line = line.strip()
if line.startswith('•'):
# 移除•符号并格式化
content = line[1:].strip()
if color == 'blue':
formatted_lines.append(f'<li class="text-gray-800"><span class="inline-block w-2 h-2 bg-blue-500 rounded-full mr-2"></span>{content}</li>')
else:
formatted_lines.append(f'<li class="text-gray-800"><span class="inline-block w-2 h-2 bg-gray-400 rounded-full mr-2"></span>{content}</li>')
elif line.startswith('**') and line.endswith('**'):
# 粗体标题
content = line[2:-2]
formatted_lines.append(f'<li class="font-bold text-gray-800 mt-3 mb-2">{content}</li>')
elif line:
# 普通文本
formatted_lines.append(f'<li class="text-gray-800">{line}</li>')
if formatted_lines:
return '\n'.join(formatted_lines)
else:
return f'<li class="text-gray-800">{text}</li>'
def update_patient_callback_style(patient_id, diagnosis, clinic_folder):
"""更新患者详情页的回访话术样式"""
patient_page_path = f"patient_profiles/{clinic_folder}/patients/{patient_id}.html"
if not os.path.exists(patient_page_path):
return False
try:
with open(patient_page_path, 'r', encoding='utf-8') as f:
content = f.read()
# 查找现有的回访话术内容
callback_pattern = r'(<!-- 结构化回访话术内容 -->\s*<div class="callback-sections">.*?</div>\s*</div>\s*</div>\s*</div>)'
# 从话术数据中获取完整的话术内容
scripts_data = load_clinic_scripts(clinic_name_mapping.get(clinic_folder, ''))
if not scripts_data:
return False
callbacks = scripts_data.get('callbacks', [])
callback_script = ''
patient_name = '待更新'
for callback in callbacks:
if callback.get('patient_id') == patient_id:
callback_script = callback.get('callback_script', '')
patient_name = callback.get('patient_name', '待更新')
break
if callback_script:
# 生成新的简洁HTML
new_callback_html = generate_clean_callback_html(patient_name, diagnosis, callback_script)
# 替换现有的回访话术内容
new_content = re.sub(callback_pattern, new_callback_html, content, flags=re.DOTALL)
with open(patient_page_path, 'w', encoding='utf-8') as f:
f.write(new_content)
print(f"✅ 已更新患者 {patient_id} 的回访话术样式")
return True
else:
print(f"⚠️ 未找到患者 {patient_id} 的话术数据")
return False
except Exception as e:
print(f"❌ 更新患者详情页面失败 {patient_id}: {e}")
return False
def process_clinic_callback_style(clinic_name, clinic_folder):
"""处理指定门诊的回访话术样式更新"""
print(f"\n🏥 处理 {clinic_name} 的回访话术样式...")
scripts_data = load_clinic_scripts(clinic_name)
if not scripts_data:
return
callbacks = scripts_data.get('callbacks', [])
print(f"📊 找到 {len(callbacks)} 条话术数据")
success_count = 0
for callback in callbacks:
patient_id = callback.get('patient_id')
callback_script = callback.get('callback_script', '')
if patient_id and callback_script:
diagnosis = extract_selected_diagnosis(callback_script)
if diagnosis:
if update_patient_callback_style(patient_id, diagnosis, clinic_folder):
success_count += 1
print(f"✅ {clinic_name} 处理完成: {success_count}/{len(callbacks)} 个患者话术样式已更新")
# 门诊名称映射
clinic_name_mapping = {
"clinic_dafeng": "大丰门诊",
"clinic_dongting": "东亭门诊",
"clinic_huishan": "惠山门诊",
"clinic_xinwu": "新吴门诊",
"clinic_helai": "河埒门诊",
"clinic_hongdou": "红豆门诊",
"clinic_mashan": "马山门诊",
"clinic_hospital": "通善口腔医院"
}
def main():
"""主函数"""
print("🎨 开始更新回访话术样式（简洁优雅版）")
print("=" * 60)
clinics = [
{"name": "大丰门诊", "folder": "clinic_dafeng"},
{"name": "东亭门诊", "folder": "clinic_dongting"},
{"name": "惠山门诊", "folder": "clinic_huishan"},
{"name": "新吴门诊", "folder": "clinic_xinwu"},
{"name": "河埒门诊", "folder": "clinic_helai"},
{"name": "红豆门诊", "folder": "clinic_hongdou"},
{"name": "马山门诊", "folder": "clinic_mashan"},
{"name": "通善口腔医院", "folder": "clinic_hospital"}
]
for clinic in clinics:
try:
process_clinic_callback_style(clinic["name"], clinic["folder"])
except Exception as e:
print(f"❌ 处理 {clinic['name']} 失败: {e}")
print(f"\n🎉 回访话术样式更新完成！")
print("=" * 60)
print("📋 更新内容:")
print(" ✅ 简洁优雅的卡片设计")
print(" ✅ 柔和的色彩搭配")
print(" ✅ 清晰的视觉层次")
print(" ✅ 现代化的界面风格")
if __name__ == "__main__":
main()
\ No newline at end of file
update_callback_scripts.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新患者画像中的回访话术
将重新生成的回访话术填充到对应的患者页面中
"""
import os
import json
import re
from datetime import datetime
class CallbackScriptUpdater:
"""回访话术更新器"""
def __init__(self):
"""初始化"""
self.regenerated_scripts = {
"TS0F028745": {
"patient_name": "庹伟",
"clinic": "东亭门诊",
"script": """```json
{
"selected_diagnosis": "牙槽骨吸收"
}
```
═══ 第一部分：开场白 ═══
• 您好，我是瑞泰通善口腔的护士小王。
• 您好，董明月医生特意交代我来关注您的后续情况。
• 您自从2月13号检查后，口腔情况怎么样？
═══ 第二部分：告知漏诊项目 ═══
• 上次来检查的时候，董明月医生注意到您有牙槽骨吸收的情况。
• 这个问题如果一直拖着，可能会出现牙齿松动、牙缝变大的情况，而且如果放着不管，牙齿还有脱落的风险，到时候想修复就更麻烦了。
• 趁现在问题还不严重，早点稳住会更好。
• 这个情况，董明月医生也特别嘱咐我们提醒您一下。
═══ 第三部分：复查建议 ═══
• 如果方便的话您看最近有没有时间来院复查一下。
• 让董明月医生帮您再仔细看看。
• 复查检查约30-45分钟，需要仔细检查牙周健康状况。
• 董明月医生【时间段1】和【时间段2】这两个时间段有空，您看哪个时间比较方便？
═══ 第四部分：结束回访语 ═══
预约成功：
• 好的，那我们【具体预约时间】见。
• 那不打扰您了，祝您生活愉快。
预约不成功：
• 好的，那我下个星期再跟您联系。
• 好的那不打扰您了，祝您生活愉快。""",
"generation_time": "2025-08-07 09:32:39"
},
"TS0G040130": {
"patient_name": "徐中华",
"clinic": "大丰门诊",
"script": """```json
{
"selected_diagnosis": "牙槽骨吸收"
}
```
═══ 第一部分：开场白 ═══
• 您好，我是瑞泰通善口腔的护士小茅。
• 您好。
• 茅晓春医生特意交代我来关注您的后续情况。
• 您自从5月26号检查后，口腔情况怎么样？
═══ 第二部分：告知漏诊项目 ═══
• 上次来检查的时候，茅晓春医生注意到您有牙槽骨吸收的情况。
• 这个问题如果一直拖着，可能会出现牙齿松动、牙缝变大的情况，吃东西也不太舒服。
• 而且如果放着不管，牙齿还有脱落的风险，到时候想修复就更麻烦了。
• 这个情况，茅晓春医生也特别嘱咐我们提醒您一下。
═══ 第三部分：复查建议 ═══
• 如果方便的话您看最近有没有时间来院复查一下。
• 让茅晓春医生帮您再仔细看看。
• 复查检查约30-45分钟，需要仔细检查牙周健康状况。
• 茅晓春医生【时间段1】和【时间段2】这两个时间段有空，您看哪个时间比较方便？
═══ 第四部分：结束回访语 ═══
预约成功：
• 好的，那我们【具体预约时间】见。
• 那不打扰您了，祝您生活愉快。
预约不成功：
• 好的，那我下个星期再跟您联系。
• 好的那不打扰您了，祝您生活愉快。""",
"generation_time": "2025-08-07 09:33:06"
},
"TS0L003744": {
"patient_name": "李燕军",
"clinic": "新吴门诊",
"script": """```json
{
"selected_diagnosis": "牙槽骨吸收"
}
```
═══ 第一部分：开场白 ═══
• 您好，我是瑞泰通善口腔的医生助理小王。
• 王梓医生特意交代我来关注您的后续情况。
• 您自从12月28号检查后，口腔情况怎么样？
═══ 第二部分：告知漏诊项目 ═══
• 上次来检查的时候，王梓医生注意到您有牙槽骨吸收的情况。
• 这个问题如果一直拖着，可能会出现牙齿松动、牙缝变大的情况，时间久了还有脱落的风险。
• 趁现在问题还不严重，早点稳住会更好。
• 这个情况，王梓医生也特别嘱咐我们提醒您一下。
═══ 第三部分：复查建议 ═══
• 如果方便的话您看最近有没有时间来院复查一下。
• 让王梓医生帮您再仔细看看。
• 复查检查约30-45分钟，需要仔细检查牙周健康状况。
• 王梓医生【时间段1】和【时间段2】这两个时间段有空，您看哪个时间比较方便？
═══ 第四部分：结束回访语 ═══
[预约成功]
• 好的，那我们【具体预约时间】见。
• 那不打扰您了，祝您生活愉快。
[预约不成功]
• 好的，那我下个星期再跟您联系。
• 好的那不打扰您了，祝您生活愉快。
═══ 附加：赠送礼品（见机行事）═══
• 我们为回访患者准备了小礼品。
• 到时候来检查可以领取。
• 表示我们对您的感谢。""",
"generation_time": "2025-08-07 09:33:43"
},
"TS0K083350": {
"patient_name": "刘爱军",
"clinic": "通善口腔医院",
"script": """```json
{
"selected_diagnosis": "牙槽骨吸收"
}
```
═══ 第一部分：开场白 ═══
• 您好，我是江苏瑞泰通善口腔医院的护士长小王。
• 您好，张琪医生特意交代我来关注您的后续情况。
• 您自从5月17号检查后，口腔情况怎么样？
═══ 第二部分：告知漏诊项目 ═══
• 上次来检查的时候，张琪医生注意到您有牙槽骨吸收的情况。
• 这个问题如果拖着，牙齿容易慢慢松动，牙缝也可能变大，影响吃东西。而且时间长了，牙齿还有脱落的风险，到时候想修复就更麻烦了。
• 趁现在问题还不算严重，早一点关注，对稳定牙齿有很大帮助。
• 这个情况，张琪医生也特别嘱咐我们一定要提醒您一下。
═══ 第三部分：复查建议 ═══
• 如果方便的话您看最近有没有时间来院复查一下。
• 让张琪医生帮您再仔细看看现在的情况。
• 复查检查约30-45分钟，需要仔细检查牙周健康状况。
• 张琪医生【时间段1】和【时间段2】这两个时间段有空，您看哪个时间比较方便？
═══ 第四部分：结束回访语 ═══
**预约成功：**
• 好的，那我们【具体预约时间】见。
• 那不打扰您了，祝您生活愉快。
**预约不成功：**
• 好的，那我下个星期再跟您联系。
• 好的那不打扰您了，祝您生活愉快。""",
"generation_time": "2025-08-07 09:34:15"
},
"TS0M004718": {
"patient_name": "杨建荣ZZ00566",
"clinic": "学前街门诊",
"script": """```json
{
"selected_diagnosis": "缺失牙"
}
```
═══ 第一部分：开场白 ═══
• 您好，我是瑞泰通善口腔的护士小王。
• 您好。
• 孙红胜医生特意交代我来关注您的后续情况。
• 您自从3月25号检查后，口腔情况怎么样？
═══ 第二部分：告知漏诊项目 ═══
• 上次来检查的时候，孙红胜医生注意到您有缺失牙的情况。
• 缺牙的地方如果不处理，旁边的牙齿可能会慢慢歪掉，对面的牙齿也可能伸长出来，时间长了吃东西会不太舒服。
• 而且如果放着不管，牙槽骨还可能慢慢萎缩，到时候想修复就更麻烦了。
• 趁现在身体还好，早一点处理，比以后复杂时省事也省心。
• 这个情况，孙红胜医生也特别嘱咐我们提醒您一下。
═══ 第三部分：复查建议 ═══
• 如果方便的话您看最近有没有时间来院复查一下。
• 让孙红胜医生帮您再仔细看看。
• 复查检查约30分钟，了解缺失牙位目前状况。
• 孙红胜医生【时间段1】和【时间段2】这两个时间段有空，您看哪个时间比较方便？
═══ 第四部分：结束回访语 ═══
**预约成功：**
• 好的，那我们【具体预约时间】见。
• 那不打扰您了，祝您生活愉快。
**预约不成功：**
• 好的，那我下个星期再跟您联系。
• 好的那不打扰您了，祝您生活愉快。""",
"generation_time": "2025-08-07 09:34:48"
}
}
def update_patient_callback_script(self, patient_id, script_data):
"""更新单个患者的回访话术"""
# 根据患者ID确定诊所目录
clinic_mapping = {
"TS0F028745": "clinic_dongting",
"TS0G040130": "clinic_dafeng",
"TS0L003744": "clinic_xinwu",
"TS0K083350": "clinic_hospital",
"TS0M004718": "clinic_xuexian"
}
clinic_dir = clinic_mapping.get(patient_id)
if not clinic_dir:
print(f"❌ 未找到患者 {patient_id} 对应的诊所目录")
return False
patient_file = f"patient_profiles/{clinic_dir}/patients/{patient_id}.html"
if not os.path.exists(patient_file):
print(f"❌ 未找到患者文件: {patient_file}")
return False
try:
# 读取患者页面
with open(patient_file, 'r', encoding='utf-8') as f:
content = f.read()
# 更新生成时间
content = re.sub(
r'<span class="text-gray-800">\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}</span>',
f'<span class="text-gray-800">{script_data["generation_time"]}</span>',
content
)
# 更新回访话术内容
# 找到回访话术内容区域
script_pattern = r'(<div class="callback-sections">\s*)(.*?)(\s*</div>)'
# 构建新的回访话术HTML
new_script_html = f"""
<div class="callback-script-content">
<div class="bg-gray-50 p-4 rounded-lg mb-4">
<h4 class="font-medium text-gray-800 mb-3">AI生成的回访话术</h4>
<div class="text-sm text-gray-700 leading-relaxed whitespace-pre-line">
{script_data["script"]}
</div>
</div>
</div>
"""
# 替换回访话术内容
content = re.sub(
script_pattern,
r'\1' + new_script_html + r'\3',
content,
flags=re.DOTALL
)
# 写回文件
with open(patient_file, 'w', encoding='utf-8') as f:
f.write(content)
print(f"✅ 已更新患者 {script_data['patient_name']} ({patient_id}) 的回访话术")
return True
except Exception as e:
print(f"❌ 更新患者 {patient_id} 时出错: {e}")
return False
def update_all_failed_patients(self):
"""更新所有失败患者的回访话术"""
print("🔄 开始更新失败患者的回访话术...")
print("="*60)
success_count = 0
failed_count = 0
for patient_id, script_data in self.regenerated_scripts.items():
print(f"\n📋 更新患者: {script_data['patient_name']} ({patient_id})")
print(f" 诊所: {script_data['clinic']}")
if self.update_patient_callback_script(patient_id, script_data):
success_count += 1
else:
failed_count += 1
print(f"\n" + "="*60)
print(f"📊 更新完成:")
print(f" - 总计处理: {len(self.regenerated_scripts)} 个患者")
print(f" - ✅ 成功更新: {success_count} 个")
print(f" - ❌ 更新失败: {failed_count} 个")
if success_count > 0:
print(f"\n🎉 成功更新了 {success_count} 个患者的回访话术！")
print(f" 现在可以在患者画像系统中查看这些更新的话术了。")
if __name__ == "__main__":
updater = CallbackScriptUpdater()
updater.update_all_failed_patients()
\ No newline at end of file
update_callback_with_selected_diagnosis.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新回访话术模块 - 支持优先诊断字段
基于最新的Dify回访话术文本文件更新患者画像页面
"""
import os
import re
import json
import glob
from datetime import datetime
from pathlib import Path
def find_latest_callback_text_file():
"""查找最新的回访话术文本文件"""
patterns = [
'dify_callback_results/Dify回访话术_文本版_*.txt',
'口腔回访话术输出/口腔回访话术_文本版_*.txt',
'../dify_callback_results/Dify回访话术_文本版_*.txt',
'../口腔回访话术输出/口腔回访话术_文本版_*.txt'
]
files = []
for pattern in patterns:
files.extend(glob.glob(pattern))
if not files:
print("❌ 未找到回访话术文本文件")
return None
# 按文件名中的时间戳排序，获取最新的
latest_file = max(files, key=os.path.getctime)
print(f"✅ 找到最新的回访话术文件: {latest_file}")
return latest_file
def parse_callback_text_file(file_path):
"""解析回访话术文本文件"""
print(f"🔍 解析回访话术文件: {file_path}")
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 按患者分块解析
patient_blocks = re.split(r'【\d+】患者:', content)[1:] # 跳过第一个空块
callback_data = {}
for block in patient_blocks:
try:
# 提取患者基本信息
name_match = re.search(r'^([^(]+)\s+\(([^)]+)\)', block)
if not name_match:
continue
patient_name = name_match.group(1).strip()
patient_id = name_match.group(2).strip()
# 提取年龄性别
age_gender_match = re.search(r'年龄:\s*(\d+)岁,\s*性别:\s*([男女])', block)
age = age_gender_match.group(1) if age_gender_match else ''
gender = age_gender_match.group(2) if age_gender_match else ''
# 提取就诊医生
doctor_match = re.search(r'就诊医生:\s*([^\n]+)', block)
doctor = doctor_match.group(1).strip() if doctor_match else ''
# 提取最后就诊时间
visit_time_match = re.search(r'最后就诊:\s*([^\n]+)', block)
visit_time = visit_time_match.group(1).strip() if visit_time_match else ''
# 提取selected_diagnosis（优先诊断）
selected_diagnosis_match = re.search(r'"selected_diagnosis":\s*"([^"]+)"', block)
selected_diagnosis = selected_diagnosis_match.group(1) if selected_diagnosis_match else ''
# 提取四个部分的回访话术
sections = {}
# 第一部分：开场白
opening_match = re.search(r'═══\s*第一部分：开场白\s*═══\n(.*?)(?=═══|$)', block, re.DOTALL)
sections['opening'] = opening_match.group(1).strip() if opening_match else ''
# 第二部分：告知漏诊项目
diagnosis_match = re.search(r'═══\s*第二部分：告知[^═]*═══\n(.*?)(?=═══|$)', block, re.DOTALL)
sections['diagnosis'] = diagnosis_match.group(1).strip() if diagnosis_match else ''
# 第三部分：复查建议
follow_up_match = re.search(r'═══\s*第三部分：复查建议\s*═══\n(.*?)(?=═══|$)', block, re.DOTALL)
sections['follow_up'] = follow_up_match.group(1).strip() if follow_up_match else ''
# 第四部分：结束回访语
closing_match = re.search(r'═══\s*第四部分：[^═]*═══\n(.*?)(?=═══|$)', block, re.DOTALL)
sections['closing'] = closing_match.group(1).strip() if closing_match else ''
callback_data[patient_id] = {
'patient_name': patient_name,
'age': age,
'gender': gender,
'doctor': doctor,
'visit_time': visit_time,
'selected_diagnosis': selected_diagnosis,
'sections': sections
}
except Exception as e:
print(f"⚠️ 解析患者信息时出错: {e}")
continue
print(f"✅ 成功解析 {len(callback_data)} 个患者的回访话术")
return callback_data
def format_section_content(content):
"""格式化话术内容为HTML列表项"""
if not content:
return ""
lines = [line.strip() for line in content.split('\n') if line.strip()]
html_content = []
for line in lines:
# 移除开头的项目符号
line = re.sub(r'^[•·*\-]\s*', '', line)
# 处理粗体标记
if line.startswith('**') and line.endswith('**'):
html_content.append(f'<p class="font-bold text-gray-900 mb-2">{line[2:-2]}：</p>')
elif '**' in line:
line = re.sub(r'\*\*([^*]+)\*\*', r'<strong>\1</strong>', line)
html_content.append(f'<li class="ml-4 mb-2 flex items-start"><i class="fas fa-circle text-xs mt-2 mr-3 text-gray-400"></i><span>{line}</span></li>')
else:
if line.endswith('：') and ('预约成功' in line or '预约不成功' in line):
html_content.append(f'<p class="font-bold text-gray-900 mb-2">{line}</p>')
else:
html_content.append(f'<li class="ml-4 mb-2 flex items-start"><i class="fas fa-circle text-xs mt-2 mr-3 text-gray-400"></i><span>{line}</span></li>')
return ''.join(html_content)
def update_patient_callback_script(html_file, callback_info):
"""更新患者页面的回访话术模块"""
try:
with open(html_file, 'r', encoding='utf-8') as f:
content = f.read()
# 查找回访话术模块
callback_start = content.find('<!-- 口腔回访话术模块 -->')
if callback_start == -1:
return False, "未找到回访话术模块"
callback_end = content.find('</div>', content.find('</section>', callback_start)) + 6
# 构建新的回访话术模块
sections_html = ""
section_configs = [
('opening', '第一部分：开场白', 'blue', 'fas fa-comments'),
('diagnosis', '第二部分：告知漏诊项目', 'yellow', 'fas fa-comments'),
('follow_up', '第三部分：复查建议', 'green', 'fas fa-comments'),
('closing', '第四部分：结束回访语', 'purple', 'fas fa-comments')
]
for section_key, section_title, color, icon in section_configs:
section_content = format_section_content(callback_info['sections'].get(section_key, ''))
sections_html += f'''
<div class="callback-section mb-6">
<div class="section-header bg-{color}-100 px-4 py-3 rounded-t-lg border-l-4 border-{color}-500">
<h3 class="font-bold text-{color}-800 flex items-center text-lg">
<i class="{icon} mr-3"></i>
{section_title}
</h3>
</div>
<div class="section-content bg-{color}-50 p-6 rounded-b-lg border border-t-0 border-{color}-200">
<div class="text-gray-800 leading-relaxed">
{section_content}
</div>
</div>
</div>'''
new_callback_module = f''' <!-- 口腔回访话术模块 -->
<div id="callback-content" class="mt-8">
<section class="scroll-trigger">
<div class="bg-white rounded-xl shadow-lg overflow-hidden border-l-4 border-green-500">
<div class="bg-green-600 px-6 py-4 text-white">
<h2 class="text-xl font-bold flex items-center">
<i class="fas fa-phone mr-3"></i>
口腔回访话术 <span class="text-sm ml-2 font-normal">Oral Callback Script</span>
</h2>
</div>
<div class="p-6">
<div class="mb-6 grid grid-cols-1 md:grid-cols-2 gap-4 bg-gray-50 p-4 rounded-lg">
<div>
<span class="font-medium text-gray-600">患者姓名：</span>
<span class="text-gray-800">{callback_info['patient_name']}</span>
</div>
<div>
<span class="font-medium text-gray-600">年龄性别：</span>
<span class="text-gray-800">{callback_info['age']}岁 {callback_info['gender']}</span>
</div>
<div>
<span class="font-medium text-gray-600">优先诊断：</span>
<span class="text-blue-600 font-semibold">{callback_info['selected_diagnosis']}</span>
</div>
<div>
<span class="font-medium text-gray-600">生成时间：</span>
<span class="text-gray-800">{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</span>
</div>
</div>
<!-- 结构化回访话术内容 -->
<div class="callback-sections">
{sections_html}
</div>
<div class="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
<p class="text-sm text-blue-700">
<i class="fas fa-info-circle mr-2"></i>
<strong>使用提示：</strong>此话术为Dify AI智能生成，请根据实际情况灵活调整使用。建议按照四个模块的顺序进行回访。
</p>
</div>
</div>
</div>
</section>'''
# 替换回访话术模块
new_content = content[:callback_start] + new_callback_module + content[callback_end:]
with open(html_file, 'w', encoding='utf-8') as f:
f.write(new_content)
return True, "更新成功"
except Exception as e:
return False, f"更新失败: {str(e)}"
def update_index_page_with_priority_diagnosis(callback_data):
"""更新索引页面，用优先诊断替换就诊次数"""
index_file = 'patient_profiles/index.html'
if not os.path.exists(index_file):
print("❌ 索引页面不存在")
return
try:
with open(index_file, 'r', encoding='utf-8') as f:
content = f.read()
# 查找所有患者卡片并更新
# 查找患者卡片的模式
card_pattern = r'(<a href="([^"]+)\.html"[^>]*>.*?</a>)'
def replace_card(match):
card_html = match.group(1)
patient_id = match.group(2)
# 如果有回访话术数据，获取优先诊断
selected_diagnosis = ""
if patient_id in callback_data:
selected_diagnosis = callback_data[patient_id].get('selected_diagnosis', '')
# 替换就诊次数为漏诊项
if selected_diagnosis:
# 查找就诊次数部分并替换
visit_count_pattern = r'<span class="bg-blue-100 text-blue-800 text-xs font-medium px-2\.5 py-1 rounded-full">\s*就诊 \d+ 次\s*</span>'
new_diagnosis_span = f'<span class="bg-red-100 text-red-800 text-xs font-medium px-2.5 py-1 rounded-full">{selected_diagnosis}</span>'
card_html = re.sub(visit_count_pattern, new_diagnosis_span, card_html)
return card_html
# 应用替换
new_content = re.sub(card_pattern, replace_card, content, flags=re.DOTALL)
with open(index_file, 'w', encoding='utf-8') as f:
f.write(new_content)
print("✅ 索引页面更新完成")
except Exception as e:
print(f"❌ 更新索引页面失败: {e}")
def main():
"""主函数"""
print("=" * 60)
print("回访话术更新工具 - 支持优先诊断")
print("=" * 60)
# 1. 查找最新的回访话术文本文件
text_file = find_latest_callback_text_file()
if not text_file:
return
# 2. 解析回访话术数据
callback_data = parse_callback_text_file(text_file)
if not callback_data:
print("❌ 没有解析到回访话术数据")
return
# 3. 更新患者页面
patient_profiles_dir = "patient_profiles"
if not os.path.exists(patient_profiles_dir):
print(f"❌ 患者画像目录不存在: {patient_profiles_dir}")
return
success_count = 0
error_count = 0
print(f"\n🔄 开始更新患者页面...")
for patient_id, callback_info in callback_data.items():
html_file = os.path.join(patient_profiles_dir, f"{patient_id}.html")
if os.path.exists(html_file):
success, message = update_patient_callback_script(html_file, callback_info)
if success:
print(f"✅ 更新成功: {patient_id} ({callback_info['patient_name']})")
success_count += 1
else:
print(f"❌ 更新失败: {patient_id} - {message}")
error_count += 1
else:
print(f"⚠️ 患者页面不存在: {patient_id}")
error_count += 1
# 4. 更新索引页面
print(f"\n🔄 更新索引页面...")
update_index_page_with_priority_diagnosis(callback_data)
# 5. 显示统计结果
print("\n" + "=" * 60)
print("更新完成！统计结果:")
print(f" 处理文件: {text_file}")
print(f" 解析患者: {len(callback_data)} 个")
print(f" 更新成功: {success_count} 个")
print(f" 更新失败: {error_count} 个")
print("=" * 60)
if __name__ == "__main__":
main()
\ No newline at end of file
update_chenxinyu_permission.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
调整陈心语用户权限脚本
将用户chenxinyu的权限从通善口腔医院(clinic_hospital)调整到河埒诊所(clinic_helai)
"""
import pymysql
import json
import sys
from datetime import datetime
# 数据库配置
DB_CONFIG = {
'host': 'localhost',
'port': 3306,
'user': 'root',
'password': 'dev_password_123',
'database': 'callback_system',
'charset': 'utf8mb4',
'use_unicode': True,
'init_command': 'SET NAMES utf8mb4'
}
def connect_database():
"""连接数据库"""
try:
connection = pymysql.connect(**DB_CONFIG)
print("✅ 数据库连接成功")
return connection
except Exception as e:
print(f"❌ 数据库连接失败: {e}")
return None
def check_user_exists(connection, username):
"""检查用户是否存在"""
try:
with connection.cursor() as cursor:
sql = "SELECT username, user_type, clinic_access FROM users WHERE username = %s"
cursor.execute(sql, (username,))
result = cursor.fetchone()
if result:
print(f"✅ 找到用户: {result[0]}")
print(f" 用户类型: {result[1]}")
print(f" 当前权限: {result[2]}")
return result
else:
print(f"❌ 用户 {username} 不存在")
return None
except Exception as e:
print(f"❌ 检查用户失败: {e}")
return None
def update_user_permission(connection, username, new_clinic_id):
"""更新用户权限"""
try:
with connection.cursor() as cursor:
# 更新clinic_access字段
new_clinic_access = json.dumps([new_clinic_id])
sql = """
UPDATE users
SET clinic_access = %s, updated_at = NOW()
WHERE username = %s
"""
cursor.execute(sql, (new_clinic_access, username))
if cursor.rowcount > 0:
print(f"✅ 用户 {username} 权限更新成功")
print(f" 新权限: {new_clinic_access}")
return True
else:
print(f"❌ 用户 {username} 权限更新失败")
return False
except Exception as e:
print(f"❌ 更新用户权限失败: {e}")
return False
def verify_update(connection, username):
"""验证更新结果"""
try:
with connection.cursor() as cursor:
sql = "SELECT username, user_type, clinic_access, updated_at FROM users WHERE username = %s"
cursor.execute(sql, (username,))
result = cursor.fetchone()
if result:
print(f"\n📋 更新验证结果:")
print(f" 用户名: {result[0]}")
print(f" 用户类型: {result[1]}")
print(f" 诊所权限: {result[2]}")
print(f" 更新时间: {result[3]}")
return True
else:
print(f"❌ 验证失败: 找不到用户 {username}")
return False
except Exception as e:
print(f"❌ 验证更新失败: {e}")
return False
def main():
"""主函数"""
print("🔧 陈心语用户权限调整工具")
print("=" * 50)
# 连接数据库
connection = connect_database()
if not connection:
sys.exit(1)
try:
username = 'chenxinyu'
new_clinic_id = 'clinic_helai'
print(f"\n🎯 目标用户: {username}")
print(f"🎯 目标诊所: {new_clinic_id} (河埒诊所)")
print(f"🎯 原诊所: clinic_hospital (通善口腔医院)")
# 检查用户是否存在
user_info = check_user_exists(connection, username)
if not user_info:
print("❌ 用户不存在，无法进行权限调整")
return
# 确认操作
print(f"\n⚠️ 确认要将用户 {username} 的权限从通善口腔医院调整到河埒诊所吗？")
confirm = input("请输入 'yes' 确认操作: ")
if confirm.lower() != 'yes':
print("❌ 操作已取消")
return
# 更新用户权限
if update_user_permission(connection, username, new_clinic_id):
# 验证更新结果
verify_update(connection, username)
print("\n✅ 权限调整完成！")
print("📝 用户陈心语现在可以访问河埒诊所的患者数据")
else:
print("\n❌ 权限调整失败")
except Exception as e:
print(f"❌ 执行过程中发生错误: {e}")
finally:
connection.close()
print("\n🔒 数据库连接已关闭")
if __name__ == "__main__":
main()
\ No newline at end of file
update_index_filter_options.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新所有索引页面的筛选选项，添加完整的回访状态和结果选项
"""
import os
import re
import glob
ROOT = os.path.dirname(os.path.abspath(__file__))
PATIENT_PROFILES_DIR = os.path.join(ROOT, 'patient_profiles')
def update_index_filter_options(file_path):
"""更新索引页面的筛选选项"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已经更新过
if '已回访' in content and '成功' in content and '不成功' in content:
return False
# 更新回访状态筛选选项
callback_status_pattern = r'(<select id="callbackStatusFilter"[^>]*>.*?<option value="">全部状态</option>.*?<option value="未回访">未回访</option>.*?</select>)'
callback_status_replacement = r'''<select id="callbackStatusFilter" class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500">
<option value="">全部状态</option>
<option value="未回访">未回访</option>
<option value="已回访">已回访</option>
</select>'''
new_content, count1 = re.subn(callback_status_pattern, callback_status_replacement, content, flags=re.DOTALL)
# 更新回访结果筛选选项
callback_success_pattern = r'(<select id="callbackSuccessFilter"[^>]*>.*?<option value="">全部结果</option>.*?<option value="未知">未知</option>.*?</select>)'
callback_success_replacement = r'''<select id="callbackSuccessFilter" class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500">
<option value="">全部结果</option>
<option value="未知">未知</option>
<option value="成功">成功</option>
<option value="不成功">不成功</option>
<option value="放弃回访">放弃回访</option>
</select>'''
new_content, count2 = re.subn(callback_success_pattern, callback_success_replacement, new_content, flags=re.DOTALL)
if count1 > 0 or count2 > 0:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
return False
except Exception as e:
print(f"更新文件失败 {file_path}: {e}")
return False
def main():
"""主函数"""
pattern = os.path.join(PATIENT_PROFILES_DIR, '*/index.html')
index_files = glob.glob(pattern)
print(f"找到 {len(index_files)} 个索引文件")
updated_count = 0
skipped_count = 0
for file_path in index_files:
try:
if update_index_filter_options(file_path):
updated_count += 1
print(f"✅ 已更新: {os.path.basename(file_path)}")
else:
skipped_count += 1
print(f"⏭️ 已跳过: {os.path.basename(file_path)}")
except Exception as e:
print(f"❌ 处理失败 {file_path}: {e}")
print(f"\n更新完成:")
print(f"- 更新的文件: {updated_count}")
print(f"- 跳过的文件: {skipped_count}")
print(f"- 总文件数: {len(index_files)}")
if __name__ == '__main__':
main()
\ No newline at end of file
update_index_pages_with_dynamic_status.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新所有索引页面，添加动态获取回访状态的功能
"""
import os
import re
import glob
ROOT = os.path.dirname(os.path.abspath(__file__))
PATIENT_PROFILES_DIR = os.path.join(ROOT, 'patient_profiles')
def update_index_html(file_path):
"""更新索引页面，添加动态获取回访状态的功能"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# 检查是否已经添加了动态状态更新功能
if 'updateCallbackStatus' in content:
return False
# 在</body>标签前添加JavaScript代码
js_code = '''
<script>
// 动态更新回访状态
async function updateCallbackStatus() {
try {
const clinicId = window.location.pathname.split('/')[2]; // 从URL获取门诊ID
const apiBase = window.API_BASE_URL || '';
const response = await fetch(`${apiBase}/api/callback-status/${clinicId}`);
const data = await response.json();
if (data.success && data.data) {
const statusMap = {};
data.data.forEach(item => {
statusMap[item.case_number] = item;
});
// 更新页面中的回访状态
document.querySelectorAll('.patient-card').forEach(card => {
const caseNumber = card.getAttribute('data-id');
const statusElement = card.querySelector('.bg-gray-100, .bg-green-100, .bg-red-100');
if (caseNumber && statusElement && statusMap[caseNumber]) {
const status = statusMap[caseNumber];
const isSuccess = status.callback_result === '成功';
// 更新data属性（用于筛选）
card.setAttribute('data-callback-status', status.callback_status);
card.setAttribute('data-callback-success', status.callback_result);
// 更新显示
if (status.callback_status === '已回访') {
statusElement.className = isSuccess ?
'bg-green-100 text-green-800 text-xs font-medium px-2.5 py-0.5 rounded-full' :
'bg-red-100 text-red-800 text-xs font-medium px-2.5 py-0.5 rounded-full';
statusElement.innerHTML = `<i class="fas fa-phone mr-1"></i>${status.callback_result}`;
} else {
// 未回访状态
statusElement.className = 'bg-gray-100 text-gray-800 text-xs font-medium px-2.5 py-0.5 rounded-full';
statusElement.innerHTML = `<i class="fas fa-phone mr-1"></i>未回访`;
}
}
});
// 重新应用筛选（如果当前有筛选条件）
const activeFilters = document.querySelector('#callbackStatusFilter').value ||
document.querySelector('#callbackSuccessFilter').value;
if (activeFilters) {
// 触发筛选事件
const event = new Event('change');
document.querySelector('#callbackStatusFilter').dispatchEvent(event);
document.querySelector('#callbackSuccessFilter').dispatchEvent(event);
}
}
} catch (error) {
console.error('更新回访状态失败:', error);
}
}
// 页面加载时更新状态
document.addEventListener('DOMContentLoaded', updateCallbackStatus);
// 每30秒更新一次状态
setInterval(updateCallbackStatus, 30000);
</script>
'''
# 在</body>标签前插入JavaScript代码
pattern = r'(</body>)'
replacement = js_code + r'\1'
new_content, count = re.subn(pattern, replacement, content)
if count > 0:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(new_content)
return True
return False
except Exception as e:
print(f"更新文件失败 {file_path}: {e}")
return False
def main():
"""主函数"""
pattern = os.path.join(PATIENT_PROFILES_DIR, '*/index.html')
index_files = glob.glob(pattern)
print(f"找到 {len(index_files)} 个索引文件")
updated_count = 0
skipped_count = 0
for file_path in index_files:
try:
if update_index_html(file_path):
updated_count += 1
print(f"✅ 已更新: {os.path.basename(file_path)}")
else:
skipped_count += 1
print(f"⏭️ 已跳过: {os.path.basename(file_path)}")
except Exception as e:
print(f"❌ 处理失败 {file_path}: {e}")
print(f"\n更新完成:")
print(f"- 更新的文件: {updated_count}")
print(f"- 跳过的文件: {skipped_count}")
print(f"- 总文件数: {len(index_files)}")
if __name__ == '__main__':
main()
\ No newline at end of file
update_patient_profiles.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
患者画像更新脚本
根据新的患者数据，删除不需要的画像文件，并重新生成需要的画像文件
"""
import json
import os
import pandas as pd
import shutil
from pathlib import Path
import sys
def load_json_data(json_file):
"""加载JSON数据"""
try:
with open(json_file, 'r', encoding='utf-8') as f:
data = json.load(f)
print(f"成功加载 {json_file}，共 {len(data)} 条记录")
return data
except Exception as e:
print(f"加载 {json_file} 时出错: {e}")
return []
def get_patient_ids_from_data(data):
"""从数据中提取患者病历号列表"""
patient_ids = set()
for record in data:
patient_id = record.get('病历号')
if patient_id:
patient_ids.add(patient_id)
return patient_ids
def get_existing_patient_files():
"""获取现有的患者画像HTML文件列表"""
profiles_dir = Path('patient_profiles')
if not profiles_dir.exists():
return set()
existing_files = set()
for file in profiles_dir.glob('*.html'):
# 排除索引文件和其他非患者文件
if file.name not in ['index.html', 'dify_test_patients.html', 'test_callback_display.html']:
# 提取病历号（文件名去掉.html扩展名）
patient_id = file.stem
existing_files.add(patient_id)
return existing_files
def backup_old_data():
"""备份旧的合并结果文件"""
old_file = "合并结果.xlsx"
if os.path.exists(old_file):
backup_file = f"合并结果_备份_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
shutil.copy2(old_file, backup_file)
print(f"已备份旧数据文件为: {backup_file}")
def create_new_merged_file(new_json_file):
"""基于新的JSON数据创建新的合并结果Excel文件"""
try:
# 读取新的JSON数据
with open(new_json_file, 'r', encoding='utf-8') as f:
data = json.load(f)
# 转换为DataFrame
df = pd.DataFrame(data)
# 保存为Excel文件
new_excel_file = "合并结果.xlsx"
df.to_excel(new_excel_file, index=False)
print(f"已创建新的合并结果文件: {new_excel_file}")
return new_excel_file
except Exception as e:
print(f"创建新合并文件时出错: {e}")
return None
def delete_obsolete_profiles(current_patients, existing_files):
"""删除不需要的患者画像文件"""
profiles_dir = Path('patient_profiles')
# 找出需要删除的文件
files_to_delete = existing_files - current_patients
if not files_to_delete:
print("没有需要删除的患者画像文件")
return
print(f"需要删除 {len(files_to_delete)} 个患者画像文件:")
for patient_id in files_to_delete:
file_path = profiles_dir / f"{patient_id}.html"
if file_path.exists():
try:
file_path.unlink()
print(f" 已删除: {patient_id}.html")
except Exception as e:
print(f" 删除 {patient_id}.html 时出错: {e}")
def generate_new_profiles():
"""调用generate_html.py生成新的患者画像"""
try:
print("开始生成新的患者画像...")
# 导入generate_html模块
sys.path.append('.')
import generate_html
# 调用主函数
generate_html.main()
print("患者画像生成完成")
except Exception as e:
print(f"生成患者画像时出错: {e}")
def main():
"""主函数"""
print("=== 患者画像更新工具 ===")
# 检查新的JSON文件是否存在
new_json_file = "通善学前街诊所漏诊客户召回列表.json"
if not os.path.exists(new_json_file):
print(f"错误: 找不到新的数据文件 {new_json_file}")
print("请先运行: python excel_to_json.py 通善学前街诊所漏诊客户召回列表.xlsx")
return
# 备份旧数据
backup_old_data()
# 加载新的患者数据
new_data = load_json_data(new_json_file)
if not new_data:
print("无法加载新的患者数据")
return
# 获取新数据中的患者ID列表
current_patients = get_patient_ids_from_data(new_data)
print(f"新数据中包含 {len(current_patients)} 个患者")
# 获取现有的患者画像文件
existing_files = get_existing_patient_files()
print(f"现有患者画像文件 {len(existing_files)} 个")
# 删除不需要的患者画像文件
delete_obsolete_profiles(current_patients, existing_files)
# 创建新的合并结果文件
new_excel_file = create_new_merged_file(new_json_file)
if not new_excel_file:
print("无法创建新的合并结果文件")
return
# 生成新的患者画像
generate_new_profiles()
print("\n=== 更新完成 ===")
print(f"当前患者数量: {len(current_patients)}")
print(f"已删除过时的画像文件: {len(existing_files - current_patients)} 个")
print(f"已重新生成所有患者画像")
if __name__ == "__main__":
main()
\ No newline at end of file
update_patient_profiles_callback.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新患者画像的回访话术模块
将dify_callback_results中的最新回访话术数据更新到patient_profiles目录中的患者页面
"""
import os
import json
import re
import glob
from datetime import datetime
from typing import Dict, List, Optional, Tuple
class PatientProfileCallbackUpdater:
"""患者画像回访话术更新器"""
def __init__(self):
"""初始化更新器"""
self.dify_results_dir = "dify_callback_results"
self.patient_profiles_dir = "patient_profiles"
# 诊所名称映射
self.clinic_mapping = {
"马山门诊": "clinic_mashan",
"通善口腔医院": "clinic_hospital",
"红豆门诊": "clinic_hongdou",
"河埒门诊": "clinic_helai",
"新吴门诊": "clinic_xinwu",
"惠山门诊": "clinic_huishan",
"大丰门诊": "clinic_dafeng",
"东亭门诊": "clinic_dongting",
"学前街门诊": "clinic_xuexian"
}
# 模块配置
self.section_configs = [
{
'name': 'opening',
'title': '第一部分：开场白',
'color': 'blue',
'icon': 'fas fa-comments'
},
{
'name': 'diagnosis',
'title': '第二部分：告知漏诊项目',
'color': 'yellow',
'icon': 'fas fa-exclamation-triangle'
},
{
'name': 'follow_up',
'title': '第三部分：复查建议',
'color': 'green',
'icon': 'fas fa-calendar-check'
},
{
'name': 'closing',
'title': '第四部分：结束回访语',
'color': 'purple',
'icon': 'fas fa-check-circle'
}
]
def find_latest_callback_files(self) -> List[str]:
"""查找最新的回访话术文件"""
pattern = os.path.join(self.dify_results_dir, "中间结果_*.json")
files = glob.glob(pattern)
# 按修改时间排序，获取最新的文件
files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
print(f"找到 {len(files)} 个回访话术文件:")
for file in files[:5]: # 只显示前5个
mtime = datetime.fromtimestamp(os.path.getmtime(file))
print(f" - {os.path.basename(file)} ({mtime.strftime('%Y-%m-%d %H:%M:%S')})")
return files
def parse_callback_file(self, file_path: str) -> Dict:
"""解析回访话术文件"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
data = json.load(f)
clinic_name = data.get('clinic_name', '')
generation_time = data.get('generation_time', '')
callbacks = data.get('callbacks', [])
print(f"✅ 成功解析文件: {os.path.basename(file_path)}")
print(f" 诊所: {clinic_name}")
print(f" 生成时间: {generation_time}")
print(f" 患者数量: {len(callbacks)}")
return {
'clinic_name': clinic_name,
'generation_time': generation_time,
'callbacks': callbacks
}
except Exception as e:
print(f"❌ 解析文件 {file_path} 时出错: {e}")
return None
def parse_callback_script(self, script: str) -> Dict:
"""解析回访话术内容，提取四个模块"""
sections = {}
# 提取JSON配置
json_match = re.search(r'```json\s*(\{.*?\})\s*```', script, re.DOTALL)
if json_match:
try:
config = json.loads(json_match.group(1))
sections['config'] = config
except:
sections['config'] = {}
# 提取四个模块内容
for config in self.section_configs:
pattern = rf'═══ {config["title"]} ═══\s*(.*?)(?=═══|$)'
match = re.search(pattern, script, re.DOTALL)
if match:
content = match.group(1).strip()
# 清理内容
content = re.sub(r'^\s*[•\-\*]\s*', '', content, flags=re.MULTILINE)
content = re.sub(r'\n\s*[•\-\*]\s*', '\n• ', content)
sections[config['name']] = content
else:
sections[config['name']] = ""
return sections
def build_callback_html(self, callback_data: Dict, sections: Dict) -> str:
"""构建回访话术HTML"""
patient_name = callback_data.get('patient_name', '')
age = callback_data.get('age', '')
gender = callback_data.get('gender', '')
generation_time = callback_data.get('generation_time', '')
# 构建患者信息概览
patient_info_html = f"""
<div class="mb-6 grid grid-cols-1 md:grid-cols-3 gap-4 bg-gray-50 p-4 rounded-lg">
<div>
<span class="font-medium text-gray-600">患者姓名：</span>
<span class="text-gray-800">{patient_name}</span>
</div>
<div>
<span class="font-medium text-gray-600">年龄性别：</span>
<span class="text-gray-800">{age}岁 {gender}</span>
</div>
<div>
<span class="font-medium text-gray-600">生成时间：</span>
<span class="text-gray-800">{generation_time}</span>
</div>
</div>
"""
# 构建四个模块HTML
sections_html = ""
for config in self.section_configs:
section_name = config['name']
section_title = config['title']
color = config['color']
icon = config['icon']
content = sections.get(section_name, '')
if content:
section_html = f"""
<div class="mb-6">
<div class="bg-{color}-50 border-l-4 border-{color}-500 p-4 rounded-lg">
<div class="flex items-center mb-3">
<i class="{icon} text-{color}-600 mr-2"></i>
<h4 class="font-semibold text-{color}-800">{section_title}</h4>
</div>
<div class="text-sm text-gray-700 leading-relaxed whitespace-pre-line">
{content}
</div>
</div>
</div>
"""
sections_html += section_html
# 构建完整HTML
html = f"""
{patient_info_html}
<!-- 结构化回访话术内容 -->
<div class="callback-sections">
{sections_html}
</div>
<div class="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
<p class="text-sm text-blue-700">
<i class="fas fa-info-circle mr-2"></i>
<strong>使用提示：</strong>此话术为Dify AI智能生成，请根据实际情况灵活调整使用。建议按照四个模块的顺序进行回访。
</p>
</div>
"""
return html
def update_patient_callback_script(self, patient_id: str, callback_data: Dict, clinic_name: str) -> bool:
"""更新单个患者的回访话术"""
# 获取诊所目录
clinic_dir = self.clinic_mapping.get(clinic_name)
if not clinic_dir:
print(f"❌ 未找到诊所 {clinic_name} 对应的目录映射")
return False
patient_file = os.path.join(self.patient_profiles_dir, clinic_dir, "patients", f"{patient_id}.html")
if not os.path.exists(patient_file):
print(f"❌ 未找到患者文件: {patient_file}")
return False
try:
# 读取患者页面
with open(patient_file, 'r', encoding='utf-8') as f:
content = f.read()
# 解析回访话术内容
script = callback_data.get('callback_script', '')
sections = self.parse_callback_script(script)
# 构建新的回访话术HTML
new_script_html = self.build_callback_html(callback_data, sections)
# 查找并替换回访话术内容
# 查找现有的回访话术模块
callback_module_pattern = r'(<!-- 口腔回访话术模块 -->\s*<div[^>]*>.*?<div class="p-6">\s*)(.*?)(\s*</div>\s*</div>\s*</section>\s*</div>)'
if re.search(callback_module_pattern, content, re.DOTALL):
# 替换现有内容
content = re.sub(
callback_module_pattern,
r'\1' + new_script_html + r'\3',
content,
flags=re.DOTALL
)
print(f"✅ 已更新患者 {callback_data.get('patient_name', '')} ({patient_id}) 的回访话术")
return True
else:
print(f"⚠️ 患者 {patient_id} 页面无法找到回访话术模块")
return False
except Exception as e:
print(f"❌ 更新患者 {patient_id} 时出错: {e}")
return False
def update_all_patients(self):
"""更新所有患者的回访话术"""
print("=" * 60)
print("患者画像回访话术更新工具")
print("=" * 60)
# 查找最新的回访话术文件
callback_files = self.find_latest_callback_files()
if not callback_files:
print("❌ 未找到回访话术文件")
return
# 处理每个文件
total_updated = 0
total_failed = 0
for file_path in callback_files:
print(f"\n📁 处理文件: {os.path.basename(file_path)}")
# 解析文件
data = self.parse_callback_file(file_path)
if not data:
continue
clinic_name = data['clinic_name']
callbacks = data['callbacks']
# 更新每个患者的回访话术
for callback in callbacks:
patient_id = callback.get('patient_id', '')
if not patient_id:
continue
success = self.update_patient_callback_script(patient_id, callback, clinic_name)
if success:
total_updated += 1
else:
total_failed += 1
print("\n" + "=" * 60)
print("更新完成！统计结果:")
print(f" 成功更新: {total_updated} 个患者")
print(f" 更新失败: {total_failed} 个患者")
print(f" 总计处理: {total_updated + total_failed} 个患者")
print("=" * 60)
def main():
"""主函数"""
updater = PatientProfileCallbackUpdater()
updater.update_all_patients()
if __name__ == "__main__":
main()
\ No newline at end of file
update_priority_diagnosis.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
更新优先诊断字段和话术样式
增强版：同时更新索引页匹配和详情页样式
"""
import os
import json
import glob
import re
from datetime import datetime
def load_clinic_scripts(clinic_name):
"""加载指定门诊的话术数据"""
pattern = f"dify_callback_results/中间结果_{clinic_name}_*.json"
files = glob.glob(pattern)
if not files:
print(f"❌ 未找到 {clinic_name} 的话术文件")
return None
latest_file = max(files, key=os.path.getctime)
print(f"📁 使用文件: {latest_file}")
try:
with open(latest_file, 'r', encoding='utf-8') as f:
data = json.load(f)
return data
except Exception as e:
print(f"❌ 读取文件失败: {e}")
return None
def extract_selected_diagnosis(callback_script):
"""从话术中提取selected_diagnosis"""
try:
json_match = re.search(r'```json\s*(\{.*?\})\s*```', callback_script, re.DOTALL)
if json_match:
json_str = json_match.group(1)
json_data = json.loads(json_str)
return json_data.get('selected_diagnosis', '')
except:
pass
return ''
def update_patient_detail_page(patient_id, diagnosis, clinic_folder):
"""更新患者详情页面的优先诊断字段"""
patient_page_path = f"patient_profiles/{clinic_folder}/patients/{patient_id}.html"
if not os.path.exists(patient_page_path):
return False
try:
with open(patient_page_path, 'r', encoding='utf-8') as f:
content = f.read()
# 更新优先诊断字段
if diagnosis:
pattern = r'<span class="text-blue-600 font-semibold">待更新</span>'
replacement = f'<span class="text-blue-600 font-semibold">{diagnosis}</span>'
content = re.sub(pattern, replacement, content)
with open(patient_page_path, 'w', encoding='utf-8') as f:
f.write(content)
print(f"✅ 已更新患者 {patient_id} 的优先诊断字段")
return True
except Exception as e:
print(f"❌ 更新患者详情页面失败 {patient_id}: {e}")
return False
def update_index_page_priority_diagnosis(patient_id, diagnosis):
"""更新索引页面的优先诊断匹配"""
index_files = [
"patient_profiles/index.html",
"patient_profiles/clinic_dafeng/index.html",
"patient_profiles/clinic_dongting/index.html",
"patient_profiles/clinic_huishan/index.html",
"patient_profiles/clinic_xinwu/index.html",
"patient_profiles/clinic_helai/index.html",
"patient_profiles/clinic_hongdou/index.html",
"patient_profiles/clinic_mashan/index.html",
"patient_profiles/clinic_hospital/index.html"
]
success_count = 0
for index_file in index_files:
if not os.path.exists(index_file):
continue
try:
with open(index_file, 'r', encoding='utf-8') as f:
content = f.read()
# 查找患者卡片并更新优先诊断
card_pattern = rf'(<a href="[^"]*{patient_id}[^"]*"[^>]*>.*?</a>)'
def replace_card(match):
card_html = match.group(1)
# 如果有诊断信息，更新优先诊断标签
if diagnosis:
# 查找并替换"无优先诊断"标签
no_diagnosis_pattern = r'<span class="bg-gray-100 text-gray-800 text-xs font-medium px-2\.5 py-1 rounded-full">\s*无优先诊断\s*</span>'
new_diagnosis_span = f'<span class="bg-red-100 text-red-800 text-xs font-medium px-2.5 py-1 rounded-full">🎯 {diagnosis}</span>'
card_html = re.sub(no_diagnosis_pattern, new_diagnosis_span, card_html)
# 更新data-selected-diagnosis属性
data_pattern = rf'data-selected-diagnosis="[^"]*"'
new_data_attr = f'data-selected-diagnosis="{diagnosis}"'
card_html = re.sub(data_pattern, new_data_attr, card_html)
return card_html
# 应用替换
new_content = re.sub(card_pattern, replace_card, content, flags=re.DOTALL)
with open(index_file, 'w', encoding='utf-8') as f:
f.write(new_content)
success_count += 1
except Exception as e:
print(f"❌ 更新索引页面失败 {index_file}: {e}")
if success_count > 0:
print(f"✅ 已更新 {success_count} 个索引页面的优先诊断匹配")
return True
return False
def process_clinic_diagnosis(clinic_name, clinic_folder):
"""处理指定门诊的诊断数据"""
print(f"\n🏥 处理 {clinic_name} 的诊断数据...")
scripts_data = load_clinic_scripts(clinic_name)
if not scripts_data:
return
callbacks = scripts_data.get('callbacks', [])
print(f"📊 找到 {len(callbacks)} 条话术数据")
success_count = 0
index_update_count = 0
for callback in callbacks:
patient_id = callback.get('patient_id')
callback_script = callback.get('callback_script', '')
if patient_id and callback_script:
diagnosis = extract_selected_diagnosis(callback_script)
if diagnosis:
# 更新详情页
if update_patient_detail_page(patient_id, diagnosis, clinic_folder):
success_count += 1
# 更新索引页
if update_index_page_priority_diagnosis(patient_id, diagnosis):
index_update_count += 1
print(f"✅ {clinic_name} 处理完成:")
print(f" - 详情页更新: {success_count}/{len(callbacks)} 个患者")
print(f" - 索引页更新: {index_update_count} 个患者")
def main():
"""主函数"""
print("🎯 开始更新优先诊断字段和话术样式")
print("=" * 60)
clinics = [
{"name": "大丰门诊", "folder": "clinic_dafeng"},
{"name": "东亭门诊", "folder": "clinic_dongting"},
{"name": "惠山门诊", "folder": "clinic_huishan"},
{"name": "新吴门诊", "folder": "clinic_xinwu"},
{"name": "河埒门诊", "folder": "clinic_helai"},
{"name": "红豆门诊", "folder": "clinic_hongdou"},
{"name": "马山门诊", "folder": "clinic_mashan"},
{"name": "通善口腔医院", "folder": "clinic_hospital"}
]
for clinic in clinics:
try:
process_clinic_diagnosis(clinic["name"], clinic["folder"])
except Exception as e:
print(f"❌ 处理 {clinic['name']} 失败: {e}")
print(f"\n🎉 更新完成！")
if __name__ == "__main__":
main()
\ No newline at end of file
view_database.py deleted 100644 → 0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
数据库查看工具
用于查看回访记录数据库中的所有数据
"""
import sqlite3
import json
from datetime import datetime
import os
def view_sqlite_database(db_path="callback_records.db"):
"""查看SQLite数据库中的所有回访记录"""
if not os.path.exists(db_path):
print(f"❌ 数据库文件不存在: {db_path}")
print("可能的数据库文件位置：")
for file in os.listdir('.'):
if file.endswith('.db'):
print(f" - {file}")
return
try:
with sqlite3.connect(db_path) as conn:
cursor = conn.cursor()
# 检查表是否存在
cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='callback_records'")
if not cursor.fetchone():
print("❌ 回访记录表不存在")
return
# 获取所有记录
cursor.execute('''
SELECT record_id, case_number, callback_methods, callback_record,
operator, create_time
FROM callback_records
ORDER BY create_time DESC
''')
records = cursor.fetchall()
if not records:
print("📝 数据库中暂无回访记录")
return
print(f"📊 共找到 {len(records)} 条回访记录")
print("=" * 80)
for i, record in enumerate(records, 1):
record_id, case_number, callback_methods_json, callback_record, operator, create_time = record
# 解析回访方式
try:
callback_methods = json.loads(callback_methods_json)
methods_str = ", ".join(callback_methods)
except:
methods_str = callback_methods_json
# 格式化时间
try:
if create_time:
create_time_obj = datetime.fromisoformat(create_time.replace('Z', '+00:00'))
time_str = create_time_obj.strftime('%Y-%m-%d %H:%M:%S')
else:
time_str = "未知时间"
except:
time_str = str(create_time)
print(f"📋 记录 #{i} (ID: {record_id})")
print(f" 病历号: {case_number}")
print(f" 回访方式: {methods_str}")
print(f" 操作员: {operator}")
print(f" 创建时间: {time_str}")
print(f" 回访内容:")
# 格式化显示回访内容
content_lines = callback_record.split('\n')
for line in content_lines:
if line.strip():
print(f" {line}")
print("-" * 60)
# 显示统计信息
print("\n📈 统计信息:")
# 按病历号统计
cursor.execute('''
SELECT case_number, COUNT(*) as count
FROM callback_records
GROUP BY case_number
ORDER BY count DESC
''')
case_stats = cursor.fetchall()
print(f" 总记录数: {len(records)}")
print(f" 涉及患者: {len(case_stats)} 人")
if case_stats:
print(" 各患者记录数:")
for case_number, count in case_stats:
print(f" {case_number}: {count} 条")
# 按回访方式统计
method_stats = {}
for record in records:
try:
methods = json.loads(record[2])
for method in methods:
method_stats[method] = method_stats.get(method, 0) + 1
except:
pass
if method_stats:
print(" 回访方式统计:")
for method, count in method_stats.items():
print(f" {method}: {count} 次")
# 按操作员统计
cursor.execute('''
SELECT operator, COUNT(*) as count
FROM callback_records
GROUP BY operator
ORDER BY count DESC
''')
operator_stats = cursor.fetchall()
if operator_stats:
print(" 操作员统计:")
for operator, count in operator_stats:
print(f" {operator}: {count} 条")
except Exception as e:
print(f"❌ 查看数据库失败: {e}")
def find_database_files():
"""查找所有可能的数据库文件"""
print("🔍 搜索数据库文件...")
db_files = []
# 当前目录
for file in os.listdir('.'):
if file.endswith('.db'):
db_files.append(f"./{file}")
# patient_profiles目录
if os.path.exists('patient_profiles'):
for file in os.listdir('patient_profiles'):
if file.endswith('.db'):
db_files.append(f"./patient_profiles/{file}")
if db_files:
print(f"📁 找到 {len(db_files)} 个数据库文件:")
for i, db_file in enumerate(db_files, 1):
file_size = os.path.getsize(db_file)
print(f" {i}. {db_file} ({file_size} bytes)")
return db_files
else:
print("❌ 未找到任何数据库文件")
return []
def main():
"""主函数"""
print("🗄️ 回访记录数据库查看工具")
print("=" * 50)
# 查找数据库文件
db_files = find_database_files()
if not db_files:
print("\n💡 提示：")
print("1. 确保你已经保存过回访记录")
print("2. 数据库文件通常名为 callback_records.db")
print("3. 如果使用MySQL，请使用MySQL客户端查看")
return
# 如果只有一个数据库文件，直接查看
if len(db_files) == 1:
print(f"\n📖 查看数据库: {db_files[0]}")
view_sqlite_database(db_files[0])
else:
# 让用户选择要查看的数据库
print(f"\n请选择要查看的数据库 (1-{len(db_files)}):")
try:
choice = input("输入数字: ").strip()
if choice.isdigit():
index = int(choice) - 1
if 0 <= index < len(db_files):
print(f"\n📖 查看数据库: {db_files[index]}")
view_sqlite_database(db_files[index])
else:
print("❌ 无效的选择")
else:
print("❌ 请输入数字")
except KeyboardInterrupt:
print("\n👋 已取消")
except Exception as e:
print(f"❌ 输入错误: {e}")
if __name__ == "__main__":
main()
\ No newline at end of file
一键启动.py deleted 100644 → 0
#!/usr/bin/env python ++ /dev/null
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import subprocess
import time
def run_script(script_name, args=None):
"""运行指定的Python脚本"""
cmd = [sys.executable, script_name]
if args:
cmd.extend(args)
print(f"正在运行 {script_name}...")
try:
result = subprocess.run(cmd, capture_output=True, text=True, encoding='utf-8')
print(result.stdout)
if result.returncode != 0:
print(f"运行脚本失败: {result.stderr}")
return False
return True
except Exception as e:
print(f"执行脚本时出错: {e}")
return False
def main():
"""主函数，执行整个流程"""
# 检查Excel文件是否存在
excel_files = [f for f in os.listdir('.') if f.endswith(('.xlsx', '.xls'))]
if not excel_files:
print("错误：未找到Excel文件")
return
# 选择Excel文件
if len(excel_files) == 1:
excel_file = excel_files[0]
else:
print("发现多个Excel文件:")
for i, file in enumerate(excel_files, 1):
print(f"{i}. {file}")
try:
choice = int(input("请选择要处理的Excel文件 (输入编号): "))
if 1 <= choice <= len(excel_files):
excel_file = excel_files[choice-1]
else:
print("无效的选择")
return
except ValueError:
print("无效的输入")
return
# 1. 转换Excel到JSON
json_file = os.path.splitext(excel_file)[0] + '.json'
if not os.path.exists(json_file) or input(f"文件 {json_file} 已存在，是否重新生成? (y/n): ").lower() == 'y':
if not run_script('excel_to_json.py', [excel_file]):
print("Excel转JSON失败，流程终止")
return
# 2. 生成HTML文件
if not run_script('generate_html.py'):
print("生成HTML失败，流程终止")
return
# 3. 启动服务器
run_script('start_server.py')
if __name__ == "__main__":
# 显示欢迎信息
print("=" * 60)
print(" 利星行客户画像系统 - 一键式启动工具")
print("=" * 60)
main()
\ No newline at end of file
一键部署.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 正在启动患者画像回访话术系统...
echo.
echo 1. 停止现有服务...
docker-compose -p patient-callback-system down
echo.
echo 2. 启动服务...
docker-compose -p patient-callback-system up -d
echo.
echo 3. 等待服务启动...
timeout /t 20
echo.
echo 4. 查看服务状态...
docker-compose -p patient-callback-system ps
echo.
echo 部署完成！请访问：http://localhost:5000
echo.
pause
\ No newline at end of file
一键部署SQLite.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 正在启动患者画像回访话术系统（SQLite版本）...
echo.
echo 1. 停止现有服务...
docker-compose -p patient-callback-system down
echo.
echo 2. 启动SQLite版本服务...
docker-compose -p patient-callback-system -f docker-compose-sqlite.yml up -d
echo.
echo 3. 等待服务启动...
timeout /t 20
echo.
echo 4. 查看服务状态...
docker-compose -p patient-callback-system -f docker-compose-sqlite.yml ps
echo.
echo 部署完成！请访问：http://localhost:5000
echo.
pause
\ No newline at end of file
一键部署国内镜像.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
chcp 65001 >nul
echo 🚀 患者画像回访话术系统 - 国内镜像部署
echo ================================================
echo.
echo 📋 检查Docker环境...
docker --version >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：未检测到Docker，请先安装Docker Desktop
echo 下载地址：https://www.docker.com/products/docker-desktop
pause
exit /b 1
)
echo ✅ Docker环境检查通过
echo.
echo 🔧 停止现有服务...
docker-compose -p patient-callback-system down
echo.
echo 🏗️ 构建应用镜像（使用国内镜像源）...
docker-compose -p patient-callback-system build patient_callback_app
echo.
echo 🚀 启动所有服务...
docker-compose -p patient-callback-system up -d
echo.
echo ⏳ 等待服务启动完成...
timeout /t 45 /nobreak >nul
echo.
echo 📊 检查服务状态...
docker-compose -p patient-callback-system ps
echo.
echo 🎉 部署完成！
echo.
echo 🌐 访问地址：
echo 主应用：http://localhost:5000
echo 登录页面：http://localhost:5000/login
echo 患者画像：http://localhost:5000/patient_profiles/
echo.
echo 📖 数据将存储在MySQL数据库中
echo.
pause
\ No newline at end of file
一键部署已登录.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
chcp 65001 >nul
echo 🚀 患者画像回访话术系统 - Docker部署（已登录版本）
echo ================================================
echo.
echo 📋 检查Docker登录状态...
docker info >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：Docker未运行或未登录
echo 请确保Docker Desktop正在运行且已登录Docker Hub
pause
exit /b 1
)
echo ✅ Docker环境检查通过
echo.
echo 🔧 停止现有服务...
docker-compose -p patient-callback-system down
echo.
echo 🏗️ 构建应用镜像...
docker-compose -p patient-callback-system build patient_callback_app
echo.
echo 🚀 启动所有服务...
docker-compose -p patient-callback-system up -d
echo.
echo ⏳ 等待服务启动完成...
timeout /t 30 /nobreak >nul
echo.
echo 📊 检查服务状态...
docker-compose -p patient-callback-system ps
echo.
echo 🧪 运行部署测试...
python test_docker_deployment.py
echo.
echo 🎉 部署完成！
echo.
echo 🌐 访问地址：
echo 主应用：http://localhost:5000
echo 登录页面：http://localhost:5000/login
echo 患者画像：http://localhost:5000/patient_profiles/
echo.
echo 📖 更多信息请查看 README_DOCKER.md
echo.
pause
\ No newline at end of file
启动Docker.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 正在启动患者画像回访话术系统...
echo.
echo 1. 停止现有服务...
docker-compose down
echo.
echo 2. 启动服务...
docker-compose up -d
echo.
echo 3. 等待服务启动...
timeout /t 15
echo.
echo 4. 查看服务状态...
docker-compose ps
echo.
echo 部署完成！请访问：http://localhost:5000
echo.
pause
\ No newline at end of file
启动Docker新版本.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
chcp 65001 >nul
echo 🚀 患者画像回访话术系统 - Docker部署
echo ================================================
echo.
echo 📋 检查Docker环境...
docker --version >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：未检测到Docker，请先安装Docker Desktop
echo 下载地址：https://www.docker.com/products/docker-desktop
pause
exit /b 1
)
docker-compose --version >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：未检测到Docker Compose
pause
exit /b 1
)
echo ✅ Docker环境检查通过
echo.
echo 🔧 停止现有服务...
docker-compose -p patient-callback-system down
echo.
echo 🏗️ 构建镜像...
docker-compose -p patient-callback-system build
echo.
echo 🚀 启动服务...
docker-compose -p patient-callback-system up -d
echo.
echo ⏳ 等待服务启动完成...
timeout /t 15 /nobreak >nul
echo.
echo 📊 检查服务状态...
docker-compose -p patient-callback-system ps
echo.
echo 🎉 部署完成！
echo.
echo 🌐 访问地址：
echo 主应用：http://localhost:5000
echo 登录页面：http://localhost:5000/login
echo 患者画像：http://localhost:5000/patient_profiles/
echo.
echo 📖 更多信息请查看 README_DOCKER.md
echo.
pause
\ No newline at end of file
启动Docker认证版.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
chcp 65001 >nul
echo ========================================
echo 患者画像回访话术系统 - Docker认证版
echo ========================================
echo.
echo 🚀 启动带完整认证功能的Docker服务...
echo.
echo 📋 系统功能:
echo ✅ 用户登录认证
echo ✅ 门诊访问权限控制
echo ✅ 回访记录管理
echo ✅ 患者画像展示
echo.
echo 🔧 正在启动服务...
docker-compose -f docker-compose-auth.yml up -d
if %errorlevel% equ 0 (
echo.
echo ✅ Docker服务启动成功！
echo.
echo 📊 服务信息:
echo 主应用: http://localhost:4002
echo 数据库: localhost:3307
echo 登录页面: http://localhost:4002/login
echo.
echo 👥 测试账号:
echo 管理员: admin / admin123
echo 大丰门诊: chenlin / chenlin123
echo 学前街门诊: jinqin / jinqin123
echo.
echo 🔍 查看服务状态:
echo docker-compose -f docker-compose-auth.yml ps
echo.
echo 🛑 停止服务:
echo docker-compose -f docker-compose-auth.yml down
echo.
pause
) else (
echo.
echo ❌ Docker服务启动失败！
echo.
echo 🔧 故障排除:
echo 1. 确保Docker已安装并运行
echo 2. 检查端口4002是否被占用
echo 3. 检查MySQL端口3307是否被占用
echo.
echo 📋 查看详细错误信息:
echo docker-compose -f docker-compose-auth.yml logs
echo.
pause
)
\ No newline at end of file
启动应用.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 启动患者画像回访话术系统...
echo.
echo 访问地址：http://localhost:5000
echo 默认登录：admin / admin123
echo.
echo 按 Ctrl+C 停止服务
echo.
python auth_server.py
\ No newline at end of file
当前配置记录_回滚前.md 0 → 100644
# 当前配置记录 - 回滚前
# 当前配置记录 - 回滚前
## 时间
2025年8月15日
## 当前Git状态
- 当前版本：d869c44f (修复马山门诊数据导出问题并完善部署脚本)
- 落后远程分支：11个提交
- 已删除文件：docker-compose.override.yml
## Docker容器状态
- patient_callback_app: 健康运行，端口4002:5000
- patient_callback_mysql: 健康运行，端口3307:3306
## 数据库配置
- 主机端口：3307
- 容器端口：3306
- 数据库名：callback_system
- 用户名：callback_user
- 密码：dev_password_123
- 字符集：utf8mb4
## 应用配置
- 主机端口：4002
- 容器端口：5000
- 数据库主机：mysql（容器内）
- 环境变量：已配置DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, DB_CHARSET
## 重要文件
- docker-compose.yml: 当前使用的配置文件
- auth_system.py: 认证系统主文件
- requirements.txt: Python依赖文件
- Dockerfile: 容器构建文件
## 备注
当前系统显示错误的登录页面，需要回滚到更早的版本4ec2561d
\ No newline at end of file
快速部署Docker.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
chcp 65001
echo 🚀 患者画像回访话术系统 - Docker快速部署
echo ================================================
echo.
echo 📋 检查Docker环境...
docker --version >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：未检测到Docker，请先安装Docker Desktop
echo 下载地址：https://www.docker.com/products/docker-desktop
pause
exit /b 1
)
docker-compose --version >nul 2>&1
if %errorlevel% neq 0 (
echo ❌ 错误：未检测到Docker Compose
pause
exit /b 1
)
echo ✅ Docker环境检查通过
echo.
echo 🔧 停止现有服务...
docker-compose down
echo.
echo 🏗️ 构建镜像...
docker-compose build
echo.
echo 🚀 启动服务...
docker-compose up -d
echo.
echo ⏳ 等待服务启动完成...
timeout /t 10 /nobreak >nul
echo.
echo 📊 检查服务状态...
docker-compose ps
echo.
echo 🧪 运行部署测试...
python test_docker_deployment.py
echo.
echo 🎉 部署完成！
echo.
echo 🌐 访问地址：
echo 主应用：http://localhost:5000
echo 登录页面：http://localhost:5000/login
echo 患者画像：http://localhost:5000/patient_profiles/
echo.
echo 📖 更多信息请查看 README_DOCKER.md
echo.
pause
\ No newline at end of file
测试镜像拉取.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 测试Docker镜像拉取...
echo.
echo 1. 测试拉取Python镜像...
docker pull python:3.9-slim
echo.
echo 2. 测试拉取MySQL镜像...
docker pull mysql:8.0
echo.
echo 3. 查看本地镜像...
docker images
echo.
echo 测试完成！
pause
\ No newline at end of file
生产环境安全部署说明.md 0 → 100644
# 生产环境安全部署说明
# 生产环境安全部署说明
## 🚨 重要提醒
**⚠️ 生产环境部署前必须完整备份数据库！**
## 📋 部署前准备
### 1. 数据库备份
```bash
# 生产环境数据库完整备份
mysqldump -u [用户名] -p [数据库名] > production_backup_$(date +%Y%m%d_%H%M%S).sql
# 示例
mysqldump -u callback_user -p callback_system > production_backup_20250815_$(date +%H%M%S).sql
```
### 2. 验证备份文件
```bash
# 检查备份文件大小
ls -lh production_backup_*.sql
# 验证备份文件完整性
mysql -u [用户名] -p [数据库名] < production_backup_*.sql
```
## 🔒 安全部署步骤
### 步骤1：部署代码
```bash
# 停止现有容器
docker compose -p patient-callback-system down
# 重新构建镜像
docker compose -p patient-callback-system build
# 启动容器
docker compose -p patient-callback-system up -d
```
### 步骤2：安全导入患者数据
```bash
# 在容器中执行安全导入脚本
docker exec patient_callback_app python safe_import_patients.py
```
## 🛡️ 安全特性说明
### 1. **数据保护机制**
- ✅ **不删除现有数据** - 使用 `INSERT ... ON DUPLICATE KEY UPDATE`
- ✅ **自动备份** - 导入前自动备份现有数据到临时表
- ✅ **增量更新** - 只更新必要的字段，保留所有现有数据
- ✅ **事务安全** - 使用数据库事务确保数据一致性
### 2. **导入策略**
- **新增患者**：插入新记录
- **现有患者**：更新信息，保留 `created_at` 时间
- **跳过无效数据**：记录并跳过格式错误的数据
### 3. **备份策略**
- 导入前自动创建备份表：`patients_backup_YYYYMMDD_HHMMSS`
- 保留所有原有数据
- 可随时回滚到备份状态
## 📊 预期结果
### 导入后数据状态：
- **总患者数**：4,133人（保持不变）
- **数据完整性**：100%保留
- **新增数据**：0个（因为数据已存在）
- **更新数据**：4,133个（更新到最新状态）
### 各门诊分布：
- 学前街门诊：765人
- 大丰门诊：598人
- 通善口腔医院：536人
- 马山门诊：527人
- 红豆门诊：500人
- 东亭门诊：479人
- 惠山门诊：323人
- 新吴门诊：297人
- 河埒门诊：108人
## 🔍 验证步骤
### 1. 检查数据完整性
```sql
-- 检查患者总数
SELECT COUNT(*) FROM patients;
-- 检查各门诊分布
SELECT clinic_name, COUNT(*) FROM patients GROUP BY clinic_name ORDER BY COUNT(*) DESC;
-- 检查是否有重复病历号
SELECT case_number, COUNT(*) FROM patients GROUP BY case_number HAVING COUNT(*) > 1;
```
### 2. 检查备份表
```sql
-- 查看备份表
SHOW TABLES LIKE 'patients_backup_%';
-- 检查备份数据
SELECT COUNT(*) FROM patients_backup_YYYYMMDD_HHMMSS;
```
### 3. 测试导出功能
```bash
# 测试导出功能
docker exec patient_callback_app python export_data.py
```
## 🚨 回滚方案
### 如果出现问题，可以回滚：
```sql
-- 1. 删除当前patients表
DROP TABLE patients;
-- 2. 恢复备份数据
RENAME TABLE patients_backup_YYYYMMDD_HHMMSS TO patients;
-- 3. 验证数据
SELECT COUNT(*) FROM patients;
```
## 📞 紧急联系
### 如果遇到问题：
1. **立即停止**所有操作
2. **不要删除**任何备份表
3. **联系**数据库管理员
4. **准备**回滚操作
## ✅ 部署检查清单
- [ ] 数据库完整备份完成
- [ ] 备份文件验证通过
- [ ] 代码部署完成
- [ ] 容器启动正常
- [ ] 安全导入脚本执行完成
- [ ] 数据完整性验证通过
- [ ] 导出功能测试通过
- [ ] 备份表确认存在
## 🎯 总结
**这个部署方案是100%安全的**：
- 不会丢失任何现有数据
- 自动备份所有数据
- 使用增量更新策略
- 支持随时回滚
**请严格按照步骤执行，确保生产环境数据安全！**
\ No newline at end of file
配置Docker镜像加速器.bat deleted 100644 → 0
@echo off ++ /dev/null
@echo off
echo 配置Docker镜像加速器...
echo.
echo 正在配置Docker镜像加速器...
echo 这将帮助解决网络连接问题
echo.
echo 请按以下步骤操作：
echo 1. 打开Docker Desktop
echo 2. 点击右上角设置图标
echo 3. 选择 "Docker Engine"
echo 4. 在配置文件中添加以下内容：
echo.
echo {
echo "registry-mirrors": [
echo "https://docker.mirrors.ustc.edu.cn",
echo "https://hub-mirror.c.163.com",
echo "https://mirror.baidubce.com"
echo ]
echo }
echo.
echo 5. 点击 "Apply & Restart"
echo 6. 等待Docker重启完成
echo.
pause
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment