1764 lines
48 KiB
Go
1764 lines
48 KiB
Go
package db
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
"xiawan/wx/api/req"
|
|
"xiawan/wx/clientsdk/baseinfo"
|
|
"xiawan/wx/db/table"
|
|
"xiawan/wx/protobuf/wechat"
|
|
pb "xiawan/wx/protobuf/wechat"
|
|
"xiawan/wx/srv"
|
|
"xiawan/wx/srv/srvconfig"
|
|
|
|
"github.com/go-sql-driver/mysql"
|
|
"github.com/jinzhu/gorm"
|
|
_ "github.com/jinzhu/gorm/dialects/mysql"
|
|
"github.com/lunny/log"
|
|
)
|
|
|
|
// MysqlDB MySQL数据库实例
|
|
var (
|
|
MysqlDB *gorm.DB
|
|
dbMutex sync.Mutex // 用于保护连接重置的互斥锁
|
|
contactMutex sync.Mutex // 联系人存储锁
|
|
mutexMap = make(map[string]*sync.Mutex) // 联系人存储锁
|
|
maxRetry = 10 // 最大重试次数
|
|
retryDelay = time.Second * 2 // 每次重试的间隔时间
|
|
)
|
|
|
|
// 联系人存储锁，uuid 区分
|
|
func getContactMutex(uuid string) *sync.Mutex {
|
|
contactMutex.Lock()
|
|
defer contactMutex.Unlock()
|
|
|
|
m, exists := mutexMap[uuid]
|
|
if !exists {
|
|
m = &sync.Mutex{}
|
|
mutexMap[uuid] = m
|
|
}
|
|
return m
|
|
}
|
|
|
|
// InitDB 初始化数据库
|
|
func InitDB() {
|
|
dbMutex.Lock() // 加锁，防止并发重连
|
|
defer dbMutex.Unlock()
|
|
var mysqlUrl = srvconfig.GlobalSetting.MysqlConnectStr
|
|
var err error
|
|
for i := 0; i < maxRetry; i++ {
|
|
MysqlDB, err = gorm.Open("mysql", mysqlUrl)
|
|
if err == nil {
|
|
break
|
|
}
|
|
fmt.Printf("Failed to connect MySQL, retrying... (%d/%d)\n", i+1, maxRetry)
|
|
time.Sleep(retryDelay)
|
|
}
|
|
if err != nil {
|
|
log.Errorf("Failed to connect MySQL after %d attempts: %v", maxRetry, err)
|
|
return
|
|
}
|
|
MysqlDB.DB().SetConnMaxLifetime(time.Minute * 5)
|
|
//设置连接池中的最大闲置连接数
|
|
MysqlDB.DB().SetMaxIdleConns(10)
|
|
//设置数据库的最大连接数量
|
|
MysqlDB.DB().SetMaxOpenConns(120)
|
|
|
|
fmt.Println("connect MySQL success")
|
|
MysqlDB.SingularTable(true)
|
|
MysqlDB.AutoMigrate(&table.UserInfoEntity{}) //用户信息 自动建表
|
|
MysqlDB.AutoMigrate(&table.DeviceInfoEntity{}) //设备信息 自动建表
|
|
MysqlDB.AutoMigrate(&table.UserLoginLog{}) //登录日志 自动建表
|
|
MysqlDB.AutoMigrate(&table.UserBusinessLog{}) //用户 自动建表
|
|
MysqlDB.AutoMigrate(&table.LicenseKey{}) //自动建表
|
|
MysqlDB.AutoMigrate(&table.UserMessageLog{}) //自动建表
|
|
MysqlDB.AutoMigrate(&table.Command{}) //自动建表
|
|
MysqlDB.AutoMigrate(&table.ModContactDB{}) //自动建表
|
|
MysqlDB.AutoMigrate(&table.AddMsgDB{}) //自动建表
|
|
MysqlDB.AutoMigrate(&table.ProxyMapping{}) //代理映射表 自动建表
|
|
MysqlDB.AutoMigrate(&table.MessageCallbackConfig{}) //消息回调配置表 自动建表
|
|
|
|
fmt.Println("auto create MySQL tables success")
|
|
MysqlDB.LogMode(false)
|
|
|
|
// 注意：回调配置的初始化移到了 InitAnewLogin 完成后
|
|
// 这样可以确保所有账号连接都已建立
|
|
}
|
|
|
|
// InitMessageCallbacks 初始化所有消息回调配置
|
|
func InitMessageCallbacks() {
|
|
// 账号已经初始化完成，稍微等待一下确保连接稳定
|
|
time.Sleep(3 * time.Second)
|
|
|
|
log.Infof("开始初始化消息回调配置...")
|
|
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
log.Errorf("Failed to initialize message callbacks: %v", err)
|
|
return
|
|
}
|
|
|
|
// 获取所有启用的回调配置
|
|
var configs []table.MessageCallbackConfig
|
|
result := MysqlDB.Where("enabled = ?", true).Find(&configs)
|
|
if result.Error != nil {
|
|
log.Errorf("Failed to query enabled callbacks: %v", result.Error)
|
|
return
|
|
}
|
|
|
|
if len(configs) == 0 {
|
|
log.Infof("未找到启用的消息回调配置")
|
|
return
|
|
}
|
|
|
|
log.Infof("找到 %d 个启用的回调配置，开始重新激活...", len(configs))
|
|
|
|
// 重新保存每个配置，相当于重新设置一遍，激活回调
|
|
successCount := 0
|
|
for _, config := range configs {
|
|
// 确保Key字段正确
|
|
if config.Key == "" {
|
|
config.Key = config.UUID
|
|
}
|
|
|
|
// 重新保存配置（相当于执行 SetCallback 操作）
|
|
err := SaveMessageCallbackConfig(&config)
|
|
if err != nil {
|
|
log.Errorf("✗ 重新激活回调失败 [UUID: %s]: %v", config.UUID, err)
|
|
} else {
|
|
log.Infof("✓ 重新激活回调成功 [UUID: %s] -> %s", config.UUID, config.CallbackURL)
|
|
successCount++
|
|
}
|
|
}
|
|
|
|
log.Infof("========================================")
|
|
log.Infof("回调配置激活完成: 成功 %d/%d", successCount, len(configs))
|
|
log.Infof("========================================")
|
|
}
|
|
|
|
// checkAndReconnect 检查并在需要时重新连接
|
|
func checkAndReconnect() error {
|
|
if MysqlDB == nil {
|
|
InitDB() // 初始化连接
|
|
}
|
|
|
|
// Ping数据库，验证连接是否有效
|
|
if err := MysqlDB.DB().Ping(); err != nil {
|
|
log.Error("Database connection lost, reconnecting...")
|
|
InitDB() // 重新连接
|
|
if MysqlDB == nil {
|
|
return errors.New("failed to reconnect to database")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Command 更新命令
|
|
func UpdateCommand(uuid string, key string, intValue int, strValue string) (bool, error) {
|
|
fmt.Println("UpdateCommand uuid:", uuid, "key:", key, "intValue:", intValue, "strValue:", strValue)
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return false, err
|
|
}
|
|
commandInfo := &table.Command{
|
|
UUID: uuid,
|
|
}
|
|
if err := MysqlDB.Model(commandInfo).Where("uuid = ?", uuid).First(&commandInfo).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
commandInfo.UUID = uuid
|
|
commandInfo.A301Str = ""
|
|
if err := MysqlDB.Create(&commandInfo).Error; err != nil {
|
|
// 创建失败
|
|
return false, err
|
|
}
|
|
// 创建成功，继续执行
|
|
}
|
|
// 错误
|
|
return false, err
|
|
}
|
|
// 记录找到
|
|
if key == "A101" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a101": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A102" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a102": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A103" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a103": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A104" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a104": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A104Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a104_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A105" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a105": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A106" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a106": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A107" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a107": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A109" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a109": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A111" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a111": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A116" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a116": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A116Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a116_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A118" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a118": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A118Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a118_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A301" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a301": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A301Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a301_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A401" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a401": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A402" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a402": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A403" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a403": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A601" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a601": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A801" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a801": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B001" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b001": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B001Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b001_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "A811" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"a811": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B002" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b002": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B002Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b002_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B003" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b003": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B003Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b003_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B004" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b004": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B004Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b004_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B005" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b005": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B005Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b005_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B006" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b006": intValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
if key == "B006Str" {
|
|
MysqlDB.Model(&table.Command{}).Where("uuid = ? ", uuid).Updates(map[string]interface{}{
|
|
"b006_str": strValue,
|
|
})
|
|
return true, nil
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// Command 根据 uuid 查询命令
|
|
func QueryCommand(uuid string) (table.Command, error) {
|
|
commandInfo := &table.Command{
|
|
UUID: uuid,
|
|
}
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return *commandInfo, err
|
|
}
|
|
|
|
if err := MysqlDB.Model(commandInfo).Where("uuid = ?", uuid).First(&commandInfo).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
commandInfo.UUID = uuid
|
|
commandInfo.A118Str = "词1,词2,词3"
|
|
commandInfo.A116Str = ""
|
|
commandInfo.A301Str = ""
|
|
commandInfo.B001Str = ""
|
|
commandInfo.B002Str = ""
|
|
commandInfo.B003Str = ""
|
|
if err := MysqlDB.Create(&commandInfo).Error; err != nil {
|
|
// 创建失败
|
|
return *commandInfo, err
|
|
}
|
|
// 创建成功，继续执行
|
|
}
|
|
// 错误
|
|
return *commandInfo, err
|
|
}
|
|
// 记录找到
|
|
return *commandInfo, nil
|
|
}
|
|
|
|
// 提交登录日志
|
|
func SetLoginLog(loginType string, acc *srv.WXAccount, errMsg string, state int32) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
var userName string
|
|
userInfo := acc.GetUserInfo()
|
|
if len(userInfo.LoginDataInfo.UserName) > 0 {
|
|
userName = userInfo.LoginDataInfo.UserName
|
|
} else {
|
|
userName = userInfo.WxId
|
|
}
|
|
|
|
// 更新登录时间信息
|
|
UpdateLoginTimeInfo(userInfo)
|
|
|
|
userLog := &table.UserLoginLog{
|
|
UUId: userInfo.UUID,
|
|
UserName: userName,
|
|
NickName: userInfo.NickName,
|
|
LoginType: loginType,
|
|
RetCode: state,
|
|
ErrMsg: errMsg,
|
|
}
|
|
userLog.TargetIp = srvconfig.GlobalSetting.TargetIp
|
|
MysqlDB.Save(userLog)
|
|
}
|
|
|
|
// UpdateLoginTimeInfo 更新用户的登录时间相关信息
|
|
func UpdateLoginTimeInfo(userInfo *baseinfo.UserInfo) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
_ = MysqlDB.Model(&table.UserInfoEntity{}).
|
|
Where("wxId = ? ", userInfo.WxId).
|
|
Updates(map[string]interface{}{
|
|
"device_create_time": userInfo.DeviceCreateTime,
|
|
"last_login_time": userInfo.LastLoginTime,
|
|
"last_auth_time": userInfo.LastAuthTime,
|
|
})
|
|
}
|
|
|
|
// 获取登录日志
|
|
func GetLoginJournal(userName string) []table.UserLoginLog {
|
|
|
|
logs := make([]table.UserLoginLog, 0)
|
|
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return logs
|
|
}
|
|
|
|
MysqlDB.Where("user_name=?", userName).Find(&logs)
|
|
|
|
return logs
|
|
}
|
|
|
|
// 获取登录错误信息
|
|
func GetUSerLoginErrMsg(userName string) string {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return ""
|
|
}
|
|
userInfoEntity := &table.UserInfoEntity{
|
|
WxId: userName,
|
|
}
|
|
MysqlDB.Model(userInfoEntity).First(userInfoEntity)
|
|
return userInfoEntity.ErrMsg
|
|
}
|
|
|
|
// 保存登录状态
|
|
func UpdateLoginStatus(userName string, state int32, errMsg string) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
data := make(map[string]interface{})
|
|
data["State"] = state //零值字段
|
|
data["ErrMsg"] = errMsg
|
|
v := GetUserInfoEntityByWxId(userName) // *table.UserInfoEntity
|
|
if v != nil && v.State != state {
|
|
MysqlDB.Model(&table.UserInfoEntity{
|
|
WxId: userName,
|
|
}).Update(data)
|
|
_ = PublishSyncMsgLoginState(userName, uint32(state))
|
|
}
|
|
}
|
|
|
|
// 保存初始化联系人结果
|
|
func UpdateInitContactStatus(uuid string, state int32) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
_ = MysqlDB.Model(&table.UserInfoEntity{}).
|
|
Where("uuid = ? ", uuid).
|
|
Updates(map[string]interface{}{
|
|
"initcontact": state,
|
|
})
|
|
}
|
|
|
|
// 查询初始化是否完成
|
|
func QueryInitContactStatus(uuid string) int32 {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return 1
|
|
}
|
|
|
|
var userInfoEntity table.UserInfoEntity
|
|
// 获取消息
|
|
if err := MysqlDB.Where("uuid = ?", uuid).First(&userInfoEntity).Error; err != nil {
|
|
return 1 // 发生其他错误
|
|
}
|
|
if userInfoEntity.InitContact == 0 {
|
|
fmt.Println("["+uuid+"]", "开始初始化联系人")
|
|
} else {
|
|
fmt.Println("["+uuid+"]", "无需初始化联系人")
|
|
}
|
|
return userInfoEntity.InitContact
|
|
}
|
|
|
|
// 更新同步消息Key
|
|
func UpdateSyncMsgKey() {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
// 更新用户信息
|
|
func UpdateUserInfo(userInfo *baseinfo.UserInfo) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
if userInfo.WxId == "" {
|
|
userInfo.WxId = userInfo.GetUserName()
|
|
}
|
|
var userInfoEntity table.UserInfoEntity
|
|
SimpleCopyProperties(&userInfoEntity, userInfo)
|
|
userInfoEntity.AutoAuthKey = base64.StdEncoding.EncodeToString(userInfo.AutoAuthKey)
|
|
userInfoEntity.SyncKey = base64.StdEncoding.EncodeToString(userInfo.SyncKey)
|
|
userInfoEntity.FavSyncKey = base64.StdEncoding.EncodeToString(userInfo.FavSyncKey)
|
|
userInfoEntity.TargetIp = srvconfig.GlobalSetting.TargetIp
|
|
userInfoEntity.UserName = userInfo.LoginDataInfo.UserName
|
|
userInfoEntity.Password = userInfo.LoginDataInfo.PassWord
|
|
userInfoEntity.State = int32(userInfo.GetLoginState())
|
|
// userInfoEntity.Proxy = userInfo.ProxyInfo.ProxyUrl
|
|
userInfoEntity.ClientVersion = userInfo.ClientVersion
|
|
if !(int(userInfoEntity.ClientVersion) > 0) {
|
|
userInfoEntity.ClientVersion = baseinfo.ClientVersion
|
|
}
|
|
// log.Infof("更新用户信息：%v", userInfoEntity.ClientVersion)
|
|
MysqlDB.Model(new(table.UserInfoEntity)).Update(&userInfoEntity)
|
|
}
|
|
|
|
// 更新用户信息，手机号和微信号
|
|
func UpdateUserInfoByPhone(modUserInfo *wechat.ModUserInfo) {
|
|
// 用户信息为空
|
|
if modUserInfo == nil {
|
|
return
|
|
}
|
|
// 微信id 为空
|
|
if modUserInfo.GetUserName() == nil {
|
|
return
|
|
}
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
wxId := modUserInfo.GetUserName().GetStr()
|
|
bindmobile := ""
|
|
if modUserInfo.GetBindMobile() != nil {
|
|
bindmobile = modUserInfo.GetBindMobile().GetStr()
|
|
}
|
|
alias := modUserInfo.GetAlias()
|
|
MysqlDB.Model(new(table.UserInfoEntity)).Where("wxId = ?", wxId).Updates(map[string]interface{}{
|
|
"bindmobile": bindmobile,
|
|
"alias": alias,
|
|
})
|
|
// wx_id
|
|
MysqlDB.Model(new(table.LicenseKey)).Where("wx_id = ?", wxId).Updates(map[string]interface{}{
|
|
"bindmobile": bindmobile,
|
|
"alias": alias,
|
|
})
|
|
}
|
|
|
|
// SaveUserInfo 保存用户信息
|
|
func SaveUserInfo(userInfo *baseinfo.UserInfo) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
|
|
if userInfo.WxId == "" {
|
|
userInfo.WxId = userInfo.GetUserName()
|
|
}
|
|
var userInfoEntity table.UserInfoEntity
|
|
SimpleCopyProperties(&userInfoEntity, userInfo)
|
|
userInfoEntity.AutoAuthKey = base64.StdEncoding.EncodeToString(userInfo.AutoAuthKey)
|
|
userInfoEntity.SyncKey = base64.StdEncoding.EncodeToString(userInfo.SyncKey)
|
|
userInfoEntity.FavSyncKey = base64.StdEncoding.EncodeToString(userInfo.FavSyncKey)
|
|
userInfoEntity.TargetIp = srvconfig.GlobalSetting.TargetIp
|
|
userInfoEntity.UserName = userInfo.LoginDataInfo.UserName
|
|
userInfoEntity.Password = userInfo.LoginDataInfo.PassWord
|
|
|
|
MysqlDB.Save(&userInfoEntity)
|
|
//判断是62还是A16
|
|
if strings.HasPrefix(userInfo.LoginDataInfo.LoginData, "A") {
|
|
//A16存redis
|
|
key := fmt.Sprintf("%s%s", "wechat:a16DeviceInfo:", userInfo.WxId)
|
|
error := SETExpirationObj(key, &userInfo.DeviceInfoA16, 60*60*24*15)
|
|
if error != nil {
|
|
log.Error("保存redis is error=" + error.Error())
|
|
}
|
|
} else {
|
|
//62存DB
|
|
var deviceInfoEntity table.DeviceInfoEntity
|
|
deviceInfoEntity.WxId = userInfo.WxId
|
|
SimpleCopyProperties(&deviceInfoEntity, userInfo.DeviceInfo)
|
|
deviceInfoEntity.SoftTypeXML = base64.StdEncoding.EncodeToString([]byte(deviceInfoEntity.SoftTypeXML))
|
|
deviceInfoEntity.ClientCheckDataXML = base64.StdEncoding.EncodeToString([]byte(deviceInfoEntity.ClientCheckDataXML))
|
|
MysqlDB.Save(&deviceInfoEntity)
|
|
}
|
|
}
|
|
|
|
// 获取所有登录用户
|
|
func QueryListUserInfo() []table.UserInfoEntity {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return make([]table.UserInfoEntity, 0)
|
|
}
|
|
// 判断 srvconfig.GlobalSetting.TargetIp 相同
|
|
var userInfoEntity = make([]table.UserInfoEntity, 0)
|
|
MysqlDB.Where("state = ? OR (state = 2 AND wxId IS NOT NULL AND wxId != '' AND autoauthkey IS NOT NULL AND autoauthkey != '')", 1).Find(&userInfoEntity)
|
|
for _, v := range userInfoEntity {
|
|
if v.State == 2 {
|
|
v.State = 1
|
|
}
|
|
}
|
|
// 过滤
|
|
var newUserInfoEntity = make([]table.UserInfoEntity, 0)
|
|
for _, v := range userInfoEntity {
|
|
if srvconfig.GlobalSetting.TargetIp == "" || v.TargetIp == srvconfig.GlobalSetting.TargetIp {
|
|
newUserInfoEntity = append(newUserInfoEntity, v)
|
|
}
|
|
}
|
|
return newUserInfoEntity
|
|
}
|
|
|
|
// 获取所有用户
|
|
func QueryUserList() []table.UserInfoEntity {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return make([]table.UserInfoEntity, 0)
|
|
}
|
|
var userInfoEntity = make([]table.UserInfoEntity, 0)
|
|
MysqlDB.Where("1=1").Find(&userInfoEntity)
|
|
return userInfoEntity
|
|
}
|
|
|
|
// GetUserInfoEntity 获取登录信息
|
|
func GetUserInfoEntity(uuid string) *table.UserInfoEntity {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
var userInfoEntity table.UserInfoEntity
|
|
if err := MysqlDB.Where("uuid=?", uuid).First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
return &userInfoEntity
|
|
}
|
|
|
|
// GetUserInfoEntity 获取登录信息
|
|
func GetUserInfoEntityByWxId(wxId string) *table.UserInfoEntity {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
var userInfoEntity table.UserInfoEntity
|
|
if err := MysqlDB.Where("wxId=?", wxId).First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
return &userInfoEntity
|
|
}
|
|
|
|
// GetUserInfo 从数据库获取UserInfo
|
|
func GetUserInfo(uuid string) *baseinfo.UserInfo {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
userInfo := &baseinfo.UserInfo{}
|
|
var userInfoEntity table.UserInfoEntity
|
|
userInfoEntity.UUID = uuid
|
|
if err := MysqlDB.First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
var deviceInfoEntity table.DeviceInfoEntity
|
|
deviceInfoEntity.WxId = userInfoEntity.WxId
|
|
if err := MysqlDB.First(&deviceInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
key := fmt.Sprintf("%s%s", "wechat:a16DeviceInfo:", userInfoEntity.WxId)
|
|
//判断是62还是A16
|
|
exists, _ := Exists(key)
|
|
if exists {
|
|
//A16存redis
|
|
deviceInfoA16 := &baseinfo.AndroidDeviceInfo{}
|
|
error := GETObj(key, &deviceInfoA16)
|
|
if error != nil {
|
|
log.Error("保存redis is error=" + error.Error())
|
|
}
|
|
userInfo.DeviceInfoA16 = deviceInfoA16
|
|
} else {
|
|
deviceInfo := &baseinfo.DeviceInfo{}
|
|
SimpleCopyProperties(deviceInfo, deviceInfoEntity)
|
|
decodeSoftTypeXML, _ := base64.StdEncoding.DecodeString(deviceInfo.SoftTypeXML)
|
|
deviceInfo.SoftTypeXML = string(decodeSoftTypeXML)
|
|
decodeClientCheckDataXML, _ := base64.StdEncoding.DecodeString(deviceInfo.ClientCheckDataXML)
|
|
deviceInfo.ClientCheckDataXML = string(decodeClientCheckDataXML)
|
|
userInfo.DeviceInfo = deviceInfo
|
|
}
|
|
SimpleCopyProperties(userInfo, userInfoEntity)
|
|
userInfo.AutoAuthKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.AutoAuthKey)
|
|
userInfo.SyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.SyncKey)
|
|
userInfo.FavSyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.FavSyncKey)
|
|
return userInfo
|
|
}
|
|
|
|
func GetUSerInfoByUUID(uuid string) *baseinfo.UserInfo {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
|
|
userInfo := &baseinfo.UserInfo{}
|
|
var userInfoEntity table.UserInfoEntity
|
|
userInfoEntity.UUID = uuid
|
|
|
|
if srvconfig.GlobalSetting.TargetIp != "" {
|
|
userInfoEntity.TargetIp = srvconfig.GlobalSetting.TargetIp
|
|
}
|
|
|
|
if err := MysqlDB.Model(&table.UserInfoEntity{}).Where(&userInfoEntity).First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
//判断是62还是A16
|
|
key := fmt.Sprintf("%s%s", "wechat:a16DeviceInfo:", userInfoEntity.WxId)
|
|
exists, _ := Exists(key)
|
|
if exists {
|
|
//A16存redis
|
|
deviceInfoA16 := &baseinfo.AndroidDeviceInfo{}
|
|
error := GETObj(key, &deviceInfoA16)
|
|
if error != nil {
|
|
log.Error("保存redis is error=" + error.Error())
|
|
}
|
|
userInfo.DeviceInfoA16 = deviceInfoA16
|
|
} else {
|
|
var deviceInfoEntity table.DeviceInfoEntity
|
|
deviceInfoEntity.WxId = userInfoEntity.WxId
|
|
if err := MysqlDB.First(&deviceInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
deviceInfo := &baseinfo.DeviceInfo{}
|
|
SimpleCopyProperties(deviceInfo, deviceInfoEntity)
|
|
decodeSoftTypeXML, _ := base64.StdEncoding.DecodeString(deviceInfo.SoftTypeXML)
|
|
deviceInfo.SoftTypeXML = string(decodeSoftTypeXML)
|
|
decodeClientCheckDataXML, _ := base64.StdEncoding.DecodeString(deviceInfo.ClientCheckDataXML)
|
|
deviceInfo.ClientCheckDataXML = string(decodeClientCheckDataXML)
|
|
userInfo.DeviceInfo = deviceInfo
|
|
}
|
|
|
|
SimpleCopyProperties(userInfo, userInfoEntity)
|
|
userInfo.AutoAuthKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.AutoAuthKey)
|
|
userInfo.SyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.SyncKey)
|
|
userInfo.FavSyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.FavSyncKey)
|
|
userInfo.SetLoginState(uint32(userInfoEntity.State))
|
|
|
|
userInfo.ClientVersion = userInfoEntity.ClientVersion
|
|
if !(int(userInfo.ClientVersion) > 0) {
|
|
userInfo.ClientVersion = baseinfo.ClientVersion
|
|
userInfoEntity.ClientVersion = baseinfo.ClientVersion
|
|
}
|
|
return userInfo
|
|
}
|
|
|
|
// GetUserInfoByWXID 从数据库获取UserInfo
|
|
func GetUserInfoByWXID(wxID string) *baseinfo.UserInfo {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
userInfo := &baseinfo.UserInfo{}
|
|
var userInfoEntity table.UserInfoEntity
|
|
userInfoEntity.WxId = wxID
|
|
if err := MysqlDB.First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
key := fmt.Sprintf("%s%s", "wechat:a16DeviceInfo:", wxID)
|
|
exists, _ := Exists(key)
|
|
if exists {
|
|
//A16存redis
|
|
key := fmt.Sprintf("%s%s", "wechat:a16DeviceInfo:", wxID)
|
|
deviceInfoA16 := &baseinfo.AndroidDeviceInfo{}
|
|
error := GETObj(key, &deviceInfoA16)
|
|
if error != nil {
|
|
log.Error("获取redis is error=" + error.Error())
|
|
}
|
|
userInfo.DeviceInfoA16 = deviceInfoA16
|
|
} else {
|
|
var deviceInfoEntity table.DeviceInfoEntity
|
|
deviceInfoEntity.WxId = userInfoEntity.WxId
|
|
if err := MysqlDB.First(&deviceInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
deviceInfo := &baseinfo.DeviceInfo{}
|
|
SimpleCopyProperties(deviceInfo, deviceInfoEntity)
|
|
decodeSoftTypeXML, _ := base64.StdEncoding.DecodeString(deviceInfo.SoftTypeXML)
|
|
deviceInfo.SoftTypeXML = string(decodeSoftTypeXML)
|
|
decodeClientCheckDataXML, _ := base64.StdEncoding.DecodeString(deviceInfo.ClientCheckDataXML)
|
|
deviceInfo.ClientCheckDataXML = string(decodeClientCheckDataXML)
|
|
userInfo.DeviceInfo = deviceInfo
|
|
}
|
|
SimpleCopyProperties(userInfo, userInfoEntity)
|
|
userInfo.AutoAuthKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.AutoAuthKey)
|
|
userInfo.SyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.SyncKey)
|
|
userInfo.FavSyncKey, _ = base64.StdEncoding.DecodeString(userInfoEntity.FavSyncKey)
|
|
return userInfo
|
|
}
|
|
|
|
// GetDeviceInfo 根据URLkey查询DeviceInfo 查不到返回nil
|
|
func GetDeviceInfo(queryKey string) *baseinfo.DeviceInfo {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
var userInfoEntity table.UserInfoEntity
|
|
MysqlDB.Where("querykey = ?", "queryKey").First(&userInfoEntity)
|
|
var count int
|
|
MysqlDB.Model(&table.UserInfoEntity{}).Where("querykey = ?", "queryKey").Count(&count)
|
|
if count == 0 {
|
|
return nil
|
|
}
|
|
|
|
deviceInfo := &baseinfo.DeviceInfo{}
|
|
_ = SimpleCopyProperties(deviceInfo, userInfoEntity)
|
|
return deviceInfo
|
|
}
|
|
|
|
// SimpleCopyProperties 拷贝属性
|
|
func SimpleCopyProperties(dst, src interface{}) (err error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
// 防止意外panic
|
|
defer func() {
|
|
if e := recover(); e != nil {
|
|
err = fmt.Errorf("%v", e)
|
|
}
|
|
}()
|
|
|
|
dstType, dstValue := reflect.TypeOf(dst), reflect.ValueOf(dst)
|
|
srcType, srcValue := reflect.TypeOf(src), reflect.ValueOf(src)
|
|
|
|
// dst必须结构体指针类型
|
|
if dstType.Kind() != reflect.Ptr || dstType.Elem().Kind() != reflect.Struct {
|
|
return errors.New("dst type should be a struct pointer")
|
|
}
|
|
|
|
// src必须为结构体或者结构体指针
|
|
if srcType.Kind() == reflect.Ptr {
|
|
srcType, srcValue = srcType.Elem(), srcValue.Elem()
|
|
}
|
|
if srcType.Kind() != reflect.Struct {
|
|
return errors.New("src type should be a struct or a struct pointer")
|
|
}
|
|
|
|
// 取具体内容
|
|
dstType, dstValue = dstType.Elem(), dstValue.Elem()
|
|
|
|
// 属性个数
|
|
propertyNums := dstType.NumField()
|
|
|
|
for i := 0; i < propertyNums; i++ {
|
|
// 属性
|
|
property := dstType.Field(i)
|
|
// 待填充属性值
|
|
propertyValue := srcValue.FieldByName(property.Name)
|
|
|
|
// 无效，说明src没有这个属性 || 属性同名但类型不同
|
|
if !propertyValue.IsValid() || property.Type != propertyValue.Type() {
|
|
// 确保 propertyValue 是有效的并且类型支持 Name() 方法
|
|
if propertyValue.IsValid() && propertyValue.Kind() == reflect.Struct {
|
|
if propertyValue.Type().Name() == "LocalTime" {
|
|
// 数据库字段为 LocalTime 类型结构体
|
|
if !dstValue.Field(i).CanSet() {
|
|
continue
|
|
}
|
|
dstValue.Field(i).Set(propertyValue.Field(0))
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
if dstValue.Field(i).CanSet() {
|
|
dstValue.Field(i).Set(propertyValue)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// IsLicenseBind 查询许可证是否绑定
|
|
func IsLicenseBind(license string) (*table.LicenseKey, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
var licenseKey table.LicenseKey
|
|
result := MysqlDB.Where("license = ? AND status = 1", license).First(&licenseKey)
|
|
if result.Error != nil {
|
|
if result.Error == gorm.ErrRecordNotFound {
|
|
return nil, nil
|
|
}
|
|
return nil, result.Error
|
|
}
|
|
return &licenseKey, nil
|
|
}
|
|
|
|
// UpdateLicenseBindStatus 更新许可证绑定状态
|
|
func UpdateLicenseBindStatus(deviceToken, license string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
result := MysqlDB.Model(&table.LicenseKey{}).Where("license = ? ", license).Updates(map[string]interface{}{
|
|
"device_token": deviceToken,
|
|
})
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 如果没有过期时间，则生成过期时间
|
|
func UpdateLicenseExpiryDate(license string) (*table.LicenseKey, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
var licenseKey table.LicenseKey
|
|
|
|
resultObj := MysqlDB.Where("license = ?", license).First(&licenseKey)
|
|
if resultObj.Error != nil {
|
|
if resultObj.Error == gorm.ErrRecordNotFound {
|
|
return &licenseKey, nil
|
|
}
|
|
return &licenseKey, resultObj.Error
|
|
}
|
|
if licenseKey.ExpiryDate == "" {
|
|
// 生成过期时间
|
|
licenseKey.ExpiryDate = generateExpiryDate3(licenseKey.Type)
|
|
// 生成开始时间
|
|
licenseKey.StartDate = time.Now().Format("2006-01-02 15:04:05")
|
|
result := MysqlDB.Model(&table.LicenseKey{}).Where("license = ?", license).Updates(map[string]interface{}{
|
|
"expiry_date": licenseKey.ExpiryDate,
|
|
"start_date": licenseKey.StartDate,
|
|
})
|
|
|
|
if result.Error != nil {
|
|
return &licenseKey, result.Error
|
|
}
|
|
}
|
|
|
|
return &licenseKey, nil
|
|
}
|
|
|
|
// 绑定微信
|
|
func UpdateLicenseBindWxid(wxid, nickName, license string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
MysqlDB.Model(&table.LicenseKey{}).Where("license = ? AND status = 0", license).Updates(map[string]interface{}{
|
|
"status": 1,
|
|
"wx_id": wxid,
|
|
"nick_name": nickName,
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
// HasLicense 查询是否存在许可证
|
|
func HasLicense(license string) (*table.LicenseKey, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
var licenseKey table.LicenseKey
|
|
result := MysqlDB.Where("license = ?", license).First(&licenseKey)
|
|
if result.Error != nil {
|
|
if result.Error == gorm.ErrRecordNotFound {
|
|
return nil, nil
|
|
}
|
|
return nil, result.Error
|
|
}
|
|
return &licenseKey, nil
|
|
}
|
|
|
|
// CheckExpiry 检查日期是否过期
|
|
func CheckExpiry(expiryDateString string, itype int) bool {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return false
|
|
}
|
|
//1日 7 周 30月 90季 180 半年 365年 30000
|
|
types := []int{1, 7, 30, 90, 180, 365, 30000}
|
|
// 判断 itype 在 types 中
|
|
isType := false
|
|
for _, t := range types {
|
|
if t == itype {
|
|
isType = true
|
|
break
|
|
}
|
|
}
|
|
// type 类型存在 同时 不存在 过期时间
|
|
if isType && expiryDateString == "" {
|
|
return false
|
|
}
|
|
// 将字符串解析为时间对象
|
|
expiryDate, err := time.Parse("2006-01-02", expiryDateString)
|
|
if err != nil {
|
|
fmt.Println("Error parsing expiry date:", err)
|
|
return false
|
|
}
|
|
|
|
// 获取当前时间
|
|
currentTime := time.Now()
|
|
|
|
// 比较过期日期和当前日期
|
|
if expiryDate.Before(currentTime) {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func generateExpiryDate(expiryDays int) string {
|
|
// 获取当前日期
|
|
currentDate := time.Now()
|
|
// 计算有效期后的日期
|
|
expiryDate := currentDate.AddDate(0, 0, expiryDays)
|
|
// 格式化日期字符串
|
|
expiryDateStr := expiryDate.Format("2006-01-02")
|
|
return expiryDateStr
|
|
}
|
|
|
|
// generateExpiryDate 根据特定时间段生成有效期日期
|
|
func generateExpiryDate3(duration int) string {
|
|
// 获取当前日期
|
|
currentDate := time.Now()
|
|
|
|
var expiryDate time.Time
|
|
|
|
// 根据输入的周期计算有效期后的日期
|
|
switch duration {
|
|
case 1:
|
|
expiryDate = currentDate.AddDate(0, 0, 1)
|
|
case 7:
|
|
expiryDate = currentDate.AddDate(0, 0, 7)
|
|
case 30:
|
|
expiryDate = currentDate.AddDate(0, 1, 0)
|
|
case 90:
|
|
expiryDate = currentDate.AddDate(0, 3, 0)
|
|
case 180:
|
|
expiryDate = currentDate.AddDate(0, 6, 0)
|
|
case 365:
|
|
expiryDate = currentDate.AddDate(1, 0, 0)
|
|
case 30000:
|
|
expiryDate = currentDate.AddDate(100, 0, 0)
|
|
default:
|
|
// 默认过期，时间为当前日期的前10天
|
|
expiryDate = currentDate.AddDate(0, 0, -10)
|
|
}
|
|
|
|
// 格式化日期字符串
|
|
expiryDateStr := expiryDate.Format("2006-01-02")
|
|
return expiryDateStr
|
|
}
|
|
|
|
//func generateActivationCode(length int, count int) []string {
|
|
// activationCodes := make([]string, count)
|
|
//
|
|
// for i := 0; i < count; i++ {
|
|
// code := generateSingleActivationCode()
|
|
// activationCodes[i] = code
|
|
// }
|
|
//
|
|
// return activationCodes
|
|
//}
|
|
|
|
func generateSingleActivationCode() string {
|
|
chars := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
var sb strings.Builder
|
|
for i := 0; i < 20; i++ {
|
|
sb.WriteByte(chars[rand.Intn(len(chars))])
|
|
}
|
|
return sb.String()
|
|
}
|
|
|
|
// generateRandomString 生成指定长度的随机字符串
|
|
func generateRandomString(length int) string {
|
|
// 设置种子（仅需设置一次）
|
|
rand.Seed(time.Now().UnixNano())
|
|
// 定义字符集
|
|
charset := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
var builder strings.Builder
|
|
for i := 0; i < length; i++ {
|
|
builder.WriteByte(charset[rand.Intn(len(charset))]) // 从字符集中随机选择一个字符
|
|
}
|
|
return builder.String()
|
|
}
|
|
|
|
func CreateLicense(count, expiryDays int) string {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return ""
|
|
}
|
|
ExpiryDate := generateExpiryDate(expiryDays)
|
|
licenses := make([]string, 0, count)
|
|
for {
|
|
if count == 0 {
|
|
break
|
|
}
|
|
if len(licenses) >= count {
|
|
break
|
|
}
|
|
//key := generateSingleActivationCode()
|
|
// key := guuid.New().String()
|
|
key := "HB" + generateRandomString(10)
|
|
licenseKey := table.LicenseKey{
|
|
Status: 0,
|
|
License: key,
|
|
ExpiryDate: ExpiryDate,
|
|
}
|
|
result := MysqlDB.Create(&licenseKey)
|
|
if result.Error != nil {
|
|
if mysqlErr, ok := result.Error.(*mysql.MySQLError); ok {
|
|
if mysqlErr.Number == 1062 {
|
|
// 唯一性 License 冲突
|
|
fmt.Println("License key already exists!")
|
|
continue
|
|
}
|
|
}
|
|
fmt.Println("failed to create license key")
|
|
break
|
|
}
|
|
|
|
licenses = append(licenses, key)
|
|
}
|
|
return strings.Join(licenses, "\n\t")
|
|
}
|
|
|
|
func CreateLicense3(count, itype int) string {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return ""
|
|
}
|
|
// ExpiryDate := generateExpiryDate(itype)
|
|
licenses := make([]string, 0, count)
|
|
for {
|
|
if count == 0 {
|
|
break
|
|
}
|
|
if len(licenses) >= count {
|
|
break
|
|
}
|
|
//key := generateSingleActivationCode()
|
|
// key := guuid.New().String()
|
|
key := "HB" + generateRandomString(10)
|
|
licenseKey := table.LicenseKey{
|
|
Status: 0,
|
|
License: key,
|
|
ExpiryDate: "",
|
|
Type: itype,
|
|
}
|
|
result := MysqlDB.Create(&licenseKey)
|
|
if result.Error != nil {
|
|
if mysqlErr, ok := result.Error.(*mysql.MySQLError); ok {
|
|
if mysqlErr.Number == 1062 {
|
|
// 唯一性 License 冲突
|
|
fmt.Println("License key already exists!")
|
|
continue
|
|
}
|
|
}
|
|
fmt.Println("failed to create license key")
|
|
break
|
|
}
|
|
|
|
licenses = append(licenses, key)
|
|
}
|
|
return strings.Join(licenses, "\n\t")
|
|
|
|
}
|
|
|
|
func DelayLicense(m req.DelayAuthKeyModel) (string, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return "", err
|
|
}
|
|
origin, err := HasLicense(m.Key)
|
|
if origin == nil || err != nil {
|
|
return "", errors.New(fmt.Sprintf("%s 该 key 无效! 请 检查正确性 或 联系管理员生成", m.Key))
|
|
}
|
|
|
|
expiryDateStr := origin.ExpiryDate
|
|
if m.Days > 0 {
|
|
// 获取当前的过期日期
|
|
originDate, err := time.Parse("2006-01-02", origin.ExpiryDate)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
// 计算延期后的日期
|
|
expiryDate := originDate.AddDate(0, 0, m.Days)
|
|
// 格式化日期字符串
|
|
expiryDateStr = expiryDate.Format("2006-01-02")
|
|
} else {
|
|
expiryDateStr = m.ExpiryDate
|
|
}
|
|
|
|
result := MysqlDB.Model(&table.LicenseKey{}).
|
|
Where("license = ?", origin.License).
|
|
Updates(map[string]interface{}{
|
|
"expiry_date": expiryDateStr,
|
|
})
|
|
|
|
if result.Error != nil {
|
|
return "", result.Error
|
|
}
|
|
return expiryDateStr, nil
|
|
}
|
|
|
|
func DeleteLicense(key string, opt int) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
has, err := HasLicense(key)
|
|
if has == nil || err != nil {
|
|
return errors.New(fmt.Sprintf("%s 该 key 无效! 请 检查正确性 或 联系管理员生成", key))
|
|
}
|
|
|
|
// 目前仅支持 0 1 2 三个删除操作 新增不删除授权码 删除userinfo deviceinfo 以及 登录日志3
|
|
if opt < 0 || opt > 3 {
|
|
return errors.New("不存在该授权码 删除操作")
|
|
}
|
|
|
|
if opt != 3 {
|
|
// 删除 license_key 数据库表的授权码信息
|
|
err = MysqlDB.Where("license = ?", key).Delete(&table.LicenseKey{}).Error
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if opt == 0 { // 仅删除 License 信息
|
|
return err
|
|
}
|
|
|
|
// op=1 时, 删除该 key 授权码对应的 UserInfoEntity DeviceInfoEntity
|
|
if has.Status == 0 || len(strings.TrimSpace(has.WxId)) == 0 {
|
|
// 该授权码还没有绑定微信号
|
|
return nil
|
|
}
|
|
|
|
// 删除 user_info_entity 数据库表的数据
|
|
_ = MysqlDB.Where("wxId = ?", has.WxId).Delete(&table.UserInfoEntity{}).Error
|
|
// 删除 device_info_entity 数据库表的数据
|
|
_ = MysqlDB.Where("wxid = ?", has.WxId).Delete(&table.DeviceInfoEntity{}).Error
|
|
|
|
if opt == 1 {
|
|
return nil
|
|
}
|
|
|
|
// 删除 UserLoginLog 数据库表的数据
|
|
_ = MysqlDB.Where("user_name = ?", has.WxId).Delete(&table.UserLoginLog{}).Error
|
|
|
|
return nil
|
|
}
|
|
|
|
// 禁用1 启用0
|
|
func DisableLicense(key string, opt int) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
result := MysqlDB.Model(&table.LicenseKey{}).
|
|
Where("license = ?", key).
|
|
Updates(map[string]interface{}{
|
|
"is_banned": opt,
|
|
})
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 创建黑名单
|
|
func CreateSB(owner string, blacker map[string]string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
blackerJSON, err := json.Marshal(blacker)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// 在这里执行 SQL 查询，直接将 blackerJSON 作为参数赋值给 Blacker 字段
|
|
record := table.BlackList{Owner: owner, Blacker: string(blackerJSON)}
|
|
result := MysqlDB.Create(&record)
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
key := owner + "_blacklist"
|
|
SETExpirationObj(key, blacker, -1)
|
|
return nil
|
|
}
|
|
|
|
// 查询黑名单
|
|
func QuerySB(owner string) (*table.BlackList, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
var record table.BlackList
|
|
result := MysqlDB.Where("owner = ?", owner).First(&record)
|
|
if result.Error != nil {
|
|
return nil, result.Error
|
|
}
|
|
return &record, nil
|
|
}
|
|
|
|
// 更新黑名单
|
|
func UpdateSB(owner string, blacker map[string]string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
record, err := QuerySB(owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if record == nil {
|
|
CreateSB(owner, blacker)
|
|
return nil
|
|
}
|
|
blackerJSON, err := json.Marshal(blacker)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result := MysqlDB.Model(record).Update("Blacker", string(blackerJSON))
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
key := owner + "_blacklist"
|
|
SETExpirationObj(key, blacker, -1)
|
|
return nil
|
|
}
|
|
|
|
// 联系人操作
|
|
func SaveOrUpdateContact(contact *pb.ModContact, uuid string) error {
|
|
// 捕获 panic，防止程序崩溃
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
fmt.Printf("Recovered from panic: %v\n", r)
|
|
// 这里可以记录日志或者执行其他的恢复操作
|
|
}
|
|
}()
|
|
if contact == nil {
|
|
return errors.New("contact cannot be nil")
|
|
}
|
|
|
|
if contact.UserName == nil || contact.UserName.GetStr() == "" {
|
|
return errors.New("userName cannot be nil or empty")
|
|
}
|
|
|
|
contactJson, err := json.Marshal(contact)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
m := getContactMutex(uuid)
|
|
m.Lock()
|
|
defer m.Unlock()
|
|
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
|
|
combinedKey := uuid + "-" + *contact.UserName.Str
|
|
|
|
// 进行更新或插入操作
|
|
err = MysqlDB.Where(table.ModContactDB{UserUUIDCombined: combinedKey}).
|
|
Assign(table.ModContactDB{Data: string(contactJson), UUID: uuid, UserName: *contact.UserName.Str}).
|
|
FirstOrCreate(&table.ModContactDB{}).Error
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetContact(userName string, uuid string) *pb.ModContact {
|
|
// m := getContactMutex(uuid)
|
|
// m.Lock()
|
|
// defer m.Unlock()
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
var contactDB table.ModContactDB
|
|
combinedKey := uuid + "-" + userName
|
|
|
|
result := MysqlDB.First(&contactDB, "user_uuid_combined = ?", combinedKey)
|
|
|
|
if gorm.IsRecordNotFoundError(result.Error) {
|
|
return nil
|
|
}
|
|
if result.Error != nil {
|
|
return nil
|
|
}
|
|
|
|
var contact pb.ModContact
|
|
err := json.Unmarshal([]byte(contactDB.Data), &contact)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return &contact
|
|
}
|
|
|
|
// 删除联系人
|
|
func DeleteContact(userName string, uuid string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
combinedKey := uuid + "-" + userName
|
|
|
|
result := MysqlDB.Where("user_uuid_combined = ?", combinedKey).Delete(&table.ModContactDB{})
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 消息操作
|
|
func SaveMsg(msg pb.AddMsg, uuid string) error {
|
|
if msg.NewMsgId == nil {
|
|
return errors.New("NewMsgId cannot be nil")
|
|
}
|
|
|
|
// 序列化消息为 JSON
|
|
msgJson, err := json.Marshal(msg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
|
|
combinedKey := uuid + fmt.Sprintf("-%d", *msg.NewMsgId)
|
|
|
|
// m := getContactMutex(uuid + "-msg")
|
|
// m.Lock()
|
|
// defer m.Unlock()
|
|
|
|
// 检查消息是否已存在
|
|
var existingMsg table.AddMsgDB
|
|
// 如果没有找到记录，会返回 gorm.ErrRecordNotFound
|
|
err = MysqlDB.Where("msg_uuid_combined = ?", combinedKey).First(&existingMsg).Error
|
|
if err == nil {
|
|
return nil // 已存在，不更新，直接返回
|
|
}
|
|
if !gorm.IsRecordNotFoundError(err) {
|
|
return err // 返回数据库操作中的其他错误
|
|
}
|
|
|
|
// 保存新消息
|
|
newMsg := &table.AddMsgDB{
|
|
UUID: uuid,
|
|
NewMsgId: msg.GetNewMsgId(),
|
|
MsgUUIDCombined: combinedKey,
|
|
Data: string(msgJson),
|
|
CreateTime: msg.GetCreateTime(),
|
|
}
|
|
|
|
if err := MysqlDB.Create(newMsg).Error; err != nil {
|
|
return err // 返回创建消息时的任何错误
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetAndDeleteMsg(newMsgId int64, uuid string) *pb.AddMsg {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
combinedKey := uuid + fmt.Sprintf("-%d", newMsgId)
|
|
|
|
// m := getContactMutex(combinedKey)
|
|
// m.Lock()
|
|
// defer m.Unlock()
|
|
|
|
var msgDB table.AddMsgDB
|
|
// 获取消息
|
|
if err := MysqlDB.Where("msg_uuid_combined = ?", combinedKey).First(&msgDB).Error; err != nil {
|
|
if gorm.IsRecordNotFoundError(err) {
|
|
return nil // 消息不存在
|
|
}
|
|
return nil // 发生其他错误
|
|
}
|
|
|
|
// 删除消息
|
|
if err := MysqlDB.Delete(&msgDB).Error; err != nil {
|
|
return nil // 发生删除错误
|
|
}
|
|
|
|
// 解析消息内容
|
|
var msg pb.AddMsg
|
|
if err := json.Unmarshal([]byte(msgDB.Data), &msg); err != nil {
|
|
return nil // 解析错误
|
|
}
|
|
|
|
return &msg
|
|
}
|
|
|
|
// StartCleanupTask 定时清理消息
|
|
func StartCleanupTask() {
|
|
// 多个协议，启动一个即可
|
|
if srvconfig.GlobalSetting.OpenClearMsg == false {
|
|
return
|
|
}
|
|
ticker := time.NewTicker(3 * time.Minute)
|
|
go func() {
|
|
for range ticker.C {
|
|
cleanupOldMessages()
|
|
}
|
|
}()
|
|
}
|
|
|
|
func cleanupOldMessages() {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
cutoffTime := uint32(time.Now().Add(-3 * time.Minute).Unix())
|
|
|
|
tx := MysqlDB.Begin()
|
|
if tx.Error != nil {
|
|
return
|
|
}
|
|
|
|
if err := tx.Where("create_time < ?", cutoffTime).Delete(&table.AddMsgDB{}).Error; err != nil {
|
|
tx.Rollback()
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
log.Println("Old messages cleaned up successfully.")
|
|
}
|
|
|
|
// 消息回调配置相关操作
|
|
|
|
// SaveMessageCallbackConfig 保存或更新消息回调配置
|
|
func SaveMessageCallbackConfig(config *table.MessageCallbackConfig) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 确保UUID和Key字段为相同的值
|
|
if config.UUID == "" {
|
|
return errors.New("UUID字段不能为空")
|
|
}
|
|
// 设置Key字段和UUID保持一致
|
|
config.Key = config.UUID
|
|
|
|
var existingConfig table.MessageCallbackConfig
|
|
result := MysqlDB.Where("uuid = ?", config.UUID).First(&existingConfig)
|
|
|
|
if result.Error != nil {
|
|
if result.Error == gorm.ErrRecordNotFound {
|
|
// 记录不存在，创建新记录
|
|
log.Infof("[回调调试] 创建新配置记录 [UUID: %s]", config.UUID)
|
|
newConfig := table.MessageCallbackConfig{
|
|
UUID: config.UUID,
|
|
Key: config.UUID, // 确保Key和UUID相同
|
|
CallbackURL: config.CallbackURL,
|
|
Enabled: config.Enabled,
|
|
}
|
|
return MysqlDB.Create(&newConfig).Error
|
|
}
|
|
return result.Error
|
|
}
|
|
return MysqlDB.Model(&existingConfig).Updates(map[string]interface{}{
|
|
"key": config.UUID, // 更新Key字段
|
|
"callback_url": config.CallbackURL,
|
|
"enabled": config.Enabled,
|
|
}).Error
|
|
}
|
|
|
|
// GetMessageCallbackConfig 获取消息回调配置
|
|
func GetMessageCallbackConfig(uuid string) (*table.MessageCallbackConfig, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var config table.MessageCallbackConfig
|
|
result := MysqlDB.Where("uuid = ?", uuid).First(&config)
|
|
if result.Error != nil {
|
|
if result.Error == gorm.ErrRecordNotFound {
|
|
log.Debugf("[回调调试] 数据库中未找到配置 [UUID: %s]", uuid)
|
|
return nil, nil
|
|
}
|
|
log.Errorf("[回调调试] 查询配置出错 [UUID: %s]: %v", uuid, result.Error)
|
|
return nil, result.Error
|
|
}
|
|
return &config, nil
|
|
}
|
|
|
|
// DeleteMessageCallbackConfig 删除消息回调配置
|
|
func DeleteMessageCallbackConfig(uuid string) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return MysqlDB.Where("uuid = ?", uuid).Delete(&table.MessageCallbackConfig{}).Error
|
|
}
|
|
|
|
// GetAllEnabledCallbacks 获取所有启用的回调配置
|
|
func GetAllEnabledCallbacks() ([]table.MessageCallbackConfig, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var configs []table.MessageCallbackConfig
|
|
result := MysqlDB.Where("enabled = ?", true).Find(&configs)
|
|
if result.Error != nil {
|
|
return nil, result.Error
|
|
}
|
|
|
|
return configs, nil
|
|
}
|
|
|
|
// GetActiveLicenseKeys 获取所有激活状态的卡密
|
|
func GetActiveLicenseKeys() ([]*table.LicenseKey, error) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var licenseKeys []*table.LicenseKey
|
|
err := MysqlDB.Where("status = ?", 1).Find(&licenseKeys).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return licenseKeys, nil
|
|
}
|
|
|
|
// SaveShortLinkStatusToDB 将短连接状态保存到数据库
|
|
func SaveShortLinkStatusToDB(uuid string, isEnabled bool) {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return
|
|
}
|
|
|
|
data := make(map[string]interface{})
|
|
data["short_link_enabled"] = isEnabled
|
|
|
|
// 更新用户信息表的短连接状态
|
|
_ = MysqlDB.Model(&table.UserInfoEntity{}).
|
|
Where("uuid = ? ", uuid).
|
|
Updates(data)
|
|
|
|
// 同时更新缓存
|
|
SaveShortLinkStatus(uuid, isEnabled)
|
|
}
|
|
|
|
// LoadShortLinkStatusFromDB 从数据库加载短连接状态
|
|
func LoadShortLinkStatusFromDB(uuid string) *ShortLinkStatus {
|
|
// 先尝试从缓存中获取
|
|
status := GetShortLinkStatus(uuid)
|
|
if status != nil {
|
|
return status
|
|
}
|
|
|
|
// 缓存中不存在，从数据库加载
|
|
if err := checkAndReconnect(); err != nil {
|
|
return nil
|
|
}
|
|
|
|
var userInfoEntity table.UserInfoEntity
|
|
if err := MysqlDB.Where("uuid = ?", uuid).First(&userInfoEntity).Error; err != nil {
|
|
return nil
|
|
}
|
|
|
|
// 创建短连接状态对象并缓存
|
|
status = &ShortLinkStatus{
|
|
IsEnabled: userInfoEntity.ShortLinkEnabled,
|
|
}
|
|
SaveShortLinkStatus(uuid, status.IsEnabled)
|
|
return status
|
|
}
|
|
|
|
// SaveDeviceInfo 保存设备信息到数据库
|
|
func SaveDeviceInfo(deviceInfo *table.DeviceInfoEntity) error {
|
|
// 检查并重新连接数据库
|
|
if err := checkAndReconnect(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 使用 Upsert 操作，如果记录存在则更新，不存在则插入
|
|
result := MysqlDB.Save(deviceInfo)
|
|
return result.Error
|
|
}
|