|
|
"""
|
|
|
数据库操作模块
|
|
|
"""
|
|
|
import os
|
|
|
import sqlite3
|
|
|
import hashlib
|
|
|
from datetime import datetime, timezone, timedelta
|
|
|
from config import config
|
|
|
|
|
|
|
|
|
def beijing_now_str(fmt='%Y-%m-%d %H:%M:%S'):
|
|
|
"""返回北京时间字符串"""
|
|
|
return datetime.now(timezone(timedelta(hours=8))).strftime(fmt)
|
|
|
|
|
|
|
|
|
class Database:
|
|
|
def __init__(self):
|
|
|
self.db_path = config.get('database')
|
|
|
db_dir = os.path.dirname(self.db_path)
|
|
|
if db_dir and not os.path.exists(db_dir):
|
|
|
os.makedirs(db_dir, exist_ok=True)
|
|
|
self.init_database()
|
|
|
|
|
|
def get_connection(self):
|
|
|
conn = sqlite3.connect(self.db_path, check_same_thread=False)
|
|
|
conn.row_factory = sqlite3.Row
|
|
|
conn.execute("PRAGMA journal_mode=WAL")
|
|
|
conn.execute("PRAGMA foreign_keys=ON")
|
|
|
return conn
|
|
|
|
|
|
def init_database(self):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
|
|
|
cursor.execute('''
|
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
|
username VARCHAR(50) UNIQUE NOT NULL,
|
|
|
password VARCHAR(100) NOT NULL,
|
|
|
nickname VARCHAR(50),
|
|
|
avatar VARCHAR(200) DEFAULT 'default.png',
|
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
|
)''')
|
|
|
|
|
|
cursor.execute('''
|
|
|
CREATE TABLE IF NOT EXISTS friendships (
|
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
|
user_id INTEGER NOT NULL,
|
|
|
friend_id INTEGER NOT NULL,
|
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
|
FOREIGN KEY (user_id) REFERENCES users(id),
|
|
|
FOREIGN KEY (friend_id) REFERENCES users(id),
|
|
|
UNIQUE(user_id, friend_id)
|
|
|
)''')
|
|
|
|
|
|
cursor.execute('''
|
|
|
CREATE TABLE IF NOT EXISTS messages (
|
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
|
sender_id INTEGER NOT NULL,
|
|
|
receiver_id INTEGER,
|
|
|
group_id INTEGER,
|
|
|
content TEXT NOT NULL,
|
|
|
msg_type VARCHAR(20) DEFAULT 'text',
|
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
|
FOREIGN KEY (sender_id) REFERENCES users(id)
|
|
|
)''')
|
|
|
|
|
|
cursor.execute('''
|
|
|
CREATE TABLE IF NOT EXISTS groups (
|
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
|
name VARCHAR(100) NOT NULL,
|
|
|
creator_id INTEGER NOT NULL,
|
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
|
FOREIGN KEY (creator_id) REFERENCES users(id)
|
|
|
)''')
|
|
|
|
|
|
cursor.execute('''
|
|
|
CREATE TABLE IF NOT EXISTS group_members (
|
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
|
group_id INTEGER NOT NULL,
|
|
|
user_id INTEGER NOT NULL,
|
|
|
join_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
|
FOREIGN KEY (group_id) REFERENCES groups(id),
|
|
|
FOREIGN KEY (user_id) REFERENCES users(id),
|
|
|
UNIQUE(group_id, user_id)
|
|
|
)''')
|
|
|
|
|
|
# 默认管理员与测试用户
|
|
|
default_users = [
|
|
|
('admin', '123456', '系统管理员'),
|
|
|
('user1', '123456', '用户一'),
|
|
|
('user2', '123456', '用户二'),
|
|
|
('user3', '123456', '用户三'),
|
|
|
]
|
|
|
for username, password, nickname in default_users:
|
|
|
cursor.execute("SELECT id FROM users WHERE username=?", (username,))
|
|
|
if not cursor.fetchone():
|
|
|
pw = hashlib.md5(password.encode()).hexdigest()
|
|
|
cursor.execute(
|
|
|
"INSERT INTO users (username, password, nickname) VALUES (?,?,?)",
|
|
|
(username, pw, nickname))
|
|
|
|
|
|
conn.commit()
|
|
|
|
|
|
# 为新数据库填充测试数据：好友关系、群组、聊天记录
|
|
|
self._seed_test_data(conn)
|
|
|
|
|
|
conn.close()
|
|
|
|
|
|
def _seed_test_data(self, conn):
|
|
|
"""为新数据库填充测试数据（仅在数据为空时执行）"""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute("SELECT COUNT(*) FROM messages")
|
|
|
if cursor.fetchone()[0] > 0:
|
|
|
return # 已有数据，跳过
|
|
|
|
|
|
now = beijing_now_str()
|
|
|
cursor.execute("SELECT id, username FROM users")
|
|
|
users = {r[1]: r[0] for r in cursor.fetchall()}
|
|
|
uid = users.get
|
|
|
|
|
|
# 好友关系
|
|
|
friendships = [
|
|
|
('admin', 'user1'), ('admin', 'user2'),
|
|
|
('user1', 'user2'), ('user1', 'user3'), ('user2', 'user3'),
|
|
|
]
|
|
|
for a, b in friendships:
|
|
|
if a in users and b in users:
|
|
|
cursor.execute("INSERT OR IGNORE INTO friendships (user_id, friend_id) VALUES (?,?)",
|
|
|
(users[a], users[b]))
|
|
|
cursor.execute("INSERT OR IGNORE INTO friendships (user_id, friend_id) VALUES (?,?)",
|
|
|
(users[b], users[a]))
|
|
|
|
|
|
# 群组
|
|
|
cursor.execute("INSERT INTO groups (name, creator_id) VALUES (?,?)", ('技术交流群', users['admin']))
|
|
|
gid = cursor.lastrowid
|
|
|
for name in ['admin', 'user1', 'user2', 'user3']:
|
|
|
if name in users:
|
|
|
cursor.execute("INSERT OR IGNORE INTO group_members (group_id, user_id) VALUES (?,?)",
|
|
|
(gid, users[name]))
|
|
|
|
|
|
# 私聊消息
|
|
|
private_msgs = [
|
|
|
('admin', 'user1', '你好 user1，欢迎使用 SimpleChat！'),
|
|
|
('user1', 'admin', '你好管理员，这个系统看起来很不错！'),
|
|
|
('admin', 'user1', '是的，支持私聊、群聊、好友管理等功能'),
|
|
|
('user1', 'admin', '太棒了，我试试看群聊功能'),
|
|
|
('admin', 'user2', 'user2，最近在忙什么呢？'),
|
|
|
('user2', 'admin', '在研究 Python 网络编程，这个聊天系统是用什么写的？'),
|
|
|
('admin', 'user2', '用 Python + PyQt5 写的，TCP 通信'),
|
|
|
('user2', 'admin', '厉害！我也想学习一下'),
|
|
|
('user1', 'user2', 'hi user2，一起加个群聊吧'),
|
|
|
('user2', 'user1', '好啊，我正想找人聊天呢'),
|
|
|
('user1', 'user3', 'user3，好久不见'),
|
|
|
('user3', 'user1', '是啊好久不见，最近怎么样？'),
|
|
|
('user1', 'user3', '挺好的，这个聊天系统不错'),
|
|
|
('user3', 'user1', '确实，界面也挺好看的'),
|
|
|
]
|
|
|
for i, (sen, rec, content) in enumerate(private_msgs):
|
|
|
if sen in users and rec in users:
|
|
|
ts = f'2026-05-14 {9 + i // 6:02d}:{30 + i % 6 * 8:02d}:00'
|
|
|
cursor.execute(
|
|
|
"INSERT INTO messages (sender_id, receiver_id, content, created_at) VALUES (?,?,?,?)",
|
|
|
(users[sen], users[rec], content, ts))
|
|
|
|
|
|
# 群聊消息
|
|
|
group_msgs = [
|
|
|
('admin', '欢迎大家加入技术交流群！'),
|
|
|
('user1', '大家好，我是 user1，很高兴加入'),
|
|
|
('user2', '大家好！我是 user2'),
|
|
|
('user3', '各位好，我是 user3'),
|
|
|
('admin', '大家可以在群里交流技术问题'),
|
|
|
('user1', 'Python 的异步编程大家有研究吗？'),
|
|
|
('user2', '我最近在看 asyncio，感觉挺有意思的'),
|
|
|
('admin', 'asyncio 确实强大，适合高并发场景'),
|
|
|
('user3', '我主要做前端，PyQt5 的界面开发也可以交流'),
|
|
|
]
|
|
|
for i, (sen, content) in enumerate(group_msgs):
|
|
|
if sen in users:
|
|
|
ts = f'2026-05-14 {9 + i // 4:02d}:{40 + i % 4 * 8:02d}:00'
|
|
|
cursor.execute(
|
|
|
"INSERT INTO messages (sender_id, group_id, content, created_at) VALUES (?,?,?,?)",
|
|
|
(users[sen], gid, content, ts))
|
|
|
|
|
|
conn.commit()
|
|
|
|
|
|
# ── 用户 ──────────────────────────────────────────────
|
|
|
def user_register(self, username, password, nickname=None):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("SELECT id FROM users WHERE username=?", (username,))
|
|
|
if cursor.fetchone():
|
|
|
return False, "用户名已存在"
|
|
|
pw = hashlib.md5(password.encode()).hexdigest()
|
|
|
cursor.execute(
|
|
|
"INSERT INTO users (username, password, nickname) VALUES (?,?,?)",
|
|
|
(username, pw, nickname or username))
|
|
|
conn.commit()
|
|
|
return True, "注册成功"
|
|
|
except Exception as e:
|
|
|
return False, f"注册失败: {e}"
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def user_login(self, username, password):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
pw = hashlib.md5(password.encode()).hexdigest()
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users WHERE username=? AND password=?",
|
|
|
(username, pw))
|
|
|
user = cursor.fetchone()
|
|
|
if user:
|
|
|
return True, "登录成功", dict(user)
|
|
|
return False, "用户名或密码错误", None
|
|
|
except Exception as e:
|
|
|
return False, f"登录失败: {e}", None
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def change_username(self, user_id, new_username):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("SELECT id FROM users WHERE username=? AND id!=?", (new_username, user_id))
|
|
|
if cursor.fetchone():
|
|
|
return False, "用户名已被占用"
|
|
|
cursor.execute("UPDATE users SET username=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
|
|
|
(new_username, user_id))
|
|
|
conn.commit()
|
|
|
return True, "用户名修改成功"
|
|
|
except Exception as e:
|
|
|
return False, f"修改失败: {e}"
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def change_nickname(self, user_id, new_nickname):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("UPDATE users SET nickname=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
|
|
|
(new_nickname, user_id))
|
|
|
conn.commit()
|
|
|
return True, "昵称修改成功"
|
|
|
except Exception as e:
|
|
|
return False, f"修改失败: {e}"
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def change_password(self, user_id, old_password, new_password):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
old_pw = hashlib.md5(old_password.encode()).hexdigest()
|
|
|
cursor.execute("SELECT id FROM users WHERE id=? AND password=?", (user_id, old_pw))
|
|
|
if not cursor.fetchone():
|
|
|
return False, "原密码错误"
|
|
|
new_pw = hashlib.md5(new_password.encode()).hexdigest()
|
|
|
cursor.execute("UPDATE users SET password=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
|
|
|
(new_pw, user_id))
|
|
|
conn.commit()
|
|
|
return True, "密码修改成功"
|
|
|
except Exception as e:
|
|
|
return False, f"修改失败: {e}"
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_user_by_id(self, user_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users WHERE id=?", (user_id,))
|
|
|
user = cursor.fetchone()
|
|
|
conn.close()
|
|
|
return dict(user) if user else None
|
|
|
|
|
|
def get_user_by_username(self, username):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users WHERE username=?", (username,))
|
|
|
user = cursor.fetchone()
|
|
|
conn.close()
|
|
|
return dict(user) if user else None
|
|
|
|
|
|
def get_all_users(self, exclude_id=None):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
if exclude_id:
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users WHERE id!=? ORDER BY username",
|
|
|
(exclude_id,))
|
|
|
else:
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users ORDER BY username")
|
|
|
users = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return users
|
|
|
|
|
|
def search_users(self, keyword, exclude_id=None):
|
|
|
"""搜索用户（用户名或昵称模糊匹配）"""
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
like = f"%{keyword}%"
|
|
|
if exclude_id:
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users "
|
|
|
"WHERE id!=? AND (username LIKE ? OR nickname LIKE ?) ORDER BY username",
|
|
|
(exclude_id, like, like))
|
|
|
else:
|
|
|
cursor.execute(
|
|
|
"SELECT id, username, nickname, avatar FROM users "
|
|
|
"WHERE username LIKE ? OR nickname LIKE ? ORDER BY username",
|
|
|
(like, like))
|
|
|
users = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return users
|
|
|
|
|
|
# ── 好友 ──────────────────────────────────────────────
|
|
|
def add_friend(self, user_id, friend_username):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
friend = self.get_user_by_username(friend_username)
|
|
|
if not friend:
|
|
|
return False, "用户不存在"
|
|
|
friend_id = friend['id']
|
|
|
if user_id == friend_id:
|
|
|
return False, "不能添加自己为好友"
|
|
|
cursor.execute(
|
|
|
"SELECT id FROM friendships WHERE (user_id=? AND friend_id=?) OR (user_id=? AND friend_id=?)",
|
|
|
(user_id, friend_id, friend_id, user_id))
|
|
|
if cursor.fetchone():
|
|
|
return False, "已经是好友"
|
|
|
cursor.execute("INSERT INTO friendships (user_id, friend_id) VALUES (?,?)", (user_id, friend_id))
|
|
|
cursor.execute("INSERT INTO friendships (user_id, friend_id) VALUES (?,?)", (friend_id, user_id))
|
|
|
conn.commit()
|
|
|
return True, "添加好友成功"
|
|
|
except Exception as e:
|
|
|
return False, f"添加好友失败: {e}"
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_friends(self, user_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT u.id, u.username, u.nickname, u.avatar
|
|
|
FROM users u JOIN friendships f ON u.id = f.friend_id
|
|
|
WHERE f.user_id=? ORDER BY u.username
|
|
|
''', (user_id,))
|
|
|
friends = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return friends
|
|
|
|
|
|
def remove_friend(self, user_id, friend_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute(
|
|
|
"DELETE FROM friendships WHERE (user_id=? AND friend_id=?) OR (user_id=? AND friend_id=?)",
|
|
|
(user_id, friend_id, friend_id, user_id))
|
|
|
conn.commit()
|
|
|
return True, "已删除好友"
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
# ── 消息 ──────────────────────────────────────────────
|
|
|
def save_message(self, sender_id, receiver_id, content, msg_type='text', group_id=None):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
now = beijing_now_str()
|
|
|
cursor.execute(
|
|
|
"INSERT INTO messages (sender_id, receiver_id, group_id, content, msg_type, created_at) VALUES (?,?,?,?,?,?)",
|
|
|
(sender_id, receiver_id, group_id, content, msg_type, now))
|
|
|
conn.commit()
|
|
|
return True, cursor.lastrowid
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_chat_history(self, user1_id, user2_id, limit=50):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE ((m.sender_id=? AND m.receiver_id=?) OR (m.sender_id=? AND m.receiver_id=?))
|
|
|
AND m.group_id IS NULL
|
|
|
ORDER BY m.created_at ASC LIMIT ?
|
|
|
''', (user1_id, user2_id, user2_id, user1_id, limit))
|
|
|
messages = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return messages
|
|
|
|
|
|
def get_group_history(self, group_id, limit=50):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE m.group_id=?
|
|
|
ORDER BY m.created_at ASC LIMIT ?
|
|
|
''', (group_id, limit))
|
|
|
messages = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return messages
|
|
|
|
|
|
# ── 群组 ──────────────────────────────────────────────
|
|
|
def create_group(self, group_name, creator_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("INSERT INTO groups (name, creator_id) VALUES (?,?)", (group_name, creator_id))
|
|
|
group_id = cursor.lastrowid
|
|
|
cursor.execute("INSERT INTO group_members (group_id, user_id) VALUES (?,?)", (group_id, creator_id))
|
|
|
conn.commit()
|
|
|
return True, group_id
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_user_groups(self, user_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT g.id, g.name, g.creator_id
|
|
|
FROM groups g JOIN group_members gm ON g.id = gm.group_id
|
|
|
WHERE gm.user_id=? ORDER BY g.name
|
|
|
''', (user_id,))
|
|
|
groups = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return groups
|
|
|
|
|
|
def get_group_members(self, group_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT u.id, u.username, u.nickname, u.avatar
|
|
|
FROM users u JOIN group_members gm ON u.id = gm.user_id
|
|
|
WHERE gm.group_id=? ORDER BY u.username
|
|
|
''', (group_id,))
|
|
|
members = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return members
|
|
|
|
|
|
def join_group(self, group_id, user_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("SELECT id FROM groups WHERE id=?", (group_id,))
|
|
|
if not cursor.fetchone():
|
|
|
return False, "群组不存在"
|
|
|
cursor.execute(
|
|
|
"INSERT OR IGNORE INTO group_members (group_id, user_id) VALUES (?,?)",
|
|
|
(group_id, user_id))
|
|
|
conn.commit()
|
|
|
return True, "加入成功"
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_all_groups(self):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute("SELECT id, name, creator_id FROM groups ORDER BY name")
|
|
|
groups = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return groups
|
|
|
|
|
|
def leave_group(self, group_id, user_id):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("SELECT id FROM groups WHERE id=?", (group_id,))
|
|
|
if not cursor.fetchone():
|
|
|
return False, "群组不存在"
|
|
|
cursor.execute(
|
|
|
"DELETE FROM group_members WHERE group_id=? AND user_id=?",
|
|
|
(group_id, user_id))
|
|
|
if cursor.rowcount == 0:
|
|
|
return False, "你不在该群组中"
|
|
|
conn.commit()
|
|
|
return True, "已退出群组"
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def invite_to_group(self, group_id, username):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
try:
|
|
|
cursor.execute("SELECT id FROM groups WHERE id=?", (group_id,))
|
|
|
if not cursor.fetchone():
|
|
|
return False, "群组不存在"
|
|
|
user = self.get_user_by_username(username)
|
|
|
if not user:
|
|
|
return False, "用户不存在"
|
|
|
cursor.execute(
|
|
|
"SELECT id FROM group_members WHERE group_id=? AND user_id=?",
|
|
|
(group_id, user['id']))
|
|
|
if cursor.fetchone():
|
|
|
return False, "用户已在群组中"
|
|
|
cursor.execute(
|
|
|
"INSERT INTO group_members (group_id, user_id) VALUES (?,?)",
|
|
|
(group_id, user['id']))
|
|
|
conn.commit()
|
|
|
return True, f"已邀请 {username} 加入群组"
|
|
|
except Exception as e:
|
|
|
return False, str(e)
|
|
|
finally:
|
|
|
conn.close()
|
|
|
|
|
|
def get_all_user_history(self, user_id, limit=200):
|
|
|
"""获取用户的所有聊天记录（私聊+群聊），用于全局历史浏览"""
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, m.msg_type,
|
|
|
u.username as sender_name, u.nickname as sender_nick,
|
|
|
CASE WHEN m.group_id IS NOT NULL THEN g.name ELSE ru.username END as target_name,
|
|
|
CASE WHEN m.group_id IS NOT NULL THEN 'group' ELSE 'private' END as chat_type,
|
|
|
m.group_id, m.receiver_id
|
|
|
FROM messages m
|
|
|
JOIN users u ON m.sender_id = u.id
|
|
|
LEFT JOIN groups g ON m.group_id = g.id
|
|
|
LEFT JOIN users ru ON m.receiver_id = ru.id
|
|
|
WHERE (m.sender_id = ? OR m.receiver_id = ?
|
|
|
OR m.group_id IN (SELECT group_id FROM group_members WHERE user_id = ?))
|
|
|
ORDER BY m.created_at DESC LIMIT ?
|
|
|
''', (user_id, user_id, user_id, limit))
|
|
|
messages = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return messages
|
|
|
|
|
|
def get_recent_history(self, user_id, chat_type='private', target_id=None, limit=50):
|
|
|
"""获取与特定对象或群组的聊天记录"""
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
if chat_type == 'private':
|
|
|
friend = self.get_user_by_id(target_id) if target_id else None
|
|
|
if not friend:
|
|
|
return []
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE m.group_id IS NULL
|
|
|
AND ((m.sender_id=? AND m.receiver_id=?) OR (m.sender_id=? AND m.receiver_id=?))
|
|
|
ORDER BY m.created_at DESC LIMIT ?
|
|
|
''', (user_id, friend['id'], friend['id'], user_id, limit))
|
|
|
else:
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE m.group_id=?
|
|
|
ORDER BY m.created_at DESC LIMIT ?
|
|
|
''', (target_id, limit))
|
|
|
messages = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return messages
|
|
|
|
|
|
def search_messages(self, user_id, keyword, chat_type='private', target_id=None, limit=100):
|
|
|
conn = self.get_connection()
|
|
|
cursor = conn.cursor()
|
|
|
like = f"%{keyword}%"
|
|
|
if chat_type == 'private':
|
|
|
# target_id may be a username string (from client) or user_id int
|
|
|
friend = None
|
|
|
if isinstance(target_id, str) and not target_id.isdigit():
|
|
|
friend = self.get_user_by_username(target_id)
|
|
|
elif target_id is not None:
|
|
|
friend = self.get_user_by_id(int(target_id))
|
|
|
if not friend:
|
|
|
return []
|
|
|
friend_id = friend['id']
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, m.msg_type, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE m.group_id IS NULL
|
|
|
AND ((m.sender_id=? AND m.receiver_id=?) OR (m.sender_id=? AND m.receiver_id=?))
|
|
|
AND m.content LIKE ?
|
|
|
ORDER BY m.created_at DESC LIMIT ?
|
|
|
''', (user_id, friend_id, friend_id, user_id, like, limit))
|
|
|
else:
|
|
|
cursor.execute('''
|
|
|
SELECT m.id, m.content, m.created_at, m.msg_type, u.username, u.nickname
|
|
|
FROM messages m JOIN users u ON m.sender_id = u.id
|
|
|
WHERE m.group_id=? AND m.content LIKE ?
|
|
|
ORDER BY m.created_at DESC LIMIT ?
|
|
|
''', (target_id, like, limit))
|
|
|
messages = [dict(r) for r in cursor.fetchall()]
|
|
|
conn.close()
|
|
|
return messages
|
