587 lines
14 KiB
Go
587 lines
14 KiB
Go
package darwinv3
|
|
|
|
import (
|
|
"context"
|
|
"crypto/md5"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"github.com/sjzar/chatlog/internal/errors"
|
|
"github.com/sjzar/chatlog/internal/model"
|
|
"github.com/sjzar/chatlog/pkg/util"
|
|
)
|
|
|
|
const (
|
|
MessageFilePattern = "^msg_([0-9]?[0-9])?\\.db$"
|
|
ContactFilePattern = "^wccontact_new2\\.db$"
|
|
ChatRoomFilePattern = "^group_new\\.db$"
|
|
SessionFilePattern = "^session_new\\.db$"
|
|
MediaFilePattern = "^hldata\\.db$"
|
|
)
|
|
|
|
type DataSource struct {
|
|
path string
|
|
messageDbs []*sql.DB
|
|
contactDb *sql.DB
|
|
chatRoomDb *sql.DB
|
|
sessionDb *sql.DB
|
|
mediaDb *sql.DB
|
|
|
|
talkerDBMap map[string]*sql.DB
|
|
user2DisplayName map[string]string
|
|
}
|
|
|
|
func New(path string) (*DataSource, error) {
|
|
ds := &DataSource{
|
|
path: path,
|
|
messageDbs: make([]*sql.DB, 0),
|
|
talkerDBMap: make(map[string]*sql.DB),
|
|
user2DisplayName: make(map[string]string),
|
|
}
|
|
|
|
if err := ds.initMessageDbs(path); err != nil {
|
|
return nil, errors.DBInitFailed(err)
|
|
}
|
|
if err := ds.initContactDb(path); err != nil {
|
|
return nil, errors.DBInitFailed(err)
|
|
}
|
|
if err := ds.initChatRoomDb(path); err != nil {
|
|
return nil, errors.DBInitFailed(err)
|
|
}
|
|
if err := ds.initSessionDb(path); err != nil {
|
|
return nil, errors.DBInitFailed(err)
|
|
}
|
|
if err := ds.initMediaDb(path); err != nil {
|
|
return nil, errors.DBInitFailed(err)
|
|
}
|
|
|
|
return ds, nil
|
|
}
|
|
|
|
func (ds *DataSource) initMessageDbs(path string) error {
|
|
|
|
files, err := util.FindFilesWithPatterns(path, MessageFilePattern, true)
|
|
if err != nil {
|
|
return errors.DBFileNotFound(path, MessageFilePattern, err)
|
|
}
|
|
|
|
if len(files) == 0 {
|
|
return errors.DBFileNotFound(path, MessageFilePattern, nil)
|
|
}
|
|
|
|
// 处理每个数据库文件
|
|
for _, filePath := range files {
|
|
// 连接数据库
|
|
db, err := sql.Open("sqlite3", filePath)
|
|
if err != nil {
|
|
log.Err(err).Msgf("连接数据库 %s 失败", filePath)
|
|
continue
|
|
}
|
|
ds.messageDbs = append(ds.messageDbs, db)
|
|
|
|
// 获取所有表名
|
|
rows, err := db.Query("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'Chat_%'")
|
|
if err != nil {
|
|
log.Err(err).Msgf("数据库 %s 中没有 Chat 表", filePath)
|
|
continue
|
|
}
|
|
|
|
for rows.Next() {
|
|
var tableName string
|
|
if err := rows.Scan(&tableName); err != nil {
|
|
log.Err(err).Msgf("数据库 %s 扫描表名失败", filePath)
|
|
continue
|
|
}
|
|
|
|
// 从表名中提取可能的talker信息
|
|
talkerMd5 := extractTalkerFromTableName(tableName)
|
|
if talkerMd5 == "" {
|
|
continue
|
|
}
|
|
ds.talkerDBMap[talkerMd5] = db
|
|
}
|
|
rows.Close()
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ds *DataSource) initContactDb(path string) error {
|
|
|
|
files, err := util.FindFilesWithPatterns(path, ContactFilePattern, true)
|
|
if err != nil {
|
|
return errors.DBFileNotFound(path, ContactFilePattern, err)
|
|
}
|
|
|
|
if len(files) == 0 {
|
|
return errors.DBFileNotFound(path, ContactFilePattern, nil)
|
|
}
|
|
|
|
ds.contactDb, err = sql.Open("sqlite3", files[0])
|
|
if err != nil {
|
|
return errors.DBConnectFailed(files[0], err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (ds *DataSource) initChatRoomDb(path string) error {
|
|
files, err := util.FindFilesWithPatterns(path, ChatRoomFilePattern, true)
|
|
if err != nil {
|
|
return errors.DBFileNotFound(path, ChatRoomFilePattern, err)
|
|
}
|
|
if len(files) == 0 {
|
|
return errors.DBFileNotFound(path, ChatRoomFilePattern, nil)
|
|
}
|
|
ds.chatRoomDb, err = sql.Open("sqlite3", files[0])
|
|
if err != nil {
|
|
return errors.DBConnectFailed(files[0], err)
|
|
}
|
|
|
|
rows, err := ds.chatRoomDb.Query("SELECT m_nsUsrName, IFNULL(nickname,\"\") FROM GroupMember")
|
|
if err != nil {
|
|
log.Err(err).Msgf("数据库 %s 获取群聊成员失败", files[0])
|
|
return nil
|
|
}
|
|
|
|
for rows.Next() {
|
|
var user string
|
|
var nickName string
|
|
if err := rows.Scan(&user, &nickName); err != nil {
|
|
log.Err(err).Msgf("数据库 %s 扫描表名失败", files[0])
|
|
continue
|
|
}
|
|
ds.user2DisplayName[user] = nickName
|
|
}
|
|
rows.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (ds *DataSource) initSessionDb(path string) error {
|
|
files, err := util.FindFilesWithPatterns(path, SessionFilePattern, true)
|
|
if err != nil {
|
|
return errors.DBFileNotFound(path, SessionFilePattern, err)
|
|
}
|
|
if len(files) == 0 {
|
|
return errors.DBFileNotFound(path, SessionFilePattern, nil)
|
|
}
|
|
ds.sessionDb, err = sql.Open("sqlite3", files[0])
|
|
if err != nil {
|
|
return errors.DBConnectFailed(files[0], err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ds *DataSource) initMediaDb(path string) error {
|
|
files, err := util.FindFilesWithPatterns(path, MediaFilePattern, true)
|
|
if err != nil {
|
|
return errors.DBFileNotFound(path, MediaFilePattern, err)
|
|
}
|
|
if len(files) == 0 {
|
|
return errors.DBFileNotFound(path, MediaFilePattern, nil)
|
|
}
|
|
ds.mediaDb, err = sql.Open("sqlite3", files[0])
|
|
if err != nil {
|
|
return errors.DBConnectFailed(files[0], err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetMessages 实现获取消息的方法
|
|
func (ds *DataSource) GetMessages(ctx context.Context, startTime, endTime time.Time, talker string, limit, offset int) ([]*model.Message, error) {
|
|
// 在 darwinv3 中，每个联系人/群聊的消息存储在单独的表中，表名为 Chat_md5(talker)
|
|
// 首先需要找到对应的表名
|
|
if talker == "" {
|
|
return nil, errors.ErrTalkerEmpty
|
|
}
|
|
|
|
_talkerMd5Bytes := md5.Sum([]byte(talker))
|
|
talkerMd5 := hex.EncodeToString(_talkerMd5Bytes[:])
|
|
db, ok := ds.talkerDBMap[talkerMd5]
|
|
if !ok {
|
|
return nil, errors.TalkerNotFound(talker)
|
|
}
|
|
tableName := fmt.Sprintf("Chat_%s", talkerMd5)
|
|
|
|
// 构建查询条件
|
|
query := fmt.Sprintf(`
|
|
SELECT msgCreateTime, msgContent, messageType, mesDes
|
|
FROM %s
|
|
WHERE msgCreateTime >= ? AND msgCreateTime <= ?
|
|
ORDER BY msgCreateTime ASC
|
|
`, tableName)
|
|
|
|
if limit > 0 {
|
|
query += fmt.Sprintf(" LIMIT %d", limit)
|
|
|
|
if offset > 0 {
|
|
query += fmt.Sprintf(" OFFSET %d", offset)
|
|
}
|
|
}
|
|
|
|
// 执行查询
|
|
rows, err := db.QueryContext(ctx, query, startTime.Unix(), endTime.Unix())
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
// 处理查询结果
|
|
messages := []*model.Message{}
|
|
for rows.Next() {
|
|
var msg model.MessageDarwinV3
|
|
err := rows.Scan(
|
|
&msg.MsgCreateTime,
|
|
&msg.MsgContent,
|
|
&msg.MessageType,
|
|
&msg.MesDes,
|
|
)
|
|
if err != nil {
|
|
log.Err(err).Msgf("扫描消息行失败")
|
|
continue
|
|
}
|
|
|
|
// 将消息包装为通用模型
|
|
message := msg.Wrap(talker)
|
|
messages = append(messages, message)
|
|
}
|
|
|
|
return messages, nil
|
|
}
|
|
|
|
// 从表名中提取 talker
|
|
func extractTalkerFromTableName(tableName string) string {
|
|
|
|
if !strings.HasPrefix(tableName, "Chat_") {
|
|
return ""
|
|
}
|
|
|
|
if strings.HasSuffix(tableName, "_dels") {
|
|
return ""
|
|
}
|
|
|
|
return strings.TrimPrefix(tableName, "Chat_")
|
|
}
|
|
|
|
// GetContacts 实现获取联系人信息的方法
|
|
func (ds *DataSource) GetContacts(ctx context.Context, key string, limit, offset int) ([]*model.Contact, error) {
|
|
var query string
|
|
var args []interface{}
|
|
|
|
if key != "" {
|
|
// 按照关键字查询
|
|
query = `SELECT IFNULL(m_nsUsrName,""), IFNULL(nickname,""), IFNULL(m_nsRemark,""), m_uiSex, IFNULL(m_nsAliasName,"")
|
|
FROM WCContact
|
|
WHERE m_nsUsrName = ? OR nickname = ? OR m_nsRemark = ? OR m_nsAliasName = ?`
|
|
args = []interface{}{key, key, key, key}
|
|
} else {
|
|
// 查询所有联系人
|
|
query = `SELECT IFNULL(m_nsUsrName,""), IFNULL(nickname,""), IFNULL(m_nsRemark,""), m_uiSex, IFNULL(m_nsAliasName,"")
|
|
FROM WCContact`
|
|
}
|
|
|
|
// 添加排序、分页
|
|
query += ` ORDER BY m_nsUsrName`
|
|
if limit > 0 {
|
|
query += fmt.Sprintf(" LIMIT %d", limit)
|
|
if offset > 0 {
|
|
query += fmt.Sprintf(" OFFSET %d", offset)
|
|
}
|
|
}
|
|
|
|
// 执行查询
|
|
rows, err := ds.contactDb.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
contacts := []*model.Contact{}
|
|
for rows.Next() {
|
|
var contactDarwinV3 model.ContactDarwinV3
|
|
err := rows.Scan(
|
|
&contactDarwinV3.M_nsUsrName,
|
|
&contactDarwinV3.Nickname,
|
|
&contactDarwinV3.M_nsRemark,
|
|
&contactDarwinV3.M_uiSex,
|
|
&contactDarwinV3.M_nsAliasName,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, errors.ScanRowFailed(err)
|
|
}
|
|
|
|
contacts = append(contacts, contactDarwinV3.Wrap())
|
|
}
|
|
|
|
return contacts, nil
|
|
}
|
|
|
|
// GetChatRooms 实现获取群聊信息的方法
|
|
func (ds *DataSource) GetChatRooms(ctx context.Context, key string, limit, offset int) ([]*model.ChatRoom, error) {
|
|
var query string
|
|
var args []interface{}
|
|
|
|
if key != "" {
|
|
// 按照关键字查询
|
|
query = `SELECT IFNULL(m_nsUsrName,""), IFNULL(nickname,""), IFNULL(m_nsRemark,""), IFNULL(m_nsChatRoomMemList,""), IFNULL(m_nsChatRoomAdminList,"")
|
|
FROM GroupContact
|
|
WHERE m_nsUsrName = ? OR nickname = ? OR m_nsRemark = ?`
|
|
args = []interface{}{key, key, key}
|
|
} else {
|
|
// 查询所有群聊
|
|
query = `SELECT IFNULL(m_nsUsrName,""), IFNULL(nickname,""), IFNULL(m_nsRemark,""), IFNULL(m_nsChatRoomMemList,""), IFNULL(m_nsChatRoomAdminList,"")
|
|
FROM GroupContact`
|
|
}
|
|
|
|
// 添加排序、分页
|
|
query += ` ORDER BY m_nsUsrName`
|
|
if limit > 0 {
|
|
query += fmt.Sprintf(" LIMIT %d", limit)
|
|
if offset > 0 {
|
|
query += fmt.Sprintf(" OFFSET %d", offset)
|
|
}
|
|
}
|
|
|
|
// 执行查询
|
|
rows, err := ds.chatRoomDb.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
chatRooms := []*model.ChatRoom{}
|
|
for rows.Next() {
|
|
var chatRoomDarwinV3 model.ChatRoomDarwinV3
|
|
err := rows.Scan(
|
|
&chatRoomDarwinV3.M_nsUsrName,
|
|
&chatRoomDarwinV3.Nickname,
|
|
&chatRoomDarwinV3.M_nsRemark,
|
|
&chatRoomDarwinV3.M_nsChatRoomMemList,
|
|
&chatRoomDarwinV3.M_nsChatRoomAdminList,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, errors.ScanRowFailed(err)
|
|
}
|
|
|
|
chatRooms = append(chatRooms, chatRoomDarwinV3.Wrap(ds.user2DisplayName))
|
|
}
|
|
|
|
// 如果没有找到群聊，尝试通过联系人查找
|
|
if len(chatRooms) == 0 && key != "" {
|
|
contacts, err := ds.GetContacts(ctx, key, 1, 0)
|
|
if err == nil && len(contacts) > 0 && strings.HasSuffix(contacts[0].UserName, "@chatroom") {
|
|
// 再次尝试通过用户名查找群聊
|
|
rows, err := ds.chatRoomDb.QueryContext(ctx,
|
|
`SELECT IFNULL(m_nsUsrName,""), IFNULL(nickname,""), IFNULL(m_nsRemark,""), IFNULL(m_nsChatRoomMemList,""), IFNULL(m_nsChatRoomAdminList,"")
|
|
FROM GroupContact
|
|
WHERE m_nsUsrName = ?`,
|
|
contacts[0].UserName)
|
|
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var chatRoomDarwinV3 model.ChatRoomDarwinV3
|
|
err := rows.Scan(
|
|
&chatRoomDarwinV3.M_nsUsrName,
|
|
&chatRoomDarwinV3.Nickname,
|
|
&chatRoomDarwinV3.M_nsRemark,
|
|
&chatRoomDarwinV3.M_nsChatRoomMemList,
|
|
&chatRoomDarwinV3.M_nsChatRoomAdminList,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, errors.ScanRowFailed(err)
|
|
}
|
|
|
|
chatRooms = append(chatRooms, chatRoomDarwinV3.Wrap(ds.user2DisplayName))
|
|
}
|
|
|
|
// 如果群聊记录不存在，但联系人记录存在，创建一个模拟的群聊对象
|
|
if len(chatRooms) == 0 {
|
|
chatRooms = append(chatRooms, &model.ChatRoom{
|
|
Name: contacts[0].UserName,
|
|
Users: make([]model.ChatRoomUser, 0),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return chatRooms, nil
|
|
}
|
|
|
|
// GetSessions 实现获取会话信息的方法
|
|
func (ds *DataSource) GetSessions(ctx context.Context, key string, limit, offset int) ([]*model.Session, error) {
|
|
var query string
|
|
var args []interface{}
|
|
|
|
if key != "" {
|
|
// 按照关键字查询
|
|
query = `SELECT m_nsUserName, m_uLastTime
|
|
FROM SessionAbstract
|
|
WHERE m_nsUserName = ?`
|
|
args = []interface{}{key}
|
|
} else {
|
|
// 查询所有会话
|
|
query = `SELECT m_nsUserName, m_uLastTime
|
|
FROM SessionAbstract`
|
|
}
|
|
|
|
// 添加排序、分页
|
|
query += ` ORDER BY m_uLastTime DESC`
|
|
if limit > 0 {
|
|
query += fmt.Sprintf(" LIMIT %d", limit)
|
|
if offset > 0 {
|
|
query += fmt.Sprintf(" OFFSET %d", offset)
|
|
}
|
|
}
|
|
|
|
// 执行查询
|
|
rows, err := ds.sessionDb.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
sessions := []*model.Session{}
|
|
for rows.Next() {
|
|
var sessionDarwinV3 model.SessionDarwinV3
|
|
err := rows.Scan(
|
|
&sessionDarwinV3.M_nsUserName,
|
|
&sessionDarwinV3.M_uLastTime,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, errors.ScanRowFailed(err)
|
|
}
|
|
|
|
// 包装成通用模型
|
|
session := sessionDarwinV3.Wrap()
|
|
|
|
// 尝试获取联系人信息以补充会话信息
|
|
contacts, err := ds.GetContacts(ctx, session.UserName, 1, 0)
|
|
if err == nil && len(contacts) > 0 {
|
|
session.NickName = contacts[0].DisplayName()
|
|
} else {
|
|
// 尝试获取群聊信息
|
|
chatRooms, err := ds.GetChatRooms(ctx, session.UserName, 1, 0)
|
|
if err == nil && len(chatRooms) > 0 {
|
|
session.NickName = chatRooms[0].DisplayName()
|
|
}
|
|
}
|
|
|
|
sessions = append(sessions, session)
|
|
}
|
|
|
|
return sessions, nil
|
|
}
|
|
|
|
func (ds *DataSource) GetMedia(ctx context.Context, _type string, key string) (*model.Media, error) {
|
|
if key == "" {
|
|
return nil, errors.ErrKeyEmpty
|
|
}
|
|
query := `SELECT
|
|
r.mediaMd5,
|
|
r.mediaSize,
|
|
r.inodeNumber,
|
|
r.modifyTime,
|
|
d.relativePath,
|
|
d.fileName
|
|
FROM
|
|
HlinkMediaRecord r
|
|
JOIN
|
|
HlinkMediaDetail d ON r.inodeNumber = d.inodeNumber
|
|
WHERE
|
|
r.mediaMd5 = ?`
|
|
args := []interface{}{key}
|
|
// 执行查询
|
|
rows, err := ds.mediaDb.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, errors.QueryFailed(query, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var media *model.Media
|
|
for rows.Next() {
|
|
var mediaDarwinV3 model.MediaDarwinV3
|
|
err := rows.Scan(
|
|
&mediaDarwinV3.MediaMd5,
|
|
&mediaDarwinV3.MediaSize,
|
|
&mediaDarwinV3.InodeNumber,
|
|
&mediaDarwinV3.ModifyTime,
|
|
&mediaDarwinV3.RelativePath,
|
|
&mediaDarwinV3.FileName,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, errors.ScanRowFailed(err)
|
|
}
|
|
|
|
// 包装成通用模型
|
|
media = mediaDarwinV3.Wrap()
|
|
}
|
|
|
|
if media == nil {
|
|
return nil, errors.ErrMediaNotFound
|
|
}
|
|
|
|
return media, nil
|
|
}
|
|
|
|
// Close 实现关闭数据库连接的方法
|
|
func (ds *DataSource) Close() error {
|
|
var errs []error
|
|
|
|
// 关闭消息数据库连接
|
|
for _, db := range ds.messageDbs {
|
|
if err := db.Close(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
// 关闭联系人数据库连接
|
|
if ds.contactDb != nil {
|
|
if err := ds.contactDb.Close(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
// 关闭群聊数据库连接
|
|
if ds.chatRoomDb != nil {
|
|
if err := ds.chatRoomDb.Close(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
// 关闭会话数据库连接
|
|
if ds.sessionDb != nil {
|
|
if err := ds.sessionDb.Close(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
// 关闭媒体数据库连接
|
|
if ds.mediaDb != nil {
|
|
if err := ds.mediaDb.Close(); err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return errors.DBCloseFailed(errs[0])
|
|
}
|
|
|
|
return nil
|
|
}
|