yunqueai/ai_wht_wechat
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

commit

Browse Source
This commit is contained in:
sjk
2026-01-06 19:36:42 +08:00
parent 15b579d64a
commit 19942144fb
261 changed files with 24034 additions and 5477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
go_backend/cmd/check_all_locks.go Normal file
View File

@@ -0,0 +1,51 @@
package main
import (
"ai_xhs/config"
"ai_xhs/database"
"context"
"fmt"
"log"
)
func main() {
// 加载配置
if err := config.LoadConfig("dev"); err != nil {
log.Fatalf("配置加载失败: %v", err)
}
// 连接Redis
if err := database.InitRedis(); err != nil {
log.Fatalf("Redis连接失败: %v", err)
}
ctx := context.Background()
// 列出所有lock相关的键
fmt.Println("=== 检查所有锁相关的键 ===")
keys, err := database.RDB.Keys(ctx, "lock:*").Result()
if err != nil {
log.Fatalf("查询锁失败: %v", err)
}
if len(keys) > 0 {
fmt.Printf("发现 %d 个锁:\n", len(keys))
for _, key := range keys {
ttl, _ := database.RDB.TTL(ctx, key).Result()
value, _ := database.RDB.Get(ctx, key).Result()
fmt.Printf(" - %s (TTL: %v, Value: %s)\n", key, ttl, value)
}
fmt.Println("\n是否要清除所有锁? (y/n)")
var answer string
fmt.Scanln(&answer)
if answer == "y" || answer == "Y" {
for _, key := range keys {
database.RDB.Del(ctx, key)
}
fmt.Println("✓ 已清除所有锁")
}
} else {
fmt.Println("未发现任何锁")
}
}

83
go_backend/cmd/clear_bind_lock.go Normal file
View File

@@ -0,0 +1,83 @@
package main
import (
"ai_xhs/config"
"ai_xhs/database"
"context"
"fmt"
"log"
"os"
"strconv"
)
func main() {
// 加载配置
if err := config.LoadConfig("dev"); err != nil {
log.Fatalf("配置加载失败: %v", err)
}
// 连接Redis
if err := database.InitRedis(); err != nil {
log.Fatalf("Redis连接失败: %v", err)
}
ctx := context.Background()
// 获取命令行参数
if len(os.Args) < 2 {
fmt.Println("用法: go run cmd/clear_bind_lock.go <employee_id>")
fmt.Println("示例: go run cmd/clear_bind_lock.go 1")
os.Exit(1)
}
employeeID, err := strconv.Atoi(os.Args[1])
if err != nil {
log.Fatalf("无效的员工ID: %v", err)
}
// 构造锁的key
lockKey := fmt.Sprintf("lock:bind_xhs:%d", employeeID)
// 检查锁是否存在
exists, err := database.RDB.Exists(ctx, lockKey).Result()
if err != nil {
log.Fatalf("检查锁失败: %v", err)
}
if exists > 0 {
// 获取锁的TTL
ttl, err := database.RDB.TTL(ctx, lockKey).Result()
if err != nil {
log.Printf("获取锁TTL失败: %v", err)
} else {
log.Printf("发现锁: %s, 剩余时间: %v", lockKey, ttl)
}
// 删除锁
err = database.RDB.Del(ctx, lockKey).Err()
if err != nil {
log.Fatalf("删除锁失败: %v", err)
}
log.Printf("✓ 成功删除锁: %s", lockKey)
} else {
log.Printf("未发现锁: %s", lockKey)
}
// 列出所有相关的锁
fmt.Println("\n=== 检查所有绑定相关的锁 ===")
keys, err := database.RDB.Keys(ctx, "lock:bind_xhs:*").Result()
if err != nil {
log.Printf("查询锁失败: %v", err)
} else {
if len(keys) > 0 {
fmt.Printf("发现 %d 个绑定锁:\n", len(keys))
for _, key := range keys {
ttl, _ := database.RDB.TTL(ctx, key).Result()
fmt.Printf(" - %s (TTL: %v)\n", key, ttl)
}
} else {
fmt.Println("未发现任何绑定锁")
}
}
}

47
go_backend/cmd/generate_password.go Normal file
View File

@@ -0,0 +1,47 @@
package main
import (
"crypto/sha256"
"encoding/hex"
"fmt"
"os"
)
// HashPassword 密码加密（使用SHA256，与Python版本保持一致）
func HashPassword(password string) string {
hash := sha256.Sum256([]byte(password))
return hex.EncodeToString(hash[:])
}
func main() {
// 如果有命令行参数，加密该密码
if len(os.Args) > 1 {
password := os.Args[1]
hashed := HashPassword(password)
fmt.Printf("原始密码: %s\n", password)
fmt.Printf("加密后: %s\n", hashed)
return
}
// 为测试数据生成加密密码
passwords := []string{
"admin123", // 企业管理员密码
"user123", // 普通用户密码
"123456", // 默认密码
}
fmt.Println("生成加密密码（SHA256）：")
fmt.Println("=====================================")
for i, pwd := range passwords {
hashed := HashPassword(pwd)
fmt.Printf("%d. 原始密码: %s\n", i+1, pwd)
fmt.Printf(" 加密后: %s\n\n", hashed)
}
fmt.Println("=====================================")
fmt.Println("使用说明：")
fmt.Println("方式1：直接运行此程序，查看常用密码的加密结果")
fmt.Println("方式2：传入密码参数，如: go run generate_password.go mypassword")
fmt.Println("注意：请将加密后的密码保存到数据库的 password 字段")
}

39
go_backend/cmd/generate_token.go Normal file
View File

@@ -0,0 +1,39 @@
package main
import (
"ai_xhs/config"
"ai_xhs/utils"
"flag"
"fmt"
"log"
)
func main() {
// 解析命令行参数
env := flag.String("env", "dev", "运行环境: dev, prod")
employeeID := flag.Int("id", 1, "员工ID")
flag.Parse()
// 加载配置
if err := config.LoadConfig(*env); err != nil {
log.Fatalf("配置加载失败: %v", err)
}
// 生成Token
token, err := utils.GenerateToken(*employeeID)
if err != nil {
log.Fatalf("生成Token失败: %v", err)
}
fmt.Println("========================================")
fmt.Printf("环境: %s\n", *env)
fmt.Printf("员工ID: %d\n", *employeeID)
fmt.Println("========================================")
fmt.Printf("JWT Token:\n%s\n", token)
fmt.Println("========================================")
fmt.Println("\n使用方式:")
fmt.Println("在请求头中添加: Authorization: Bearer " + token)
fmt.Println("\ncURL示例:")
fmt.Printf("curl -H \"Authorization: Bearer %s\" http://localhost:8080/api/employee/profile\n", token)
fmt.Println("========================================")
}

24
go_backend/cmd/test_password_hash.go Normal file
View File

@@ -0,0 +1,24 @@
package main
import (
"crypto/sha256"
"encoding/hex"
"fmt"
)
func main() {
// 测试密码
passwords := []string{
"123456",
"password",
"admin123",
}
fmt.Println("=== Go SHA256 密码加密测试 ===")
for _, pwd := range passwords {
hash := sha256.Sum256([]byte(pwd))
hashStr := hex.EncodeToString(hash[:])
fmt.Printf("密码: %s\n", pwd)
fmt.Printf("SHA256: %s\n\n", hashStr)
}
}

168
go_backend/cmd/test_redis.go Normal file
View File

@@ -0,0 +1,168 @@
package main
import (
"ai_xhs/config"
"ai_xhs/database"
"ai_xhs/utils"
"context"
"fmt"
"log"
"time"
)
// TestData 测试数据结构
type TestData struct {
Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}
func main() {
// 加载配置
if err := config.LoadConfig("dev"); err != nil {
log.Fatalf("配置加载失败: %v", err)
}
// 初始化Redis
if err := database.InitRedis(); err != nil {
log.Fatalf("Redis初始化失败: %v", err)
}
defer database.CloseRedis()
ctx := context.Background()
fmt.Println("\n=== Redis缓存功能测试 ===\n")
// 1. 测试基本的Set/Get
fmt.Println("1. 测试基本Set/Get操作:")
testData := TestData{
Name: "张三",
Age: 25,
Email: "zhangsan@example.com",
}
if err := utils.SetCache(ctx, "user:1001", testData, 5*time.Minute); err != nil {
log.Fatalf("设置缓存失败: %v", err)
}
fmt.Println("✓ 缓存设置成功")
var result TestData
if err := utils.GetCache(ctx, "user:1001", &result); err != nil {
log.Fatalf("获取缓存失败: %v", err)
}
fmt.Printf("✓ 缓存获取成功: %+v\n", result)
// 2. 测试Exists
fmt.Println("\n2. 测试缓存是否存在:")
exists, err := utils.ExistsCache(ctx, "user:1001")
if err != nil {
log.Fatalf("检查缓存失败: %v", err)
}
fmt.Printf("✓ 缓存存在性检查: %v\n", exists)
// 3. 测试TTL
fmt.Println("\n3. 测试获取TTL:")
ttl, err := utils.GetTTL(ctx, "user:1001")
if err != nil {
log.Fatalf("获取TTL失败: %v", err)
}
fmt.Printf("✓ 缓存TTL: %v\n", ttl)
// 4. 测试计数器
fmt.Println("\n4. 测试计数器操作:")
count, err := utils.IncrCache(ctx, "counter:test")
if err != nil {
log.Fatalf("递增失败: %v", err)
}
fmt.Printf("✓ 递增后计数: %d\n", count)
count, err = utils.IncrCache(ctx, "counter:test")
if err != nil {
log.Fatalf("递增失败: %v", err)
}
fmt.Printf("✓ 再次递增后计数: %d\n", count)
// 5. 测试Hash操作
fmt.Println("\n5. 测试Hash操作:")
if err := utils.HSetCache(ctx, "user:hash:1001", "name", "李四"); err != nil {
log.Fatalf("HSet失败: %v", err)
}
if err := utils.HSetCache(ctx, "user:hash:1001", "age", "30"); err != nil {
log.Fatalf("HSet失败: %v", err)
}
fmt.Println("✓ Hash字段设置成功")
name, err := utils.HGetCache(ctx, "user:hash:1001", "name")
if err != nil {
log.Fatalf("HGet失败: %v", err)
}
fmt.Printf("✓ 获取Hash字段 name: %s\n", name)
allFields, err := utils.HGetAllCache(ctx, "user:hash:1001")
if err != nil {
log.Fatalf("HGetAll失败: %v", err)
}
fmt.Printf("✓ 获取所有Hash字段: %+v\n", allFields)
// 6. 测试Set操作
fmt.Println("\n6. 测试Set操作:")
if err := utils.SAddCache(ctx, "tags:1001", "golang", "redis", "mysql"); err != nil {
log.Fatalf("SAdd失败: %v", err)
}
fmt.Println("✓ Set成员添加成功")
members, err := utils.SMembersCache(ctx, "tags:1001")
if err != nil {
log.Fatalf("SMembers失败: %v", err)
}
fmt.Printf("✓ 获取Set所有成员: %v\n", members)
// 7. 测试ZSet操作
fmt.Println("\n7. 测试ZSet操作:")
if err := utils.ZAddCache(ctx, "rank:score", 100.5, "user1"); err != nil {
log.Fatalf("ZAdd失败: %v", err)
}
if err := utils.ZAddCache(ctx, "rank:score", 95.0, "user2"); err != nil {
log.Fatalf("ZAdd失败: %v", err)
}
if err := utils.ZAddCache(ctx, "rank:score", 105.5, "user3"); err != nil {
log.Fatalf("ZAdd失败: %v", err)
}
fmt.Println("✓ ZSet成员添加成功")
rangeResult, err := utils.ZRangeCache(ctx, "rank:score", 0, -1)
if err != nil {
log.Fatalf("ZRange失败: %v", err)
}
fmt.Printf("✓ 获取ZSet所有成员(按分数排序): %v\n", rangeResult)
// 8. 测试删除操作
fmt.Println("\n8. 测试删除操作:")
if err := utils.DelCache(ctx, "counter:test", "tags:1001", "rank:score"); err != nil {
log.Fatalf("删除缓存失败: %v", err)
}
fmt.Println("✓ 缓存删除成功")
// 9. 测试SetNX (仅当key不存在时设置)
fmt.Println("\n9. 测试SetNX操作:")
success, err := utils.SetCacheNX(ctx, "lock:test", "locked", 10*time.Second)
if err != nil {
log.Fatalf("SetNX失败: %v", err)
}
fmt.Printf("✓ SetNX首次设置: %v\n", success)
success, err = utils.SetCacheNX(ctx, "lock:test", "locked", 10*time.Second)
if err != nil {
log.Fatalf("SetNX失败: %v", err)
}
fmt.Printf("✓ SetNX重复设置(应该失败): %v\n", success)
// 清理测试数据
fmt.Println("\n10. 清理测试数据:")
if err := utils.DelCache(ctx, "user:1001", "user:hash:1001", "lock:test"); err != nil {
log.Fatalf("清理失败: %v", err)
}
fmt.Println("✓ 测试数据清理完成")
fmt.Println("\n=== 所有测试完成! ===")
}

33
go_backend/cmd/test_service_alert.go Normal file
View File

@@ -0,0 +1,33 @@
package main
import (
"ai_xhs/config"
"ai_xhs/service"
"fmt"
"log"
)
// 测试发送服务宕机通知短信
func main() {
// 加载配置
config.InitConfig()
// 初始化短信服务
smsService := service.GetSmsService()
// 发送宕机通知到指定手机号
alertPhone := "15707023967"
serviceName := "AI小红书服务"
fmt.Printf("正在发送服务宕机通知到 %s...\n", alertPhone)
err := smsService.SendServiceDownAlert(alertPhone, serviceName)
if err != nil {
log.Fatalf("发送宕机通知失败: %v", err)
}
fmt.Printf("✅ 宕机通知发送成功！\n")
fmt.Printf("手机号: %s\n", alertPhone)
fmt.Printf("通知码: 11111\n")
fmt.Printf("服务名: %s\n", serviceName)
}