725 lines
23 KiB
Python
725 lines
23 KiB
Python
import sqlite3
|
|
import json
|
|
import logging
|
|
import os
|
|
import threading
|
|
import datetime
|
|
import uuid
|
|
import random
|
|
|
|
# 配置日志
|
|
logging.basicConfig(
|
|
filename='db_adapter.log',
|
|
level=logging.INFO,
|
|
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
|
)
|
|
logger = logging.getLogger('db_adapter')
|
|
|
|
# 数据库文件路径
|
|
DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data", "warhammer.db")
|
|
|
|
# 线程本地存储，确保每个线程使用独立的数据库连接
|
|
_thread_local = threading.local()
|
|
|
|
def get_db_connection():
|
|
"""获取数据库连接（每个线程一个）"""
|
|
if not hasattr(_thread_local, 'connection'):
|
|
_thread_local.connection = sqlite3.connect(DB_PATH)
|
|
# 启用外键约束
|
|
_thread_local.connection.execute("PRAGMA foreign_keys = ON")
|
|
# 配置连接返回行为字典格式
|
|
_thread_local.connection.row_factory = sqlite3.Row
|
|
|
|
return _thread_local.connection
|
|
|
|
def close_db_connection():
|
|
"""关闭当前线程的数据库连接"""
|
|
if hasattr(_thread_local, 'connection'):
|
|
_thread_local.connection.close()
|
|
delattr(_thread_local, 'connection')
|
|
|
|
# 用户数据操作
|
|
def get_users():
|
|
"""获取所有用户数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("SELECT * FROM users")
|
|
users = [dict(row) for row in cursor.fetchall()]
|
|
return users
|
|
except Exception as e:
|
|
logger.error(f"获取用户数据失败: {str(e)}")
|
|
return []
|
|
|
|
def save_users(users):
|
|
"""保存用户数据（批量更新）"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
for user in users:
|
|
cursor.execute(
|
|
"INSERT OR REPLACE INTO users (id, username, password, created_at, high_score, total_games, last_year, last_game_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(
|
|
user['id'],
|
|
user['username'],
|
|
user['password'],
|
|
user.get('created_at', datetime.datetime.now().isoformat()),
|
|
user.get('high_score', 0),
|
|
user.get('total_games', 0),
|
|
user.get('last_year', 41000),
|
|
user.get('last_game_time', None)
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存用户数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 游戏状态操作
|
|
def get_game_states():
|
|
"""获取所有游戏状态数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("SELECT * FROM game_states")
|
|
rows = cursor.fetchall()
|
|
|
|
game_states = []
|
|
for row in rows:
|
|
state = dict(row)
|
|
# 将JSON字符串转换为字典
|
|
state['game_data'] = json.loads(state['game_data'])
|
|
game_states.append(state)
|
|
|
|
return game_states
|
|
except Exception as e:
|
|
logger.error(f"获取游戏状态数据失败: {str(e)}")
|
|
return []
|
|
|
|
def save_game_states(states):
|
|
"""保存游戏状态数据（批量更新）"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
for state in states:
|
|
# 将游戏数据转换为JSON字符串
|
|
game_data_json = json.dumps(state['game_data'], ensure_ascii=False)
|
|
|
|
cursor.execute(
|
|
"INSERT OR REPLACE INTO game_states (id, user_id, game_data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
|
|
(
|
|
state['id'],
|
|
state['user_id'],
|
|
game_data_json,
|
|
state.get('created_at', datetime.datetime.now().isoformat()),
|
|
state.get('updated_at', datetime.datetime.now().isoformat())
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存游戏状态数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 卡牌数据操作
|
|
def get_cards():
|
|
"""获取卡牌基础数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("SELECT cards_data FROM game_cards WHERE id = 1")
|
|
row = cursor.fetchone()
|
|
|
|
if row:
|
|
return json.loads(row['cards_data'])
|
|
else:
|
|
logger.warning("未找到卡牌数据，返回空字典")
|
|
return {}
|
|
except Exception as e:
|
|
logger.error(f"获取卡牌数据失败: {str(e)}")
|
|
return {}
|
|
|
|
# 自定义卡牌操作
|
|
def get_custom_cards():
|
|
"""获取自定义卡牌数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("""
|
|
SELECT c.*, vs.upvotes, vs.downvotes
|
|
FROM custom_cards c
|
|
LEFT JOIN card_vote_stats vs ON c.id = vs.card_id
|
|
""")
|
|
rows = cursor.fetchall()
|
|
|
|
cards = []
|
|
for row in rows:
|
|
card = {
|
|
'id': row['id'],
|
|
'title': row['title'],
|
|
'character': json.loads(row['character_data']),
|
|
'description': row['description'],
|
|
'option_a': json.loads(row['option_a']),
|
|
'option_b': json.loads(row['option_b']),
|
|
'creator_id': row['creator_id'],
|
|
'creator_name': row['creator_name'],
|
|
'created_at': row['created_at'],
|
|
'upvotes': row['upvotes'] or 0,
|
|
'downvotes': row['downvotes'] or 0
|
|
}
|
|
cards.append(card)
|
|
|
|
return {'cards': cards}
|
|
except Exception as e:
|
|
logger.error(f"获取自定义卡牌数据失败: {str(e)}")
|
|
return {'cards': []}
|
|
|
|
def save_custom_cards(data):
|
|
"""保存自定义卡牌数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
# 清空现有数据（可选，根据需要修改）
|
|
# cursor.execute("DELETE FROM custom_cards")
|
|
|
|
# 插入新数据
|
|
cards = data.get('cards', [])
|
|
for card in cards:
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO custom_cards
|
|
(id, title, character_data, description, option_a, option_b, creator_id, creator_name, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
|
|
(
|
|
card['id'],
|
|
card['title'],
|
|
json.dumps(card['character'], ensure_ascii=False),
|
|
card['description'],
|
|
json.dumps(card['option_a'], ensure_ascii=False),
|
|
json.dumps(card['option_b'], ensure_ascii=False),
|
|
card['creator_id'],
|
|
card['creator_name'],
|
|
card.get('created_at', datetime.datetime.now().isoformat())
|
|
)
|
|
)
|
|
|
|
# 确保有对应的投票统计记录
|
|
cursor.execute(
|
|
"INSERT OR IGNORE INTO card_vote_stats (card_id, upvotes, downvotes) VALUES (?, ?, ?)",
|
|
(card['id'], card.get('upvotes', 0), card.get('downvotes', 0))
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存自定义卡牌数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 卡牌投票操作
|
|
def get_card_votes():
|
|
"""获取卡牌投票数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 获取用户投票
|
|
cursor.execute("SELECT user_id, card_id, vote_type FROM card_votes")
|
|
vote_rows = cursor.fetchall()
|
|
|
|
user_votes = {}
|
|
for row in vote_rows:
|
|
user_id = row['user_id']
|
|
if user_id not in user_votes:
|
|
user_votes[user_id] = {}
|
|
user_votes[user_id][row['card_id']] = row['vote_type']
|
|
|
|
# 获取投票统计
|
|
cursor.execute("SELECT card_id, upvotes, downvotes FROM card_vote_stats")
|
|
stat_rows = cursor.fetchall()
|
|
|
|
card_votes = {}
|
|
for row in stat_rows:
|
|
card_id = row['card_id']
|
|
card_votes[card_id] = {
|
|
'upvotes': row['upvotes'] or 0,
|
|
'downvotes': row['downvotes'] or 0,
|
|
'users': {} # 这部分可能需要额外填充，取决于原来的数据结构
|
|
}
|
|
|
|
return {'user_votes': user_votes, 'card_votes': card_votes}
|
|
except Exception as e:
|
|
logger.error(f"获取卡牌投票数据失败: {str(e)}")
|
|
return {'user_votes': {}, 'card_votes': {}}
|
|
|
|
def save_card_votes(data):
|
|
"""保存卡牌投票数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
# 更新用户投票
|
|
user_votes = data.get('user_votes', {})
|
|
for user_id, votes in user_votes.items():
|
|
for card_id, vote_type in votes.items():
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO card_votes
|
|
(card_id, user_id, vote_type, created_at)
|
|
VALUES (?, ?, ?, ?)""",
|
|
(
|
|
card_id,
|
|
user_id,
|
|
vote_type,
|
|
datetime.datetime.now().isoformat()
|
|
)
|
|
)
|
|
|
|
# 更新投票统计
|
|
card_votes = data.get('card_votes', {})
|
|
for card_id, votes in card_votes.items():
|
|
cursor.execute(
|
|
"INSERT OR REPLACE INTO card_vote_stats (card_id, upvotes, downvotes) VALUES (?, ?, ?)",
|
|
(
|
|
card_id,
|
|
votes.get('upvotes', 0),
|
|
votes.get('downvotes', 0)
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存卡牌投票数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 会话操作
|
|
def get_sessions():
|
|
"""获取会话数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("SELECT * FROM sessions")
|
|
rows = cursor.fetchall()
|
|
|
|
active_sessions = []
|
|
for row in rows:
|
|
session = {
|
|
'user_id': row['user_id'],
|
|
'login_time': row['login_time'],
|
|
'last_activity': row['last_activity'],
|
|
'ip_address': row['ip_address'],
|
|
'status': row['status']
|
|
}
|
|
active_sessions.append(session)
|
|
|
|
return {'active_sessions': active_sessions}
|
|
except Exception as e:
|
|
logger.error(f"获取会话数据失败: {str(e)}")
|
|
return {'active_sessions': []}
|
|
|
|
def save_sessions(data):
|
|
"""保存会话数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
# 清空旧会话
|
|
cursor.execute("DELETE FROM sessions")
|
|
|
|
# 插入新会话
|
|
active_sessions = data.get('active_sessions', [])
|
|
for session in active_sessions:
|
|
# 生成会话ID
|
|
session_id = str(uuid.uuid4())
|
|
|
|
cursor.execute(
|
|
"""INSERT INTO sessions
|
|
(id, user_id, login_time, last_activity, ip_address, status)
|
|
VALUES (?, ?, ?, ?, ?, ?)""",
|
|
(
|
|
session_id,
|
|
session['user_id'],
|
|
session.get('login_time', datetime.datetime.now().isoformat()),
|
|
session.get('last_activity', datetime.datetime.now().isoformat()),
|
|
session.get('ip_address', ''),
|
|
session.get('status', 'idle')
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存会话数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 投票卡牌的实用函数
|
|
def vote_card(card_id, user_id, vote_type):
|
|
"""对卡牌进行投票或取消投票"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
# 检查是否已存在投票
|
|
cursor.execute("SELECT vote_type FROM card_votes WHERE card_id = ? AND user_id = ?", (card_id, user_id))
|
|
existing_vote = cursor.fetchone()
|
|
|
|
# 检查卡牌投票统计
|
|
cursor.execute("SELECT upvotes, downvotes FROM card_vote_stats WHERE card_id = ?", (card_id,))
|
|
vote_stats = cursor.fetchone()
|
|
|
|
upvotes = 0
|
|
downvotes = 0
|
|
|
|
if vote_stats:
|
|
upvotes = vote_stats['upvotes'] or 0
|
|
downvotes = vote_stats['downvotes'] or 0
|
|
|
|
new_vote = None
|
|
|
|
if vote_type == 'none' or (existing_vote and existing_vote['vote_type'] == vote_type):
|
|
# 取消投票
|
|
if existing_vote:
|
|
if existing_vote['vote_type'] == 'upvote':
|
|
upvotes = max(0, upvotes - 1)
|
|
else:
|
|
downvotes = max(0, downvotes - 1)
|
|
|
|
# 删除投票记录
|
|
cursor.execute("DELETE FROM card_votes WHERE card_id = ? AND user_id = ?", (card_id, user_id))
|
|
|
|
else:
|
|
# 如果之前投过票，先取消之前的投票
|
|
if existing_vote:
|
|
if existing_vote['vote_type'] == 'upvote':
|
|
upvotes = max(0, upvotes - 1)
|
|
else:
|
|
downvotes = max(0, downvotes - 1)
|
|
|
|
# 添加新投票
|
|
if vote_type == 'upvote':
|
|
upvotes += 1
|
|
new_vote = 'upvote'
|
|
else:
|
|
downvotes += 1
|
|
new_vote = 'downvote'
|
|
|
|
# 更新或添加投票记录
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO card_votes
|
|
(card_id, user_id, vote_type, created_at)
|
|
VALUES (?, ?, ?, ?)""",
|
|
(card_id, user_id, vote_type, datetime.datetime.now().isoformat())
|
|
)
|
|
|
|
# 更新投票统计
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO card_vote_stats
|
|
(card_id, upvotes, downvotes)
|
|
VALUES (?, ?, ?)""",
|
|
(card_id, upvotes, downvotes)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
|
|
return {
|
|
'success': True,
|
|
'upvotes': upvotes,
|
|
'downvotes': downvotes,
|
|
'newVote': new_vote
|
|
}
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"投票失败: {str(e)}")
|
|
return {
|
|
'success': False,
|
|
'error': str(e)
|
|
}
|
|
|
|
# 死亡场景操作
|
|
def get_death_scenarios(death_type=None):
|
|
"""获取死亡场景数据，可选按死亡类型筛选"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
if death_type:
|
|
cursor.execute("SELECT * FROM death_scenarios WHERE death_type = ?", (death_type,))
|
|
else:
|
|
cursor.execute("SELECT * FROM death_scenarios")
|
|
|
|
rows = cursor.fetchall()
|
|
|
|
scenarios = []
|
|
for row in rows:
|
|
scenario = {
|
|
'id': row['id'],
|
|
'death_type': row['death_type'],
|
|
'name': row['name'],
|
|
'weight': row['weight'] or 100,
|
|
'first_card': json.loads(row['first_card']),
|
|
'second_card': json.loads(row['second_card'])
|
|
}
|
|
scenarios.append(scenario)
|
|
|
|
return scenarios
|
|
except Exception as e:
|
|
logger.error(f"获取死亡场景数据失败: {str(e)}")
|
|
return []
|
|
|
|
def get_random_death_scenario(death_type):
|
|
"""根据死亡类型获取随机死亡场景，考虑权重"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 获取指定类型的所有死亡场景
|
|
cursor.execute("SELECT id, weight FROM death_scenarios WHERE death_type = ?", (death_type,))
|
|
scenarios = cursor.fetchall()
|
|
|
|
if not scenarios:
|
|
return None
|
|
|
|
# 计算权重总和
|
|
total_weight = sum(s['weight'] or 100 for s in scenarios)
|
|
|
|
# 随机选择一个场景，考虑权重
|
|
rand_val = random.randint(1, total_weight)
|
|
|
|
# 根据权重选择
|
|
current_weight = 0
|
|
selected_id = None
|
|
|
|
for scenario in scenarios:
|
|
current_weight += scenario['weight'] or 100
|
|
if rand_val <= current_weight:
|
|
selected_id = scenario['id']
|
|
break
|
|
|
|
# 获取选中的场景详情
|
|
if selected_id:
|
|
cursor.execute("SELECT * FROM death_scenarios WHERE id = ?", (selected_id,))
|
|
row = cursor.fetchone()
|
|
|
|
if row:
|
|
return {
|
|
'id': row['id'],
|
|
'death_type': row['death_type'],
|
|
'name': row['name'],
|
|
'weight': row['weight'] or 100,
|
|
'first_card': json.loads(row['first_card']),
|
|
'second_card': json.loads(row['second_card'])
|
|
}
|
|
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"获取随机死亡场景失败: {str(e)}")
|
|
return None
|
|
|
|
def save_death_scenarios(scenarios):
|
|
"""保存死亡场景数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
for scenario in scenarios:
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO death_scenarios
|
|
(id, death_type, name, weight, first_card, second_card)
|
|
VALUES (?, ?, ?, ?, ?, ?)""",
|
|
(
|
|
scenario['id'],
|
|
scenario['death_type'],
|
|
scenario['name'],
|
|
scenario.get('weight', 100),
|
|
json.dumps(scenario['first_card'], ensure_ascii=False),
|
|
json.dumps(scenario['second_card'], ensure_ascii=False)
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存死亡场景数据失败: {str(e)}")
|
|
return False
|
|
|
|
# 成就系统操作
|
|
def get_achievements():
|
|
"""获取所有成就数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("SELECT * FROM achievements")
|
|
rows = cursor.fetchall()
|
|
|
|
achievements = []
|
|
for row in rows:
|
|
achievement = {
|
|
'id': row['id'],
|
|
'name': row['name'],
|
|
'description': row['description'],
|
|
'icon': row['icon'],
|
|
'death_scenario_id': row['death_scenario_id'],
|
|
'hidden': row['hidden']
|
|
}
|
|
achievements.append(achievement)
|
|
|
|
return achievements
|
|
except Exception as e:
|
|
logger.error(f"获取成就数据失败: {str(e)}")
|
|
return []
|
|
|
|
def get_user_achievements(user_id):
|
|
"""获取用户已解锁的成就"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
cursor.execute("""
|
|
SELECT a.*, ua.unlock_time
|
|
FROM achievements a
|
|
JOIN user_achievements ua ON a.id = ua.achievement_id
|
|
WHERE ua.user_id = ?
|
|
""", (user_id,))
|
|
|
|
rows = cursor.fetchall()
|
|
|
|
unlocked = []
|
|
for row in rows:
|
|
achievement = {
|
|
'id': row['id'],
|
|
'name': row['name'],
|
|
'description': row['description'],
|
|
'icon': row['icon'],
|
|
'death_scenario_id': row['death_scenario_id'],
|
|
'unlock_time': row['unlock_time']
|
|
}
|
|
unlocked.append(achievement)
|
|
|
|
return unlocked
|
|
except Exception as e:
|
|
logger.error(f"获取用户成就数据失败: {str(e)}")
|
|
return []
|
|
|
|
def unlock_achievement(user_id, achievement_id):
|
|
"""解锁用户成就"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 检查成就是否存在
|
|
cursor.execute("SELECT id FROM achievements WHERE id = ?", (achievement_id,))
|
|
if not cursor.fetchone():
|
|
logger.error(f"成就不存在: {achievement_id}")
|
|
return False
|
|
|
|
# 检查用户是否已解锁该成就
|
|
cursor.execute(
|
|
"SELECT * FROM user_achievements WHERE user_id = ? AND achievement_id = ?",
|
|
(user_id, achievement_id)
|
|
)
|
|
|
|
if cursor.fetchone():
|
|
# 已解锁，无需重复操作
|
|
return True
|
|
|
|
# 解锁新成就
|
|
cursor.execute(
|
|
"""INSERT INTO user_achievements (user_id, achievement_id, unlock_time)
|
|
VALUES (?, ?, ?)""",
|
|
(
|
|
user_id,
|
|
achievement_id,
|
|
datetime.datetime.now().isoformat()
|
|
)
|
|
)
|
|
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
conn.rollback()
|
|
logger.error(f"解锁成就失败: {str(e)}")
|
|
return False
|
|
|
|
def save_achievements(achievements):
|
|
"""保存成就数据"""
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# 开始事务
|
|
conn.execute("BEGIN TRANSACTION")
|
|
|
|
for achievement in achievements:
|
|
cursor.execute(
|
|
"""INSERT OR REPLACE INTO achievements
|
|
(id, name, description, icon, death_scenario_id, hidden)
|
|
VALUES (?, ?, ?, ?, ?, ?)""",
|
|
(
|
|
achievement['id'],
|
|
achievement['name'],
|
|
achievement['description'],
|
|
achievement['icon'],
|
|
achievement.get('death_scenario_id'),
|
|
achievement.get('hidden', 0)
|
|
)
|
|
)
|
|
|
|
# 提交事务
|
|
conn.commit()
|
|
return True
|
|
except Exception as e:
|
|
# 回滚事务
|
|
conn.rollback()
|
|
logger.error(f"保存成就数据失败: {str(e)}")
|
|
return False |