repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/chatsynchandler.go | app/chat/chat_api/internal/handler/chatsynchandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func chatSyncHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ChatSyncReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewChatSyncLogic(r.Context(), svcCtx)
resp, err := l.ChatSync(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/recallmessagehandler.go | app/chat/chat_api/internal/handler/recallmessagehandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func recallMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.RecallMessageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewRecallMessageLogic(r.Context(), svcCtx)
resp, err := l.RecallMessage(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/pinnedchathandler.go | app/chat/chat_api/internal/handler/pinnedchathandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func pinnedChatHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.PinnedChatReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewPinnedChatLogic(r.Context(), svcCtx)
resp, err := l.PinnedChat(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/getconversationslistbyidshandler.go | app/chat/chat_api/internal/handler/getconversationslistbyidshandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getConversationsListByIdsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetConversationsListByIdsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetConversationsListByIdsLogic(r.Context(), svcCtx)
resp, err := l.GetConversationsListByIds(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/routes.go | app/chat/chat_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/chat/chat_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 删除某个最近会话
Method: http.MethodPost,
Path: "/api/chat/deleteRecentChat",
Handler: deleteRecentHandler(serverCtx),
},
{
// 编辑消息
Method: http.MethodPost,
Path: "/api/chat/edit",
Handler: editMessageHandler(serverCtx),
},
{
// 转发消息
Method: http.MethodPost,
Path: "/api/chat/forward",
Handler: forwardMessageHandler(serverCtx),
},
{
// 获取聊天记录
Method: http.MethodPost,
Path: "/api/chat/getChatHistory",
Handler: chatHistoryHandler(serverCtx),
},
{
// 获取会话id
Method: http.MethodPost,
Path: "/api/chat/getConversationInfo",
Handler: ConversationInfoHandler(serverCtx),
},
{
// 批量获取会话数据
Method: http.MethodPost,
Path: "/api/chat/getConversationsListByIds",
Handler: getConversationsListByIdsHandler(serverCtx),
},
{
// 获取最近会话列表
Method: http.MethodGet,
Path: "/api/chat/getRecentChatList",
Handler: recentChatListHandler(serverCtx),
},
{
// 批量获取用户会话设置数据
Method: http.MethodPost,
Path: "/api/chat/getUserConversationSettingsListByIds",
Handler: getUserConversationSettingsListByIdsHandler(serverCtx),
},
{
// 隐藏/显示会话
Method: http.MethodPost,
Path: "/api/chat/hideChat",
Handler: hideChatHandler(serverCtx),
},
{
// 设置会话免打扰
Method: http.MethodPost,
Path: "/api/chat/muteChat",
Handler: muteChatHandler(serverCtx),
},
{
// 置顶某个会话
Method: http.MethodPost,
Path: "/api/chat/pinnedChat",
Handler: pinnedChatHandler(serverCtx),
},
{
// 撤回消息
Method: http.MethodPost,
Path: "/api/chat/recall",
Handler: recallMessageHandler(serverCtx),
},
{
// 发送消息
Method: http.MethodPost,
Path: "/api/chat/sendMsg",
Handler: SendMsgHandler(serverCtx),
},
{
// 聊天数据同步
Method: http.MethodPost,
Path: "/api/chat/sync",
Handler: chatSyncHandler(serverCtx),
},
{
// 更新会话已读序列号
Method: http.MethodPost,
Path: "/api/chat/updateReadSeq",
Handler: updateReadSeqHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/forwardmessagehandler.go | app/chat/chat_api/internal/handler/forwardmessagehandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func forwardMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ForwardMessageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewForwardMessageLogic(r.Context(), svcCtx)
resp, err := l.ForwardMessage(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/updatereadseqlogic.go | app/chat/chat_api/internal/logic/updatereadseqlogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UpdateReadSeqLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateReadSeqLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateReadSeqLogic {
return &UpdateReadSeqLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateReadSeqLogic) UpdateReadSeq(req *types.UpdateReadSeqReq) (*types.UpdateReadSeqRes, error) {
// 参数验证
if req.ConversationID == "" {
return nil, errors.New("ConversationID不能为空")
}
if req.ReadSeq < 0 {
return nil, errors.New("ReadSeq值不对")
}
// 查询用户会话关系
var userConvo chat_models.ChatUserConversation
err := l.svcCtx.DB.Where("conversation_id = ? AND user_id = ?", req.ConversationID, req.UserID).First(&userConvo).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
// 如果记录不存在，创建新记录
version := l.svcCtx.VersionGen.GetNextVersion("chat_user_conversations", "user_id", req.UserID)
userConvo = chat_models.ChatUserConversation{
UserID: req.UserID,
ConversationID: req.ConversationID,
IsHidden: false,
IsPinned: false,
IsMuted: false,
UserReadSeq: req.ReadSeq,
Version: version,
}
if err := l.svcCtx.DB.Create(&userConvo).Error; err != nil {
l.Errorf("创建用户会话关系失败: userId=%s, conversationId=%s, error=%v", req.UserID, req.ConversationID, err)
return nil, err
}
l.Infof("创建用户会话关系并设置已读序列号: userId=%s, conversationId=%s, readSeq=%d", req.UserID, req.ConversationID, req.ReadSeq)
} else {
l.Errorf("查询用户会话关系失败: userId=%s, conversationId=%s, error=%v", req.UserID, req.ConversationID, err)
return nil, err
}
} else {
// 如果记录存在，更新已读序列号（只有当新的readSeq大于当前值时才更新，避免回退）
if req.ReadSeq > userConvo.UserReadSeq {
version := l.svcCtx.VersionGen.GetNextVersion("chat_user_conversations", "user_id", req.UserID)
err = l.svcCtx.DB.Model(&userConvo).
Updates(map[string]interface{}{
"user_read_seq": req.ReadSeq,
"updated_at": time.Now(),
"version": version,
}).Error
if err != nil {
l.Errorf("更新已读序列号失败: userId=%s, conversationId=%s, readSeq=%d, error=%v", req.UserID, req.ConversationID, req.ReadSeq, err)
return nil, err
}
l.Infof("更新已读序列号成功: userId=%s, conversationId=%s, readSeq=%d (原值: %d)", req.UserID, req.ConversationID, req.ReadSeq, userConvo.UserReadSeq)
// 异步推送WebSocket通知
go l.notifyReadSeqUpdate(req.UserID, req.ConversationID, version)
} else {
l.Infof("已读序列号无需更新: userId=%s, conversationId=%s, 当前readSeq=%d, 请求readSeq=%d", req.UserID, req.ConversationID, userConvo.UserReadSeq, req.ReadSeq)
}
}
return &types.UpdateReadSeqRes{
Success: true,
}, nil
}
// notifyReadSeqUpdate 推送已读序列号更新通知
func (l *UpdateReadSeqLogic) notifyReadSeqUpdate(userID, conversationID string, version int64) {
defer func() {
if r := recover(); r != nil {
l.Errorf("推送已读序列号更新通知时发生panic: %v", r)
}
}()
// 构建 chat_user_conversations 表更新数据（WebSocket推送使用前端期望的表名）
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations", // 前端期望的表名
"userId": userID,
"conversationId": conversationID,
"data": []map[string]interface{}{
{
"version": version,
},
},
}
// 推送WebSocket通知（给自己，同步到其他设备）
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.CHAT_MESSAGE, wsTypeConst.ChatUserConversationReceive, userID, userID, map[string]interface{}{
"tableUpdates": []map[string]interface{}{userConversationsUpdate},
}, conversationID)
l.Infof("推送已读序列号更新通知完成: userId=%s, conversationId=%s, version=%d", userID, conversationID, version)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/pinnedchatlogic.go | app/chat/chat_api/internal/logic/pinnedchatlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type PinnedChatLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewPinnedChatLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PinnedChatLogic {
return &PinnedChatLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *PinnedChatLogic) PinnedChat(req *types.PinnedChatReq) (resp *types.PinnedChatRes, err error) {
resp = &types.PinnedChatRes{}
// 获取下一个版本号
version := l.svcCtx.VersionGen.GetNextVersion("chat_user_conversations", "user_id", req.UserID)
// 更新会话置顶状态和版本号
err = l.svcCtx.DB.Model(&chat_models.ChatUserConversation{}).
Where("user_id = ? AND conversation_id = ?", req.UserID, req.ConversationID).
Updates(map[string]interface{}{
"is_pinned": req.IsPinned,
"version": version,
}).Error
if err != nil {
l.Logger.Errorf("pinned chat update failed: %v", err)
return nil, err
}
// 发送WS通知给自己（更新本地数据）
go func() {
l.notifyPinnedUpdate(req.ConversationID, req.UserID, version)
}()
return resp, nil
}
// 发送置顶状态更新通知
func (l *PinnedChatLogic) notifyPinnedUpdate(conversationId, userId string, version int64) {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("发送置顶通知时发生panic: %v", r)
}
}()
// 构建用户会话表更新数据
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations",
"userId": userId,
"conversationId": conversationId,
"data": []map[string]interface{}{
{
"version": int32(version),
},
},
}
// 发送给自己
tableUpdates := []map[string]interface{}{userConversationsUpdate}
messageType := wsTypeConst.ChatUserConversationReceive
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.CHAT_MESSAGE, messageType, userId, userId, map[string]interface{}{
"tableUpdates": tableUpdates,
}, conversationId)
l.Logger.Infof("发送置顶状态更新通知: user=%s, conversation=%s, version=%d",
userId, conversationId, version)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/getuserconversationsettingslistbyidslogic.go | app/chat/chat_api/internal/logic/getuserconversationsettingslistbyidslogic.go | package logic
import (
"context"
"time"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserConversationSettingsListByIdsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 批量获取用户会话设置数据
func NewGetUserConversationSettingsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserConversationSettingsListByIdsLogic {
return &GetUserConversationSettingsListByIdsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserConversationSettingsListByIdsLogic) GetUserConversationSettingsListByIds(req *types.GetUserConversationSettingsListByIdsReq) (resp *types.GetUserConversationSettingsListByIdsRes, err error) {
// 只查询用户会话设置表的数据
var userConversations []chat_models.ChatUserConversation
err = l.svcCtx.DB.Where("user_id = ? AND conversation_id IN (?)", req.UserID, req.ConversationIds).Find(&userConversations).Error
if err != nil {
l.Errorf("查询用户会话设置失败: %v", err)
return nil, err
}
// 转换数据库模型为API响应
conversationSettings := make([]types.UserConversationSettingById, 0, len(userConversations))
for _, uc := range userConversations {
conversationSettings = append(conversationSettings, types.UserConversationSettingById{
UserID: uc.UserID,
ConversationID: uc.ConversationID,
IsHidden: uc.IsHidden,
IsPinned: uc.IsPinned,
IsMuted: uc.IsMuted,
UserReadSeq: uc.UserReadSeq,
Version: uc.Version,
CreatedAt: time.Time(uc.CreatedAt).Unix(),
UpdatedAt: time.Time(uc.UpdatedAt).Unix(),
})
}
return &types.GetUserConversationSettingsListByIdsRes{
UserConversationSettings: conversationSettings,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/recallmessagelogic.go | app/chat/chat_api/internal/logic/recallmessagelogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type RecallMessageLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewRecallMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecallMessageLogic {
return &RecallMessageLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *RecallMessageLogic) RecallMessage(req *types.RecallMessageReq) (resp *types.RecallMessageRes, err error) {
// todo: add your logic here and delete this line
return
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/recentchatlistlogic.go | app/chat/chat_api/internal/logic/recentchatlistlogic.go | package logic
import (
"context"
"strings"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/utils/conversation"
"github.com/zeromicro/go-zero/core/logx"
)
type RecentChatListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewRecentChatListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecentChatListLogic {
return &RecentChatListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *RecentChatListLogic) RecentChatList(req *types.RecentChatListReq) (resp *types.RecentChatListRes, err error) {
var userConversations []chat_models.ChatUserConversation
var conversationMetas []chat_models.ChatConversationMeta
// 获取该用户的所有未隐藏会话
err = l.svcCtx.DB.Where("user_id = ? AND is_hidden = ?", req.UserID, false).
Order("is_pinned DESC, updated_at DESC").
Find(&userConversations).Error
if err != nil {
return nil, err
}
// 获取对应的会话元数据（包含LastMessage）
conversationIds := make([]string, len(userConversations))
for i, conv := range userConversations {
conversationIds[i] = conv.ConversationID
}
if len(conversationIds) > 0 {
err = l.svcCtx.DB.Where("conversation_id IN (?)", conversationIds).
Find(&conversationMetas).Error
if err != nil {
return nil, err
}
}
if err != nil {
return nil, err
}
var privateChatIds []string
var groupChatIds []string
// 获取会话Ids并根据命名规则区分私聊和群聊
for _, convo := range userConversations {
conversationType := conversation.GetConversationType(convo.ConversationID)
if conversationType == 1 { // 私聊
privateChatIds = append(privateChatIds, convo.ConversationID)
} else if conversationType == 2 { // 群聊
groupChatIds = append(groupChatIds, convo.ConversationID)
}
}
// 从私聊Id中提取用户Id进行去重
userIdMap := make(map[string]struct{})
for _, chatID := range privateChatIds {
_, userIds := conversation.ParseConversationWithType(chatID)
for _, userId := range userIds {
if userId != req.UserID {
userIdMap[userId] = struct{}{}
}
}
}
// 将map转为slice
var userIds []string
for id := range userIdMap {
userIds = append(userIds, id)
}
// 通过FriendRpc获取好友详细信息（包含用户基础信息和备注）
var friendDetails []*friend_rpc.FriendDetailItem
if len(userIds) > 0 {
friendDetailRes, err := l.svcCtx.FriendRpc.GetFriendDetail(l.ctx, &friend_rpc.GetFriendDetailReq{
UserId: req.UserID,
FriendIds: userIds,
})
if err != nil {
logx.Errorf("获取好友详情失败: %v", err)
return nil, err
}
friendDetails = friendDetailRes.Friends
}
// 通过RPC批量获取群组信息
var groupDetails []*group_rpc.GroupListById
if len(groupChatIds) > 0 {
// 从群聊会话ID中提取实际的群组ID（去掉group_前缀）
var actualGroupIds []string
for _, groupChatId := range groupChatIds {
_, userIds := conversation.ParseConversationWithType(groupChatId)
if len(userIds) > 0 {
actualGroupIds = append(actualGroupIds, userIds[0])
}
}
if len(actualGroupIds) > 0 {
groupRes, err := l.svcCtx.GroupRpc.GetGroupsListByIds(l.ctx, &group_rpc.GetGroupsListByIdsReq{
GroupIDs: actualGroupIds,
})
if err != nil {
logx.Errorf("获取群组详情失败: %v", err)
return nil, err
}
groupDetails = groupRes.Groups
}
}
// 构建群组数据映射 (key为完整的会话ID)
groupMap := make(map[string]*group_rpc.GroupListById)
for i, groupChatId := range groupChatIds {
if i < len(groupDetails) {
groupMap[groupChatId] = groupDetails[i]
}
}
// 构建好友详细信息映射
friendDetailMap := make(map[string]*friend_rpc.FriendDetailItem)
for _, friendDetail := range friendDetails {
friendDetailMap[friendDetail.UserId] = friendDetail
}
conversationMetaMap := make(map[string]chat_models.ChatConversationMeta)
for _, meta := range conversationMetas {
conversationMetaMap[meta.ConversationID] = meta
}
var respList []types.ConversationInfoRes
for _, convo := range userConversations {
var chatInfo types.ConversationInfoRes
// 从会话元数据中获取最后消息
if meta, exists := conversationMetaMap[convo.ConversationID]; exists {
chatInfo.MsgPreview = meta.LastMessage
} else {
chatInfo.MsgPreview = ""
}
chatInfo.IsTop = convo.IsPinned
chatInfo.ConversationID = convo.ConversationID
chatInfo.UpdatedAt = convo.UpdatedAt.String()
if strings.HasPrefix(convo.ConversationID, "private_") { // 私聊
ids := strings.Split(convo.ConversationID, "_")
// ids格式: ["private", "A", "B"]
var opponentID string
if ids[1] == req.UserID {
opponentID = ids[2]
} else {
opponentID = ids[1]
}
// 从好友详细信息中获取用户信息和备注
if friendDetail, exists := friendDetailMap[opponentID]; exists {
chatInfo.NickName = friendDetail.NickName
chatInfo.Avatar = friendDetail.Avatar
chatInfo.Notice = friendDetail.Notice
} else {
chatInfo.NickName = "未知用户"
chatInfo.Avatar = ""
chatInfo.Notice = ""
}
chatInfo.ChatType = 1
} else { // 群聊
group, exists := groupMap[convo.ConversationID]
if exists {
chatInfo.NickName = group.Name
chatInfo.Avatar = group.Avatar
} else {
chatInfo.NickName = "未知群聊"
chatInfo.Avatar = ""
}
chatInfo.ChatType = 2
chatInfo.Notice = "" // 群聊暂时没有备注功能
}
respList = append(respList, chatInfo)
}
return &types.RecentChatListRes{
List: respList,
Count: int64(len(respList)),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/mutechatlogic.go | app/chat/chat_api/internal/logic/mutechatlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type MuteChatLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 设置会话免打扰
func NewMuteChatLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MuteChatLogic {
return &MuteChatLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *MuteChatLogic) MuteChat(req *types.MuteChatReq) (resp *types.MuteChatRes, err error) {
resp = &types.MuteChatRes{}
// 获取下一个版本号
version := l.svcCtx.VersionGen.GetNextVersion("chat_user_conversations", "user_id", req.UserID)
// 更新会话免打扰状态和版本号
err = l.svcCtx.DB.Model(&chat_models.ChatUserConversation{}).
Where("user_id = ? AND conversation_id = ?", req.UserID, req.ConversationID).
Updates(map[string]interface{}{
"is_muted": req.IsMuted,
"version": version,
}).Error
if err != nil {
l.Logger.Errorf("mute chat update failed: %v", err)
return nil, err
}
// 发送WS通知给自己（更新本地数据）
go func() {
l.notifyMutedUpdate(req.ConversationID, req.UserID, version)
}()
return resp, nil
}
// 发送免打扰状态更新通知
func (l *MuteChatLogic) notifyMutedUpdate(conversationId, userId string, version int64) {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("发送免打扰通知时发生panic: %v", r)
}
}()
// 获取会话类型
// 构建用户会话表更新数据
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations",
"userId": userId,
"conversationId": conversationId,
"data": []map[string]interface{}{
{
"version": int32(version),
},
},
}
// 发送给自己
tableUpdates := []map[string]interface{}{userConversationsUpdate}
messageType := wsTypeConst.ChatUserConversationReceive
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.CHAT_MESSAGE, messageType, userId, userId, map[string]interface{}{
"tableUpdates": tableUpdates,
}, conversationId)
l.Logger.Infof("发送免打扰状态更新通知: user=%s, conversation=%s, version=%d",
userId, conversationId, version)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/getconversationslistbyidslogic.go | app/chat/chat_api/internal/logic/getconversationslistbyidslogic.go | package logic
import (
"context"
"time"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetConversationsListByIdsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 批量获取会话数据
func NewGetConversationsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetConversationsListByIdsLogic {
return &GetConversationsListByIdsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetConversationsListByIdsLogic) GetConversationsListByIds(req *types.GetConversationsListByIdsReq) (resp *types.GetConversationsListByIdsRes, err error) {
// 直接从数据库查询会话完整信息
var conversations []chat_models.ChatConversationMeta
err = l.svcCtx.DB.Where("conversation_id IN (?)", req.ConversationIds).Find(&conversations).Error
if err != nil {
l.Errorf("查询会话信息失败: %v", err)
return nil, err
}
// 转换数据库模型为API响应
conversationList := make([]types.ConversationById, 0, len(conversations))
for _, conv := range conversations {
conversationList = append(conversationList, types.ConversationById{
ConversationID: conv.ConversationID,
Type: conv.Type,
MaxSeq: conv.MaxSeq,
LastMessage: conv.LastMessage,
Version: conv.Version,
CreatedAt: time.Time(conv.CreatedAt).Unix(),
UpdatedAt: time.Time(conv.UpdatedAt).Unix(),
})
}
return &types.GetConversationsListByIdsRes{
Conversations: conversationList,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/hidechatlogic.go | app/chat/chat_api/internal/logic/hidechatlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type HideChatLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 隐藏/显示会话
func NewHideChatLogic(ctx context.Context, svcCtx *svc.ServiceContext) *HideChatLogic {
return &HideChatLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *HideChatLogic) HideChat(req *types.HideChatReq) (resp *types.HideChatRes, err error) {
resp = &types.HideChatRes{}
// 获取下一个版本号
version := l.svcCtx.VersionGen.GetNextVersion("chat_user_conversations", "user_id", req.UserID)
// 更新会话隐藏状态和版本号
err = l.svcCtx.DB.Model(&chat_models.ChatUserConversation{}).
Where("user_id = ? AND conversation_id = ?", req.UserID, req.ConversationID).
Updates(map[string]interface{}{
"is_hidden": req.IsHidden,
"version": version,
}).Error
if err != nil {
l.Logger.Errorf("hide chat update failed: %v", err)
return nil, err
}
// 发送WS通知给自己（更新本地数据）
go func() {
l.notifyHiddenUpdate(req.ConversationID, req.UserID, version)
}()
return resp, nil
}
// 发送隐藏状态更新通知
func (l *HideChatLogic) notifyHiddenUpdate(conversationId, userId string, version int64) {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("发送隐藏通知时发生panic: %v", r)
}
}()
// 构建用户会话表更新数据
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations",
"userId": userId,
"conversationId": conversationId,
"data": []map[string]interface{}{
{
"version": int32(version),
},
},
}
// 发送给自己
tableUpdates := []map[string]interface{}{userConversationsUpdate}
messageType := wsTypeConst.ChatUserConversationReceive
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.CHAT_MESSAGE, messageType, userId, userId, map[string]interface{}{
"tableUpdates": tableUpdates,
}, conversationId)
l.Logger.Infof("发送隐藏状态更新通知: user=%s, conversation=%s, version=%d",
userId, conversationId, version)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/deleterecentlogic.go | app/chat/chat_api/internal/logic/deleterecentlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"github.com/zeromicro/go-zero/core/logx"
)
type DeleteRecentLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewDeleteRecentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteRecentLogic {
return &DeleteRecentLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteRecentLogic) DeleteRecent(req *types.DeleteRecentReq) (resp *types.DeleteRecentRes, err error) {
// 假删除操作
err = l.svcCtx.DB.Model(&chat_models.ChatUserConversation{}).
Where("user_id = ? AND conversation_id = ?", req.UserID, req.ConversationID).
Updates(map[string]interface{}{"is_delete": true, "is_pinned": false}).Error
return nil, err
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/forwardmessagelogic.go | app/chat/chat_api/internal/logic/forwardmessagelogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type ForwardMessageLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewForwardMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ForwardMessageLogic {
return &ForwardMessageLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ForwardMessageLogic) ForwardMessage(req *types.ForwardMessageReq) (resp *types.ForwardMessageRes, err error) {
// todo: add your logic here and delete this line
return
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/chathistorylogic.go | app/chat/chat_api/internal/logic/chathistorylogic.go | package logic
import (
"context"
"encoding/json"
"fmt"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/common/list_query"
"beaver/common/models"
"beaver/common/models/ctype"
"github.com/zeromicro/go-zero/core/logx"
)
type ChatHistoryLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewChatHistoryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ChatHistoryLogic {
return &ChatHistoryLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ChatHistoryLogic) ChatHistory(req *types.ChatHistoryReq) (resp *types.ChatHistoryRes, err error) {
fmt.Println("当前的会话Id是:", req.ConversationID)
chatMessages, count, err := list_query.ListQuery(l.svcCtx.DB, chat_models.ChatMessage{}, list_query.Option{
PageInfo: models.PageInfo{
Page: req.Page,
Limit: req.Limit,
Sort: "created_at desc",
},
Where: l.svcCtx.DB.Where("conversation_id = ?", req.ConversationID),
// 移除Preload，因为微服务架构中不使用跨服务外键
})
if err != nil {
return nil, err
}
// 收集需要查询用户信息的UserID列表（排除通知消息）
var userIds []string
userIdSet := make(map[string]bool)
for _, chat := range chatMessages {
if chat.SendUserID != nil && *chat.SendUserID != "" {
if !userIdSet[*chat.SendUserID] {
userIds = append(userIds, *chat.SendUserID)
userIdSet[*chat.SendUserID] = true
}
}
}
// 批量获取用户信息
userInfoMap := make(map[string]types.Sender)
if len(userIds) > 0 {
userListResp, err := l.svcCtx.UserRpc.UserListInfo(l.ctx, &user_rpc.UserListInfoReq{
UserIdList: userIds,
})
if err != nil {
l.Logger.Errorf("批量获取用户信息失败: %v", err)
// 不返回错误，继续处理，为没有用户信息的消息设置默认值
} else {
// 转换用户信息
for userId, userInfo := range userListResp.UserInfo {
userInfoMap[userId] = types.Sender{
UserID: userId,
NickName: userInfo.NickName,
Avatar: userInfo.Avatar,
}
}
}
}
// 构建消息历史
var chatHistory []types.Message
for _, chat := range chatMessages {
// 转换消息内容
var msg types.Msg
if chat.Msg != nil {
err := convertCtypeMsgToTypesMsg(*chat.Msg, &msg)
if err != nil {
return nil, err
}
}
// 处理发送者信息
var sender types.Sender
sendUserID := ""
if chat.SendUserID != nil {
sendUserID = *chat.SendUserID
}
if sendUserID != "" {
// 普通用户消息
if userInfo, exists := userInfoMap[sendUserID]; exists {
sender = userInfo
} else {
// 用户信息获取失败，使用默认值
sender = types.Sender{
UserID: sendUserID,
NickName: "未知用户",
Avatar: "",
}
}
} else {
// 通知消息：SendUserID为空
sender = types.Sender{
UserID: "",
NickName: "通知消息",
Avatar: "",
}
}
message := types.Message{
Id: chat.Id,
ConversationID: chat.ConversationID,
ConversationType: chat.ConversationType,
Sender: sender,
CreatedAt: chat.CreatedAt.String(),
Msg: msg,
}
chatHistory = append(chatHistory, message)
}
return &types.ChatHistoryRes{
Count: count,
List: chatHistory,
}, nil
}
// Convert ctype.Msg to types.MsgType
func convertCtypeMsgToTypesMsg(ctypeMsg ctype.Msg, typesMsg *types.Msg) error {
// 先用JSON解码为一个通用结构体
encodedMsg, err := json.Marshal(ctypeMsg)
if err != nil {
return err
}
// 再将其解码为目标类型
err = json.Unmarshal(encodedMsg, typesMsg)
if err != nil {
return err
}
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/conversationinfologic.go | app/chat/chat_api/internal/logic/conversationinfologic.go | package logic
import (
"context"
"errors"
"strings"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"beaver/app/group/group_models"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type ConversationInfoLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewConversationInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ConversationInfoLogic {
return &ConversationInfoLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ConversationInfoLogic) ConversationInfo(req *types.ConversationInfoReq) (resp *types.ConversationInfoRes, err error) {
// 查询会话信息（这里应该是查询用户特定的会话设置）
var userConversation chat_models.ChatUserConversation
err = l.svcCtx.DB.Where("conversation_id = ? AND user_id = ?", req.ConversationID, req.UserID).First(&userConversation).Error
// 初始化响应
resp = &types.ConversationInfoRes{
ConversationID: req.ConversationID,
MsgPreview: "",
UpdatedAt: "",
IsTop: false,
}
// 查询会话元数据获取最后消息
var conversationMeta chat_models.ChatConversationMeta
metaErr := l.svcCtx.DB.Where("conversation_id = ?", req.ConversationID).First(&conversationMeta).Error
// 存在会话时填充消息预览和时间信息
if err == nil {
// 从会话元数据中获取最后消息
if metaErr == nil {
resp.MsgPreview = conversationMeta.LastMessage
}
resp.UpdatedAt = userConversation.UpdatedAt.String()
resp.IsTop = userConversation.IsPinned
} else if !errors.Is(err, gorm.ErrRecordNotFound) {
return nil, err
}
// 判断会话类型：包含下划线为私聊，否则为群聊
if strings.Contains(req.ConversationID, "_") {
// 私聊会话
ids := strings.Split(req.ConversationID, "_")
opponentID := ids[0]
if ids[0] == req.UserID {
opponentID = ids[1]
}
// 查询对方用户信息
var user user_models.UserModel
err = l.svcCtx.DB.Where("user_id = ?", opponentID).First(&user).Error
if err != nil {
return nil, err
}
resp.Avatar = user.Avatar
resp.NickName = user.NickName
resp.ChatType = 1 // 私聊类型
} else {
// 群聊会话
var group group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ?", req.ConversationID).First(&group).Error
if err != nil {
return nil, err
}
resp.Avatar = group.Avatar
resp.NickName = group.Title
resp.ChatType = 2 // 群聊类型
}
return resp, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/chatsynclogic.go | app/chat/chat_api/internal/logic/chatsynclogic.go | package logic
import (
"context"
"encoding/json"
"time"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_models"
"github.com/zeromicro/go-zero/core/logx"
)
type ChatSyncLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 聊天数据同步
func NewChatSyncLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ChatSyncLogic {
return &ChatSyncLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ChatSyncLogic) ChatSync(req *types.ChatSyncReq) (resp *types.ChatSyncRes, err error) {
var chats []chat_models.ChatMessage
// 构建基础查询条件 - 查询指定seq范围的消息（包含起始seq）
var query = l.svcCtx.DB.Where("seq >= ? AND seq <= ?", req.FromSeq, req.ToSeq)
// 如果指定了会话ID，则只同步该会话的消息
if req.ConversationID != "" {
query = query.Where("conversation_id = ?", req.ConversationID)
} else {
// 如果没有指定会话ID，需要过滤出用户相关的会话
// 通过子查询获取用户参与的所有会话ID（包括已删除的）
subQuery := l.svcCtx.DB.Model(&chat_models.ChatUserConversation{}).
Select("conversation_id").
Where("user_id = ?", req.UserID)
query = query.Where("conversation_id IN (?)", subQuery)
}
// 设置默认限制
limit := req.Limit
if limit <= 0 {
limit = 100
}
// 查询数据
err = query.Order("seq ASC").Limit(limit + 1).Find(&chats).Error
if err != nil {
l.Errorf("查询聊天数据失败: %v", err)
return nil, err
}
// 判断是否还有更多数据
hasMore := len(chats) > limit
if hasMore {
chats = chats[:limit]
}
// 转换为响应格式
var messages = make([]types.ChatSyncMessage, 0)
var nextSeq int64 = req.FromSeq
for _, chat := range chats {
// 序列化消息内容
msgJson := ""
if chat.Msg != nil {
// 将Msg结构体序列化为JSON字符串
msgBytes, err := json.Marshal(chat.Msg)
if err != nil {
l.Errorf("序列化消息内容失败: %v", err)
msgJson = chat.MsgPreview // 出错时使用预览
} else {
msgJson = string(msgBytes)
}
}
// 根据消息类型判断是否已删除（撤回或删除类型）
isDeleted := chat.MsgType == 7 || chat.MsgType == 8 // 假设7=REVOKE, 8=DELETE
// 处理发送者ID
sendUserID := ""
if chat.SendUserID != nil {
sendUserID = *chat.SendUserID
}
// 对于通知消息，前端可以根据SendUserID是否为空来判断
messages = append(messages, types.ChatSyncMessage{
MessageID: chat.MessageID,
ConversationID: chat.ConversationID,
ConversationType: chat.ConversationType,
SendUserID: sendUserID,
MsgType: uint32(chat.MsgType),
MsgPreview: chat.MsgPreview,
Msg: msgJson,
IsDeleted: isDeleted,
Seq: chat.Seq,
CreatedAt: time.Time(chat.CreatedAt).Unix(),
})
nextSeq = chat.Seq
}
// 如果没有更多数据，nextSeq应该是toSeq+1
if !hasMore {
nextSeq = req.ToSeq + 1
}
resp = &types.ChatSyncRes{
Messages: messages,
HasMore: hasMore,
NextSeq: nextSeq,
}
l.Infof("聊天数据同步完成，用户ID: %s, 返回消息数: %d, 还有更多: %v", req.UserID, len(messages), hasMore)
return resp, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/sendmsglogic.go | app/chat/chat_api/internal/logic/sendmsglogic.go | // logic/sendmsglogic.go
package logic
import (
"context"
"errors"
"fmt"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/common/models/ctype"
"github.com/zeromicro/go-zero/core/logx"
)
type SendMsgLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSendMsgLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SendMsgLogic {
return &SendMsgLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *SendMsgLogic) SendMsg(req *types.SendMsgReq) (*types.SendMsgRes, error) {
// 构建RPC请求
rpcReq := &chat_rpc.SendMsgReq{
UserId: req.UserID,
MessageId: req.MessageID,
ConversationId: req.ConversationID,
Msg: &chat_rpc.Msg{
Type: req.Msg.Type,
},
}
msgType := ctype.MsgType(req.Msg.Type)
switch msgType {
case ctype.TextMsgType:
rpcReq.Msg.TextMsg = &chat_rpc.TextMsg{Content: req.Msg.TextMsg.Content}
case ctype.ImageMsgType:
imageMsg := &chat_rpc.ImageMsg{FileKey: req.Msg.ImageMsg.FileKey}
// 设置可选字段（打平后的结构）
if req.Msg.ImageMsg.Width > 0 {
imageMsg.Width = int32(req.Msg.ImageMsg.Width)
}
if req.Msg.ImageMsg.Height > 0 {
imageMsg.Height = int32(req.Msg.ImageMsg.Height)
}
if req.Msg.ImageMsg.Size > 0 {
imageMsg.Size = req.Msg.ImageMsg.Size
}
rpcReq.Msg.ImageMsg = imageMsg
case ctype.VideoMsgType:
videoMsg := &chat_rpc.VideoMsg{FileKey: req.Msg.VideoMsg.FileKey}
// 设置可选字段（打平后的结构）
if req.Msg.VideoMsg.Width > 0 {
videoMsg.Width = int32(req.Msg.VideoMsg.Width)
}
if req.Msg.VideoMsg.Height > 0 {
videoMsg.Height = int32(req.Msg.VideoMsg.Height)
}
if req.Msg.VideoMsg.Duration > 0 {
videoMsg.Duration = int32(req.Msg.VideoMsg.Duration)
}
if req.Msg.VideoMsg.ThumbnailKey != "" {
videoMsg.ThumbnailKey = req.Msg.VideoMsg.ThumbnailKey
}
if req.Msg.VideoMsg.Size > 0 {
videoMsg.Size = req.Msg.VideoMsg.Size
}
rpcReq.Msg.VideoMsg = videoMsg
case ctype.FileMsgType:
fileMsg := &chat_rpc.FileMsg{FileKey: req.Msg.FileMsg.FileKey}
// 设置可选字段
if req.Msg.FileMsg.FileName != "" {
fileMsg.FileName = req.Msg.FileMsg.FileName
}
if req.Msg.FileMsg.Size > 0 {
fileMsg.Size = req.Msg.FileMsg.Size
}
if req.Msg.FileMsg.MimeType != "" {
fileMsg.MimeType = req.Msg.FileMsg.MimeType
}
rpcReq.Msg.FileMsg = fileMsg
case ctype.VoiceMsgType:
voiceMsg := &chat_rpc.VoiceMsg{FileKey: req.Msg.VoiceMsg.FileKey}
// 设置可选字段（打平后的结构）
if req.Msg.VoiceMsg.Duration > 0 {
voiceMsg.Duration = int32(req.Msg.VoiceMsg.Duration)
}
if req.Msg.VoiceMsg.Size > 0 {
voiceMsg.Size = req.Msg.VoiceMsg.Size
}
rpcReq.Msg.VoiceMsg = voiceMsg
case ctype.EmojiMsgType:
rpcReq.Msg.EmojiMsg = &chat_rpc.EmojiMsg{
FileKey: req.Msg.EmojiMsg.FileKey,
EmojiId: req.Msg.EmojiMsg.EmojiID,
PackageId: req.Msg.EmojiMsg.PackageID,
}
case ctype.NotificationMsgType:
rpcReq.Msg.NotificationMsg = &chat_rpc.NotificationMsg{
Type: int32(req.Msg.NotificationMsg.Type),
Actors: req.Msg.NotificationMsg.Actors,
}
case ctype.AudioFileMsgType:
audioFileMsg := &chat_rpc.AudioFileMsg{FileKey: req.Msg.AudioFileMsg.FileKey}
// 设置可选字段（打平后的结构）
if req.Msg.AudioFileMsg.FileName != "" {
audioFileMsg.FileName = req.Msg.AudioFileMsg.FileName
}
if req.Msg.AudioFileMsg.Duration > 0 {
audioFileMsg.Duration = int32(req.Msg.AudioFileMsg.Duration)
}
if req.Msg.AudioFileMsg.Size > 0 {
audioFileMsg.Size = req.Msg.AudioFileMsg.Size
}
rpcReq.Msg.AudioFileMsg = audioFileMsg
default:
return nil, errors.New("invalid message type")
}
fmt.Println("rpcReq:", rpcReq)
// 调用RPC服务
rpcResp, err := l.svcCtx.ChatRpc.SendMsg(l.ctx, rpcReq)
if err != nil {
l.Logger.Errorf("failed to send message via RPC: %v", err)
return nil, errors.New("failed to send message")
}
// 构建API响应
resp := &types.SendMsgRes{
Id: uint(rpcResp.Id),
ConversationID: rpcResp.ConversationId,
Msg: req.Msg,
Sender: types.Sender{
UserID: rpcResp.Sender.UserId,
Avatar: rpcResp.Sender.Avatar,
NickName: rpcResp.Sender.NickName,
},
CreatedAt: rpcResp.CreatedAt,
MsgPreview: rpcResp.MsgPreview,
Status: uint32(rpcResp.Status),
Seq: rpcResp.Seq,
}
return resp, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/logic/editmessagelogic.go | app/chat/chat_api/internal/logic/editmessagelogic.go | package logic
import (
"context"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type EditMessageLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewEditMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *EditMessageLogic {
return &EditMessageLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *EditMessageLogic) EditMessage(req *types.EditMessageReq) (resp *types.EditMessageRes, err error) {
// todo: add your logic here and delete this line
return
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/chatrpc.go | app/chat/chat_rpc/chatrpc.go | package main
import (
"flag"
"fmt"
"beaver/app/chat/chat_rpc/internal/config"
"beaver/app/chat/chat_rpc/internal/server"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
grpcMiddleware "beaver/common/middleware/grpc"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/core/service"
"github.com/zeromicro/go-zero/zrpc"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
)
var configFile = flag.String("f", "etc/chatrpc.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
ctx := svc.NewServiceContext(c)
s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
chat_rpc.RegisterChatServer(grpcServer, server.NewChatServer(ctx))
if c.Mode == service.DevMode || c.Mode == service.TestMode {
reflection.Register(grpcServer)
}
})
defer s.Stop()
// 添加拦截器
s.AddUnaryInterceptors(grpcMiddleware.RequestLogInterceptor)
fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
s.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/chat/chat.go | app/chat/chat_rpc/chat/chat.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
// Source: chat_rpc.proto
package chat
import (
"context"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/zrpc"
"google.golang.org/grpc"
)
type (
AddConversationMembersReq = chat_rpc.AddConversationMembersReq
AddConversationMembersRes = chat_rpc.AddConversationMembersRes
AudioFileMsg = chat_rpc.AudioFileMsg
BatchUpdateConversationReq = chat_rpc.BatchUpdateConversationReq
BatchUpdateConversationRes = chat_rpc.BatchUpdateConversationRes
ConversationItem = chat_rpc.ConversationItem
ConversationListById = chat_rpc.ConversationListById
DissolveConversationReq = chat_rpc.DissolveConversationReq
DissolveConversationRes = chat_rpc.DissolveConversationRes
EmojiMsg = chat_rpc.EmojiMsg
FileMsg = chat_rpc.FileMsg
GetConversationsListByIdsReq = chat_rpc.GetConversationsListByIdsReq
GetConversationsListByIdsRes = chat_rpc.GetConversationsListByIdsRes
GetUserConversationSettingsListByIdsReq = chat_rpc.GetUserConversationSettingsListByIdsReq
GetUserConversationSettingsListByIdsRes = chat_rpc.GetUserConversationSettingsListByIdsRes
GetUserConversationVersionsReq = chat_rpc.GetUserConversationVersionsReq
GetUserConversationVersionsRes = chat_rpc.GetUserConversationVersionsRes
GetUserConversationsReq = chat_rpc.GetUserConversationsReq
GetUserConversationsRes = chat_rpc.GetUserConversationsRes
ImageMsg = chat_rpc.ImageMsg
InitializeConversationReq = chat_rpc.InitializeConversationReq
InitializeConversationRes = chat_rpc.InitializeConversationRes
Msg = chat_rpc.Msg
NotificationMsg = chat_rpc.NotificationMsg
RemoveConversationMembersReq = chat_rpc.RemoveConversationMembersReq
RemoveConversationMembersRes = chat_rpc.RemoveConversationMembersRes
SendMsgReq = chat_rpc.SendMsgReq
SendMsgRes = chat_rpc.SendMsgRes
SendNotificationMessageReq = chat_rpc.SendNotificationMessageReq
SendNotificationMessageRes = chat_rpc.SendNotificationMessageRes
Sender = chat_rpc.Sender
TextMsg = chat_rpc.TextMsg
UpdateConversationReq = chat_rpc.UpdateConversationReq
UpdateConversationRes = chat_rpc.UpdateConversationRes
UserConversationSettingListById = chat_rpc.UserConversationSettingListById
UserConversationVersion = chat_rpc.UserConversationVersion
VideoMsg = chat_rpc.VideoMsg
VoiceMsg = chat_rpc.VoiceMsg
Chat interface {
SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgRes, error)
UpdateConversation(ctx context.Context, in *UpdateConversationReq, opts ...grpc.CallOption) (*UpdateConversationRes, error)
BatchUpdateConversation(ctx context.Context, in *BatchUpdateConversationReq, opts ...grpc.CallOption) (*BatchUpdateConversationRes, error)
GetUserConversations(ctx context.Context, in *GetUserConversationsReq, opts ...grpc.CallOption) (*GetUserConversationsRes, error)
GetConversationsListByIds(ctx context.Context, in *GetConversationsListByIdsReq, opts ...grpc.CallOption) (*GetConversationsListByIdsRes, error)
GetUserConversationSettingsListByIds(ctx context.Context, in *GetUserConversationSettingsListByIdsReq, opts ...grpc.CallOption) (*GetUserConversationSettingsListByIdsRes, error)
GetUserConversationVersions(ctx context.Context, in *GetUserConversationVersionsReq, opts ...grpc.CallOption) (*GetUserConversationVersionsRes, error)
InitializeConversation(ctx context.Context, in *InitializeConversationReq, opts ...grpc.CallOption) (*InitializeConversationRes, error)
AddConversationMembers(ctx context.Context, in *AddConversationMembersReq, opts ...grpc.CallOption) (*AddConversationMembersRes, error)
RemoveConversationMembers(ctx context.Context, in *RemoveConversationMembersReq, opts ...grpc.CallOption) (*RemoveConversationMembersRes, error)
DissolveConversation(ctx context.Context, in *DissolveConversationReq, opts ...grpc.CallOption) (*DissolveConversationRes, error)
SendNotificationMessage(ctx context.Context, in *SendNotificationMessageReq, opts ...grpc.CallOption) (*SendNotificationMessageRes, error)
}
defaultChat struct {
cli zrpc.Client
}
)
func NewChat(cli zrpc.Client) Chat {
return &defaultChat{
cli: cli,
}
}
func (m *defaultChat) SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.SendMsg(ctx, in, opts...)
}
func (m *defaultChat) UpdateConversation(ctx context.Context, in *UpdateConversationReq, opts ...grpc.CallOption) (*UpdateConversationRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.UpdateConversation(ctx, in, opts...)
}
func (m *defaultChat) BatchUpdateConversation(ctx context.Context, in *BatchUpdateConversationReq, opts ...grpc.CallOption) (*BatchUpdateConversationRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.BatchUpdateConversation(ctx, in, opts...)
}
func (m *defaultChat) GetUserConversations(ctx context.Context, in *GetUserConversationsReq, opts ...grpc.CallOption) (*GetUserConversationsRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.GetUserConversations(ctx, in, opts...)
}
func (m *defaultChat) GetConversationsListByIds(ctx context.Context, in *GetConversationsListByIdsReq, opts ...grpc.CallOption) (*GetConversationsListByIdsRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.GetConversationsListByIds(ctx, in, opts...)
}
func (m *defaultChat) GetUserConversationSettingsListByIds(ctx context.Context, in *GetUserConversationSettingsListByIdsReq, opts ...grpc.CallOption) (*GetUserConversationSettingsListByIdsRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.GetUserConversationSettingsListByIds(ctx, in, opts...)
}
func (m *defaultChat) GetUserConversationVersions(ctx context.Context, in *GetUserConversationVersionsReq, opts ...grpc.CallOption) (*GetUserConversationVersionsRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.GetUserConversationVersions(ctx, in, opts...)
}
func (m *defaultChat) InitializeConversation(ctx context.Context, in *InitializeConversationReq, opts ...grpc.CallOption) (*InitializeConversationRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.InitializeConversation(ctx, in, opts...)
}
func (m *defaultChat) AddConversationMembers(ctx context.Context, in *AddConversationMembersReq, opts ...grpc.CallOption) (*AddConversationMembersRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.AddConversationMembers(ctx, in, opts...)
}
func (m *defaultChat) RemoveConversationMembers(ctx context.Context, in *RemoveConversationMembersReq, opts ...grpc.CallOption) (*RemoveConversationMembersRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.RemoveConversationMembers(ctx, in, opts...)
}
func (m *defaultChat) DissolveConversation(ctx context.Context, in *DissolveConversationReq, opts ...grpc.CallOption) (*DissolveConversationRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.DissolveConversation(ctx, in, opts...)
}
func (m *defaultChat) SendNotificationMessage(ctx context.Context, in *SendNotificationMessageReq, opts ...grpc.CallOption) (*SendNotificationMessageRes, error) {
client := chat_rpc.NewChatClient(m.cli.Conn())
return client.SendNotificationMessage(ctx, in, opts...)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/types/chat_rpc/chat_rpc.pb.go | app/chat/chat_rpc/types/chat_rpc/chat_rpc.pb.go | // Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.36.7
// protoc v4.25.3
// source: chat_rpc.proto
package chat_rpc
import (
reflect "reflect"
sync "sync"
unsafe "unsafe"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 定义TextMsg消息
type TextMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` // 文本消息内容
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TextMsg) Reset() {
*x = TextMsg{}
mi := &file_chat_rpc_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TextMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TextMsg) ProtoMessage() {}
func (x *TextMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TextMsg.ProtoReflect.Descriptor instead.
func (*TextMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{0}
}
func (x *TextMsg) GetContent() string {
if x != nil {
return x.Content
}
return ""
}
// 定义ImageMsg消息
type ImageMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 图片文件ID
Width int32 `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"` // 图片宽度（可选）
Height int32 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` // 图片高度（可选）
Size int64 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"` // 文件大小（字节，可选）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ImageMsg) Reset() {
*x = ImageMsg{}
mi := &file_chat_rpc_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ImageMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ImageMsg) ProtoMessage() {}
func (x *ImageMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ImageMsg.ProtoReflect.Descriptor instead.
func (*ImageMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{1}
}
func (x *ImageMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *ImageMsg) GetWidth() int32 {
if x != nil {
return x.Width
}
return 0
}
func (x *ImageMsg) GetHeight() int32 {
if x != nil {
return x.Height
}
return 0
}
func (x *ImageMsg) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
// 定义VideoMsg消息
type VideoMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 视频文件ID
Width int32 `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"` // 视频宽度（可选）
Height int32 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` // 视频高度（可选）
Duration int32 `protobuf:"varint,4,opt,name=duration,proto3" json:"duration,omitempty"` // 视频时长（秒，可选）
ThumbnailKey string `protobuf:"bytes,5,opt,name=thumbnailKey,proto3" json:"thumbnailKey,omitempty"` // 视频封面图文件ID（可选）
Size int64 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"` // 文件大小（字节，可选）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *VideoMsg) Reset() {
*x = VideoMsg{}
mi := &file_chat_rpc_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *VideoMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VideoMsg) ProtoMessage() {}
func (x *VideoMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use VideoMsg.ProtoReflect.Descriptor instead.
func (*VideoMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{2}
}
func (x *VideoMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *VideoMsg) GetWidth() int32 {
if x != nil {
return x.Width
}
return 0
}
func (x *VideoMsg) GetHeight() int32 {
if x != nil {
return x.Height
}
return 0
}
func (x *VideoMsg) GetDuration() int32 {
if x != nil {
return x.Duration
}
return 0
}
func (x *VideoMsg) GetThumbnailKey() string {
if x != nil {
return x.ThumbnailKey
}
return ""
}
func (x *VideoMsg) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
// 定义FileMsg消息
type FileMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 文件ID
FileName string `protobuf:"bytes,2,opt,name=fileName,proto3" json:"fileName,omitempty"` // 原始文件名（可选，用于显示）
Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` // 文件大小（字节，可选）
MimeType string `protobuf:"bytes,4,opt,name=mimeType,proto3" json:"mimeType,omitempty"` // MIME类型（可选，如 application/pdf）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FileMsg) Reset() {
*x = FileMsg{}
mi := &file_chat_rpc_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FileMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FileMsg) ProtoMessage() {}
func (x *FileMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FileMsg.ProtoReflect.Descriptor instead.
func (*FileMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{3}
}
func (x *FileMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *FileMsg) GetFileName() string {
if x != nil {
return x.FileName
}
return ""
}
func (x *FileMsg) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
func (x *FileMsg) GetMimeType() string {
if x != nil {
return x.MimeType
}
return ""
}
// 定义VoiceMsg消息
type VoiceMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 语音文件ID
Duration int32 `protobuf:"varint,2,opt,name=duration,proto3" json:"duration,omitempty"` // 语音时长（秒，可选）
Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` // 文件大小（字节，可选）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *VoiceMsg) Reset() {
*x = VoiceMsg{}
mi := &file_chat_rpc_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *VoiceMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VoiceMsg) ProtoMessage() {}
func (x *VoiceMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use VoiceMsg.ProtoReflect.Descriptor instead.
func (*VoiceMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{4}
}
func (x *VoiceMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *VoiceMsg) GetDuration() int32 {
if x != nil {
return x.Duration
}
return 0
}
func (x *VoiceMsg) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
// 定义AudioFileMsg消息 - 音频文件消息
type AudioFileMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 音频文件ID
FileName string `protobuf:"bytes,2,opt,name=fileName,proto3" json:"fileName,omitempty"` // 原始文件名（可选，用于显示）
Duration int32 `protobuf:"varint,3,opt,name=duration,proto3" json:"duration,omitempty"` // 音频时长（秒，可选）
Size int64 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"` // 文件大小（字节，可选）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *AudioFileMsg) Reset() {
*x = AudioFileMsg{}
mi := &file_chat_rpc_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *AudioFileMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AudioFileMsg) ProtoMessage() {}
func (x *AudioFileMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AudioFileMsg.ProtoReflect.Descriptor instead.
func (*AudioFileMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{5}
}
func (x *AudioFileMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *AudioFileMsg) GetFileName() string {
if x != nil {
return x.FileName
}
return ""
}
func (x *AudioFileMsg) GetDuration() int32 {
if x != nil {
return x.Duration
}
return 0
}
func (x *AudioFileMsg) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
// 定义EmojiMsg消息 - 表情相关消息
type EmojiMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 表情图片文件ID（Emoji.FileName）
EmojiId string `protobuf:"bytes,2,opt,name=emojiId,proto3" json:"emojiId,omitempty"` // 表情ID（Emoji.ID，单个表情时使用）
PackageId string `protobuf:"bytes,3,opt,name=packageId,proto3" json:"packageId,omitempty"` // 表情包ID（EmojiPackage.ID，表情包分享时使用）
Width int64 `protobuf:"varint,4,opt,name=width,proto3" json:"width,omitempty"` // 表情图片宽度（可选，用于保持比例显示）
Height int64 `protobuf:"varint,5,opt,name=height,proto3" json:"height,omitempty"` // 表情图片高度（可选，用于保持比例显示）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EmojiMsg) Reset() {
*x = EmojiMsg{}
mi := &file_chat_rpc_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EmojiMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EmojiMsg) ProtoMessage() {}
func (x *EmojiMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EmojiMsg.ProtoReflect.Descriptor instead.
func (*EmojiMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{6}
}
func (x *EmojiMsg) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *EmojiMsg) GetEmojiId() string {
if x != nil {
return x.EmojiId
}
return ""
}
func (x *EmojiMsg) GetPackageId() string {
if x != nil {
return x.PackageId
}
return ""
}
func (x *EmojiMsg) GetWidth() int64 {
if x != nil {
return x.Width
}
return 0
}
func (x *EmojiMsg) GetHeight() int64 {
if x != nil {
return x.Height
}
return 0
}
// 定义NotificationMsg消息 - 通知消息（会话内的通知，如：xxx加入了群聊、xxx创建了群、添加好友成功等）
type NotificationMsg struct {
state protoimpl.MessageState `protogen:"open.v1"`
Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` // 通知类型：1=好友欢迎 2=创建群 3=加入群 4=退出群 5=踢出成员 6=转让群主等
Actors []string `protobuf:"bytes,2,rep,name=actors,proto3" json:"actors,omitempty"` // 相关用户ID列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *NotificationMsg) Reset() {
*x = NotificationMsg{}
mi := &file_chat_rpc_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *NotificationMsg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*NotificationMsg) ProtoMessage() {}
func (x *NotificationMsg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[7]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use NotificationMsg.ProtoReflect.Descriptor instead.
func (*NotificationMsg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{7}
}
func (x *NotificationMsg) GetType() int32 {
if x != nil {
return x.Type
}
return 0
}
func (x *NotificationMsg) GetActors() []string {
if x != nil {
return x.Actors
}
return nil
}
// 定义Msg消息
type Msg struct {
state protoimpl.MessageState `protogen:"open.v1"`
Type uint32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` // 消息类型 1:文本 2:图片 3:视频 4:文件 5:语音 6:表情 7:通知消息 8:音频文件
TextMsg *TextMsg `protobuf:"bytes,2,opt,name=textMsg,proto3" json:"textMsg,omitempty"` // 文本消息
ImageMsg *ImageMsg `protobuf:"bytes,3,opt,name=imageMsg,proto3" json:"imageMsg,omitempty"` // 图片
VideoMsg *VideoMsg `protobuf:"bytes,4,opt,name=videoMsg,proto3" json:"videoMsg,omitempty"` // 视频
FileMsg *FileMsg `protobuf:"bytes,5,opt,name=fileMsg,proto3" json:"fileMsg,omitempty"` // 文件
VoiceMsg *VoiceMsg `protobuf:"bytes,6,opt,name=voiceMsg,proto3" json:"voiceMsg,omitempty"` // 语音（移动端录制的短语音）
EmojiMsg *EmojiMsg `protobuf:"bytes,7,opt,name=emojiMsg,proto3" json:"emojiMsg,omitempty"` // 表情（单个表情或表情包）
NotificationMsg *NotificationMsg `protobuf:"bytes,8,opt,name=notificationMsg,proto3" json:"notificationMsg,omitempty"` // 通知消息（会话内的通知，如：xxx加入了群聊、xxx创建了群等）
AudioFileMsg *AudioFileMsg `protobuf:"bytes,9,opt,name=audioFileMsg,proto3" json:"audioFileMsg,omitempty"` // 音频文件（用户上传的音频文件）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Msg) Reset() {
*x = Msg{}
mi := &file_chat_rpc_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Msg) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Msg) ProtoMessage() {}
func (x *Msg) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[8]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Msg.ProtoReflect.Descriptor instead.
func (*Msg) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{8}
}
func (x *Msg) GetType() uint32 {
if x != nil {
return x.Type
}
return 0
}
func (x *Msg) GetTextMsg() *TextMsg {
if x != nil {
return x.TextMsg
}
return nil
}
func (x *Msg) GetImageMsg() *ImageMsg {
if x != nil {
return x.ImageMsg
}
return nil
}
func (x *Msg) GetVideoMsg() *VideoMsg {
if x != nil {
return x.VideoMsg
}
return nil
}
func (x *Msg) GetFileMsg() *FileMsg {
if x != nil {
return x.FileMsg
}
return nil
}
func (x *Msg) GetVoiceMsg() *VoiceMsg {
if x != nil {
return x.VoiceMsg
}
return nil
}
func (x *Msg) GetEmojiMsg() *EmojiMsg {
if x != nil {
return x.EmojiMsg
}
return nil
}
func (x *Msg) GetNotificationMsg() *NotificationMsg {
if x != nil {
return x.NotificationMsg
}
return nil
}
func (x *Msg) GetAudioFileMsg() *AudioFileMsg {
if x != nil {
return x.AudioFileMsg
}
return nil
}
// 定义SendMsgReq消息
type SendMsgReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserId string `protobuf:"bytes,1,opt,name=userId,proto3" json:"userId,omitempty"` // 用户ID
ConversationId string `protobuf:"bytes,2,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"` // 会话ID
MessageId string `protobuf:"bytes,3,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"` // 客户端消息ID
Msg *Msg `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"` // 消息内容
DeviceId string `protobuf:"bytes,5,opt,name=deviceId,proto3" json:"deviceId,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *SendMsgReq) Reset() {
*x = SendMsgReq{}
mi := &file_chat_rpc_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *SendMsgReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SendMsgReq) ProtoMessage() {}
func (x *SendMsgReq) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[9]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SendMsgReq.ProtoReflect.Descriptor instead.
func (*SendMsgReq) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{9}
}
func (x *SendMsgReq) GetUserId() string {
if x != nil {
return x.UserId
}
return ""
}
func (x *SendMsgReq) GetConversationId() string {
if x != nil {
return x.ConversationId
}
return ""
}
func (x *SendMsgReq) GetMessageId() string {
if x != nil {
return x.MessageId
}
return ""
}
func (x *SendMsgReq) GetMsg() *Msg {
if x != nil {
return x.Msg
}
return nil
}
func (x *SendMsgReq) GetDeviceId() string {
if x != nil {
return x.DeviceId
}
return ""
}
// 定义Sender消息
type Sender struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserId string `protobuf:"bytes,1,opt,name=userId,proto3" json:"userId,omitempty"`
Avatar string `protobuf:"bytes,2,opt,name=avatar,proto3" json:"avatar,omitempty"`
NickName string `protobuf:"bytes,3,opt,name=nickName,proto3" json:"nickName,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Sender) Reset() {
*x = Sender{}
mi := &file_chat_rpc_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Sender) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Sender) ProtoMessage() {}
func (x *Sender) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[10]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Sender.ProtoReflect.Descriptor instead.
func (*Sender) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{10}
}
func (x *Sender) GetUserId() string {
if x != nil {
return x.UserId
}
return ""
}
func (x *Sender) GetAvatar() string {
if x != nil {
return x.Avatar
}
return ""
}
func (x *Sender) GetNickName() string {
if x != nil {
return x.NickName
}
return ""
}
// 定义SendMsgRes消息
type SendMsgRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // 数据库自增ID
MessageId string `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"` // 客户端消息ID
ConversationId string `protobuf:"bytes,3,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"` // 会话ID
Msg *Msg `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"` // 消息内容
Sender *Sender `protobuf:"bytes,5,opt,name=sender,proto3" json:"sender,omitempty"` // 发送者
CreatedAt string `protobuf:"bytes,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // 消息时间
MsgPreview string `protobuf:"bytes,7,opt,name=msg_preview,json=msgPreview,proto3" json:"msg_preview,omitempty"` // 消息预览
Status uint32 `protobuf:"varint,8,opt,name=status,proto3" json:"status,omitempty"` // 消息状态 1:正常 2:已撤回 3:已编辑
Seq int64 `protobuf:"varint,9,opt,name=seq,proto3" json:"seq,omitempty"` // 消息序列号，用于数据同步
ConversationType uint32 `protobuf:"varint,10,opt,name=conversation_type,json=conversationType,proto3" json:"conversation_type,omitempty"` // 会话类型 1:私聊 2:群聊
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *SendMsgRes) Reset() {
*x = SendMsgRes{}
mi := &file_chat_rpc_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *SendMsgRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SendMsgRes) ProtoMessage() {}
func (x *SendMsgRes) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[11]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SendMsgRes.ProtoReflect.Descriptor instead.
func (*SendMsgRes) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{11}
}
func (x *SendMsgRes) GetId() uint32 {
if x != nil {
return x.Id
}
return 0
}
func (x *SendMsgRes) GetMessageId() string {
if x != nil {
return x.MessageId
}
return ""
}
func (x *SendMsgRes) GetConversationId() string {
if x != nil {
return x.ConversationId
}
return ""
}
func (x *SendMsgRes) GetMsg() *Msg {
if x != nil {
return x.Msg
}
return nil
}
func (x *SendMsgRes) GetSender() *Sender {
if x != nil {
return x.Sender
}
return nil
}
func (x *SendMsgRes) GetCreateAt() string {
if x != nil {
return x.CreatedAt
}
return ""
}
func (x *SendMsgRes) GetMsgPreview() string {
if x != nil {
return x.MsgPreview
}
return ""
}
func (x *SendMsgRes) GetStatus() uint32 {
if x != nil {
return x.Status
}
return 0
}
func (x *SendMsgRes) GetSeq() int64 {
if x != nil {
return x.Seq
}
return 0
}
func (x *SendMsgRes) GetConversationType() uint32 {
if x != nil {
return x.ConversationType
}
return 0
}
// 定义UpdateConversationReq消息
type UpdateConversationReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
ConversationId string `protobuf:"bytes,1,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"` // 会话ID
UserId string `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` // 用户ID
LastMessage string `protobuf:"bytes,3,opt,name=last_message,json=lastMessage,proto3" json:"last_message,omitempty"` // 最后一条消息
IsPinned bool `protobuf:"varint,4,opt,name=is_pinned,json=isPinned,proto3" json:"is_pinned,omitempty"` // 是否置顶
IsDeleted bool `protobuf:"varint,5,opt,name=is_deleted,json=isDeleted,proto3" json:"is_deleted,omitempty"` // 是否已删除
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *UpdateConversationReq) Reset() {
*x = UpdateConversationReq{}
mi := &file_chat_rpc_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *UpdateConversationReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateConversationReq) ProtoMessage() {}
func (x *UpdateConversationReq) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[12]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateConversationReq.ProtoReflect.Descriptor instead.
func (*UpdateConversationReq) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{12}
}
func (x *UpdateConversationReq) GetConversationId() string {
if x != nil {
return x.ConversationId
}
return ""
}
func (x *UpdateConversationReq) GetUserId() string {
if x != nil {
return x.UserId
}
return ""
}
func (x *UpdateConversationReq) GetLastMessage() string {
if x != nil {
return x.LastMessage
}
return ""
}
func (x *UpdateConversationReq) GetIsPinned() bool {
if x != nil {
return x.IsPinned
}
return false
}
func (x *UpdateConversationReq) GetIsDeleted() bool {
if x != nil {
return x.IsDeleted
}
return false
}
// 定义UpdateConversationRes消息
type UpdateConversationRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` // 是否成功
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *UpdateConversationRes) Reset() {
*x = UpdateConversationRes{}
mi := &file_chat_rpc_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *UpdateConversationRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateConversationRes) ProtoMessage() {}
func (x *UpdateConversationRes) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[13]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateConversationRes.ProtoReflect.Descriptor instead.
func (*UpdateConversationRes) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{13}
}
func (x *UpdateConversationRes) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
// 定义BatchUpdateConversationReq消息
type BatchUpdateConversationReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
ConversationId string `protobuf:"bytes,1,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"` // 会话ID
UserIds []string `protobuf:"bytes,2,rep,name=user_ids,json=userIds,proto3" json:"user_ids,omitempty"` // 用户ID列表
LastMessage string `protobuf:"bytes,3,opt,name=last_message,json=lastMessage,proto3" json:"last_message,omitempty"` // 最后一条消息
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *BatchUpdateConversationReq) Reset() {
*x = BatchUpdateConversationReq{}
mi := &file_chat_rpc_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *BatchUpdateConversationReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BatchUpdateConversationReq) ProtoMessage() {}
func (x *BatchUpdateConversationReq) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[14]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BatchUpdateConversationReq.ProtoReflect.Descriptor instead.
func (*BatchUpdateConversationReq) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{14}
}
func (x *BatchUpdateConversationReq) GetConversationId() string {
if x != nil {
return x.ConversationId
}
return ""
}
func (x *BatchUpdateConversationReq) GetUserIds() []string {
if x != nil {
return x.UserIds
}
return nil
}
func (x *BatchUpdateConversationReq) GetLastMessage() string {
if x != nil {
return x.LastMessage
}
return ""
}
// 定义BatchUpdateConversationRes消息
type BatchUpdateConversationRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` // 是否成功
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *BatchUpdateConversationRes) Reset() {
*x = BatchUpdateConversationRes{}
mi := &file_chat_rpc_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *BatchUpdateConversationRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BatchUpdateConversationRes) ProtoMessage() {}
func (x *BatchUpdateConversationRes) ProtoReflect() protoreflect.Message {
mi := &file_chat_rpc_proto_msgTypes[15]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BatchUpdateConversationRes.ProtoReflect.Descriptor instead.
func (*BatchUpdateConversationRes) Descriptor() ([]byte, []int) {
return file_chat_rpc_proto_rawDescGZIP(), []int{15}
}
func (x *BatchUpdateConversationRes) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
// 定义GetUserConversationsReq消息 - 获取用户参与的会话列表
type GetUserConversationsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | true |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/types/chat_rpc/chat_rpc_grpc.pb.go | app/chat/chat_rpc/types/chat_rpc/chat_rpc_grpc.pb.go | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc v4.25.3
// source: chat_rpc.proto
package chat_rpc
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9
const (
Chat_SendMsg_FullMethodName = "/chat_rpc.Chat/SendMsg"
Chat_UpdateConversation_FullMethodName = "/chat_rpc.Chat/UpdateConversation"
Chat_BatchUpdateConversation_FullMethodName = "/chat_rpc.Chat/BatchUpdateConversation"
Chat_GetUserConversations_FullMethodName = "/chat_rpc.Chat/GetUserConversations"
Chat_GetConversationsListByIds_FullMethodName = "/chat_rpc.Chat/GetConversationsListByIds"
Chat_GetUserConversationSettingsListByIds_FullMethodName = "/chat_rpc.Chat/GetUserConversationSettingsListByIds"
Chat_GetUserConversationVersions_FullMethodName = "/chat_rpc.Chat/GetUserConversationVersions"
Chat_InitializeConversation_FullMethodName = "/chat_rpc.Chat/InitializeConversation"
Chat_AddConversationMembers_FullMethodName = "/chat_rpc.Chat/AddConversationMembers"
Chat_RemoveConversationMembers_FullMethodName = "/chat_rpc.Chat/RemoveConversationMembers"
Chat_DissolveConversation_FullMethodName = "/chat_rpc.Chat/DissolveConversation"
Chat_SendNotificationMessage_FullMethodName = "/chat_rpc.Chat/SendNotificationMessage"
)
// ChatClient is the client API for Chat service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
//
// 定义chat_rpc服务
type ChatClient interface {
SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgRes, error)
UpdateConversation(ctx context.Context, in *UpdateConversationReq, opts ...grpc.CallOption) (*UpdateConversationRes, error)
BatchUpdateConversation(ctx context.Context, in *BatchUpdateConversationReq, opts ...grpc.CallOption) (*BatchUpdateConversationRes, error)
GetUserConversations(ctx context.Context, in *GetUserConversationsReq, opts ...grpc.CallOption) (*GetUserConversationsRes, error)
GetConversationsListByIds(ctx context.Context, in *GetConversationsListByIdsReq, opts ...grpc.CallOption) (*GetConversationsListByIdsRes, error)
GetUserConversationSettingsListByIds(ctx context.Context, in *GetUserConversationSettingsListByIdsReq, opts ...grpc.CallOption) (*GetUserConversationSettingsListByIdsRes, error)
GetUserConversationVersions(ctx context.Context, in *GetUserConversationVersionsReq, opts ...grpc.CallOption) (*GetUserConversationVersionsRes, error)
InitializeConversation(ctx context.Context, in *InitializeConversationReq, opts ...grpc.CallOption) (*InitializeConversationRes, error)
AddConversationMembers(ctx context.Context, in *AddConversationMembersReq, opts ...grpc.CallOption) (*AddConversationMembersRes, error)
RemoveConversationMembers(ctx context.Context, in *RemoveConversationMembersReq, opts ...grpc.CallOption) (*RemoveConversationMembersRes, error)
DissolveConversation(ctx context.Context, in *DissolveConversationReq, opts ...grpc.CallOption) (*DissolveConversationRes, error)
SendNotificationMessage(ctx context.Context, in *SendNotificationMessageReq, opts ...grpc.CallOption) (*SendNotificationMessageRes, error)
}
type chatClient struct {
cc grpc.ClientConnInterface
}
func NewChatClient(cc grpc.ClientConnInterface) ChatClient {
return &chatClient{cc}
}
func (c *chatClient) SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(SendMsgRes)
err := c.cc.Invoke(ctx, Chat_SendMsg_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) UpdateConversation(ctx context.Context, in *UpdateConversationReq, opts ...grpc.CallOption) (*UpdateConversationRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(UpdateConversationRes)
err := c.cc.Invoke(ctx, Chat_UpdateConversation_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) BatchUpdateConversation(ctx context.Context, in *BatchUpdateConversationReq, opts ...grpc.CallOption) (*BatchUpdateConversationRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(BatchUpdateConversationRes)
err := c.cc.Invoke(ctx, Chat_BatchUpdateConversation_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) GetUserConversations(ctx context.Context, in *GetUserConversationsReq, opts ...grpc.CallOption) (*GetUserConversationsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserConversationsRes)
err := c.cc.Invoke(ctx, Chat_GetUserConversations_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) GetConversationsListByIds(ctx context.Context, in *GetConversationsListByIdsReq, opts ...grpc.CallOption) (*GetConversationsListByIdsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetConversationsListByIdsRes)
err := c.cc.Invoke(ctx, Chat_GetConversationsListByIds_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) GetUserConversationSettingsListByIds(ctx context.Context, in *GetUserConversationSettingsListByIdsReq, opts ...grpc.CallOption) (*GetUserConversationSettingsListByIdsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserConversationSettingsListByIdsRes)
err := c.cc.Invoke(ctx, Chat_GetUserConversationSettingsListByIds_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) GetUserConversationVersions(ctx context.Context, in *GetUserConversationVersionsReq, opts ...grpc.CallOption) (*GetUserConversationVersionsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserConversationVersionsRes)
err := c.cc.Invoke(ctx, Chat_GetUserConversationVersions_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) InitializeConversation(ctx context.Context, in *InitializeConversationReq, opts ...grpc.CallOption) (*InitializeConversationRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(InitializeConversationRes)
err := c.cc.Invoke(ctx, Chat_InitializeConversation_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) AddConversationMembers(ctx context.Context, in *AddConversationMembersReq, opts ...grpc.CallOption) (*AddConversationMembersRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(AddConversationMembersRes)
err := c.cc.Invoke(ctx, Chat_AddConversationMembers_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) RemoveConversationMembers(ctx context.Context, in *RemoveConversationMembersReq, opts ...grpc.CallOption) (*RemoveConversationMembersRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(RemoveConversationMembersRes)
err := c.cc.Invoke(ctx, Chat_RemoveConversationMembers_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) DissolveConversation(ctx context.Context, in *DissolveConversationReq, opts ...grpc.CallOption) (*DissolveConversationRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(DissolveConversationRes)
err := c.cc.Invoke(ctx, Chat_DissolveConversation_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) SendNotificationMessage(ctx context.Context, in *SendNotificationMessageReq, opts ...grpc.CallOption) (*SendNotificationMessageRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(SendNotificationMessageRes)
err := c.cc.Invoke(ctx, Chat_SendNotificationMessage_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
// ChatServer is the server API for Chat service.
// All implementations must embed UnimplementedChatServer
// for forward compatibility.
//
// 定义chat_rpc服务
type ChatServer interface {
SendMsg(context.Context, *SendMsgReq) (*SendMsgRes, error)
UpdateConversation(context.Context, *UpdateConversationReq) (*UpdateConversationRes, error)
BatchUpdateConversation(context.Context, *BatchUpdateConversationReq) (*BatchUpdateConversationRes, error)
GetUserConversations(context.Context, *GetUserConversationsReq) (*GetUserConversationsRes, error)
GetConversationsListByIds(context.Context, *GetConversationsListByIdsReq) (*GetConversationsListByIdsRes, error)
GetUserConversationSettingsListByIds(context.Context, *GetUserConversationSettingsListByIdsReq) (*GetUserConversationSettingsListByIdsRes, error)
GetUserConversationVersions(context.Context, *GetUserConversationVersionsReq) (*GetUserConversationVersionsRes, error)
InitializeConversation(context.Context, *InitializeConversationReq) (*InitializeConversationRes, error)
AddConversationMembers(context.Context, *AddConversationMembersReq) (*AddConversationMembersRes, error)
RemoveConversationMembers(context.Context, *RemoveConversationMembersReq) (*RemoveConversationMembersRes, error)
DissolveConversation(context.Context, *DissolveConversationReq) (*DissolveConversationRes, error)
SendNotificationMessage(context.Context, *SendNotificationMessageReq) (*SendNotificationMessageRes, error)
mustEmbedUnimplementedChatServer()
}
// UnimplementedChatServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedChatServer struct{}
func (UnimplementedChatServer) SendMsg(context.Context, *SendMsgReq) (*SendMsgRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method SendMsg not implemented")
}
func (UnimplementedChatServer) UpdateConversation(context.Context, *UpdateConversationReq) (*UpdateConversationRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpdateConversation not implemented")
}
func (UnimplementedChatServer) BatchUpdateConversation(context.Context, *BatchUpdateConversationReq) (*BatchUpdateConversationRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method BatchUpdateConversation not implemented")
}
func (UnimplementedChatServer) GetUserConversations(context.Context, *GetUserConversationsReq) (*GetUserConversationsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserConversations not implemented")
}
func (UnimplementedChatServer) GetConversationsListByIds(context.Context, *GetConversationsListByIdsReq) (*GetConversationsListByIdsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetConversationsListByIds not implemented")
}
func (UnimplementedChatServer) GetUserConversationSettingsListByIds(context.Context, *GetUserConversationSettingsListByIdsReq) (*GetUserConversationSettingsListByIdsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserConversationSettingsListByIds not implemented")
}
func (UnimplementedChatServer) GetUserConversationVersions(context.Context, *GetUserConversationVersionsReq) (*GetUserConversationVersionsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserConversationVersions not implemented")
}
func (UnimplementedChatServer) InitializeConversation(context.Context, *InitializeConversationReq) (*InitializeConversationRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method InitializeConversation not implemented")
}
func (UnimplementedChatServer) AddConversationMembers(context.Context, *AddConversationMembersReq) (*AddConversationMembersRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method AddConversationMembers not implemented")
}
func (UnimplementedChatServer) RemoveConversationMembers(context.Context, *RemoveConversationMembersReq) (*RemoveConversationMembersRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method RemoveConversationMembers not implemented")
}
func (UnimplementedChatServer) DissolveConversation(context.Context, *DissolveConversationReq) (*DissolveConversationRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method DissolveConversation not implemented")
}
func (UnimplementedChatServer) SendNotificationMessage(context.Context, *SendNotificationMessageReq) (*SendNotificationMessageRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method SendNotificationMessage not implemented")
}
func (UnimplementedChatServer) mustEmbedUnimplementedChatServer() {}
func (UnimplementedChatServer) testEmbeddedByValue() {}
// UnsafeChatServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ChatServer will
// result in compilation errors.
type UnsafeChatServer interface {
mustEmbedUnimplementedChatServer()
}
func RegisterChatServer(s grpc.ServiceRegistrar, srv ChatServer) {
// If the following call pancis, it indicates UnimplementedChatServer was
// embedded by pointer and is nil. This will cause panics if an
// unimplemented method is ever invoked, so we test this at initialization
// time to prevent it from happening at runtime later due to I/O.
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
t.testEmbeddedByValue()
}
s.RegisterService(&Chat_ServiceDesc, srv)
}
func _Chat_SendMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SendMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).SendMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_SendMsg_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).SendMsg(ctx, req.(*SendMsgReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_UpdateConversation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateConversationReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).UpdateConversation(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_UpdateConversation_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).UpdateConversation(ctx, req.(*UpdateConversationReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_BatchUpdateConversation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BatchUpdateConversationReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).BatchUpdateConversation(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_BatchUpdateConversation_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).BatchUpdateConversation(ctx, req.(*BatchUpdateConversationReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_GetUserConversations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserConversationsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).GetUserConversations(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_GetUserConversations_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).GetUserConversations(ctx, req.(*GetUserConversationsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_GetConversationsListByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConversationsListByIdsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).GetConversationsListByIds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_GetConversationsListByIds_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).GetConversationsListByIds(ctx, req.(*GetConversationsListByIdsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_GetUserConversationSettingsListByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserConversationSettingsListByIdsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).GetUserConversationSettingsListByIds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_GetUserConversationSettingsListByIds_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).GetUserConversationSettingsListByIds(ctx, req.(*GetUserConversationSettingsListByIdsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_GetUserConversationVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserConversationVersionsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).GetUserConversationVersions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_GetUserConversationVersions_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).GetUserConversationVersions(ctx, req.(*GetUserConversationVersionsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_InitializeConversation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InitializeConversationReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).InitializeConversation(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_InitializeConversation_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).InitializeConversation(ctx, req.(*InitializeConversationReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_AddConversationMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AddConversationMembersReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).AddConversationMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_AddConversationMembers_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).AddConversationMembers(ctx, req.(*AddConversationMembersReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_RemoveConversationMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RemoveConversationMembersReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).RemoveConversationMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_RemoveConversationMembers_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).RemoveConversationMembers(ctx, req.(*RemoveConversationMembersReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_DissolveConversation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DissolveConversationReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).DissolveConversation(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_DissolveConversation_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).DissolveConversation(ctx, req.(*DissolveConversationReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_SendNotificationMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SendNotificationMessageReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).SendNotificationMessage(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Chat_SendNotificationMessage_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).SendNotificationMessage(ctx, req.(*SendNotificationMessageReq))
}
return interceptor(ctx, in, info, handler)
}
// Chat_ServiceDesc is the grpc.ServiceDesc for Chat service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Chat_ServiceDesc = grpc.ServiceDesc{
ServiceName: "chat_rpc.Chat",
HandlerType: (*ChatServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "SendMsg",
Handler: _Chat_SendMsg_Handler,
},
{
MethodName: "UpdateConversation",
Handler: _Chat_UpdateConversation_Handler,
},
{
MethodName: "BatchUpdateConversation",
Handler: _Chat_BatchUpdateConversation_Handler,
},
{
MethodName: "GetUserConversations",
Handler: _Chat_GetUserConversations_Handler,
},
{
MethodName: "GetConversationsListByIds",
Handler: _Chat_GetConversationsListByIds_Handler,
},
{
MethodName: "GetUserConversationSettingsListByIds",
Handler: _Chat_GetUserConversationSettingsListByIds_Handler,
},
{
MethodName: "GetUserConversationVersions",
Handler: _Chat_GetUserConversationVersions_Handler,
},
{
MethodName: "InitializeConversation",
Handler: _Chat_InitializeConversation_Handler,
},
{
MethodName: "AddConversationMembers",
Handler: _Chat_AddConversationMembers_Handler,
},
{
MethodName: "RemoveConversationMembers",
Handler: _Chat_RemoveConversationMembers_Handler,
},
{
MethodName: "DissolveConversation",
Handler: _Chat_DissolveConversation_Handler,
},
{
MethodName: "SendNotificationMessage",
Handler: _Chat_SendNotificationMessage_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "chat_rpc.proto",
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/svc/servicecontext.go | app/chat/chat_rpc/internal/svc/servicecontext.go | package svc
import (
"beaver/app/chat/chat_rpc/internal/config"
"beaver/app/user/user_rpc/user"
"beaver/core"
versionPkg "beaver/core/version"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
DB *gorm.DB
Redis *redis.Client
VersionGen *versionPkg.VersionGenerator
UserRpc user.User
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.RedisConf.Addr, c.RedisConf.Password, c.RedisConf.Db)
versionGen := versionPkg.NewVersionGenerator(client, mysqlDb)
userRpc := user.NewUser(zrpc.MustNewClient(c.UserRpc))
return &ServiceContext{
Config: c,
Redis: client,
DB: mysqlDb,
VersionGen: versionGen,
UserRpc: userRpc,
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/server/chatserver.go | app/chat/chat_rpc/internal/server/chatserver.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
// Source: chat_rpc.proto
package server
import (
"context"
"beaver/app/chat/chat_rpc/internal/logic"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
)
type ChatServer struct {
svcCtx *svc.ServiceContext
chat_rpc.UnimplementedChatServer
}
func NewChatServer(svcCtx *svc.ServiceContext) *ChatServer {
return &ChatServer{
svcCtx: svcCtx,
}
}
func (s *ChatServer) SendMsg(ctx context.Context, in *chat_rpc.SendMsgReq) (*chat_rpc.SendMsgRes, error) {
l := logic.NewSendMsgLogic(ctx, s.svcCtx)
return l.SendMsg(in)
}
func (s *ChatServer) UpdateConversation(ctx context.Context, in *chat_rpc.UpdateConversationReq) (*chat_rpc.UpdateConversationRes, error) {
l := logic.NewUpdateConversationLogic(ctx, s.svcCtx)
return l.UpdateConversation(in)
}
func (s *ChatServer) BatchUpdateConversation(ctx context.Context, in *chat_rpc.BatchUpdateConversationReq) (*chat_rpc.BatchUpdateConversationRes, error) {
l := logic.NewBatchUpdateConversationLogic(ctx, s.svcCtx)
return l.BatchUpdateConversation(in)
}
func (s *ChatServer) GetUserConversations(ctx context.Context, in *chat_rpc.GetUserConversationsReq) (*chat_rpc.GetUserConversationsRes, error) {
l := logic.NewGetUserConversationsLogic(ctx, s.svcCtx)
return l.GetUserConversations(in)
}
func (s *ChatServer) GetConversationsListByIds(ctx context.Context, in *chat_rpc.GetConversationsListByIdsReq) (*chat_rpc.GetConversationsListByIdsRes, error) {
l := logic.NewGetConversationsListByIdsLogic(ctx, s.svcCtx)
return l.GetConversationsListByIds(in)
}
func (s *ChatServer) GetUserConversationSettingsListByIds(ctx context.Context, in *chat_rpc.GetUserConversationSettingsListByIdsReq) (*chat_rpc.GetUserConversationSettingsListByIdsRes, error) {
l := logic.NewGetUserConversationSettingsListByIdsLogic(ctx, s.svcCtx)
return l.GetUserConversationSettingsListByIds(in)
}
func (s *ChatServer) GetUserConversationVersions(ctx context.Context, in *chat_rpc.GetUserConversationVersionsReq) (*chat_rpc.GetUserConversationVersionsRes, error) {
l := logic.NewGetUserConversationVersionsLogic(ctx, s.svcCtx)
return l.GetUserConversationVersions(in)
}
func (s *ChatServer) InitializeConversation(ctx context.Context, in *chat_rpc.InitializeConversationReq) (*chat_rpc.InitializeConversationRes, error) {
l := logic.NewInitializeConversationLogic(ctx, s.svcCtx)
return l.InitializeConversation(in)
}
func (s *ChatServer) AddConversationMembers(ctx context.Context, in *chat_rpc.AddConversationMembersReq) (*chat_rpc.AddConversationMembersRes, error) {
l := logic.NewAddConversationMembersLogic(ctx, s.svcCtx)
return l.AddConversationMembers(in)
}
func (s *ChatServer) RemoveConversationMembers(ctx context.Context, in *chat_rpc.RemoveConversationMembersReq) (*chat_rpc.RemoveConversationMembersRes, error) {
l := logic.NewRemoveConversationMembersLogic(ctx, s.svcCtx)
return l.RemoveConversationMembers(in)
}
func (s *ChatServer) DissolveConversation(ctx context.Context, in *chat_rpc.DissolveConversationReq) (*chat_rpc.DissolveConversationRes, error) {
l := logic.NewDissolveConversationLogic(ctx, s.svcCtx)
return l.DissolveConversation(in)
}
func (s *ChatServer) SendNotificationMessage(ctx context.Context, in *chat_rpc.SendNotificationMessageReq) (*chat_rpc.SendNotificationMessageRes, error) {
l := logic.NewSendNotificationMessageLogic(ctx, s.svcCtx)
return l.SendNotificationMessage(in)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/config/config.go | app/chat/chat_rpc/internal/config/config.go | package config
import "github.com/zeromicro/go-zero/zrpc"
type Config struct {
zrpc.RpcServerConf
Mysql struct {
DataSource string
}
RedisConf struct {
Addr string
Password string
Db int
}
DatasyncRpc zrpc.RpcClientConf
UserRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/removeconversationmemberslogic.go | app/chat/chat_rpc/internal/logic/removeconversationmemberslogic.go | package logic
import (
"context"
"errors"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type RemoveConversationMembersLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewRemoveConversationMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RemoveConversationMembersLogic {
return &RemoveConversationMembersLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *RemoveConversationMembersLogic) RemoveConversationMembers(in *chat_rpc.RemoveConversationMembersReq) (*chat_rpc.RemoveConversationMembersRes, error) {
if in.ConversationId == "" {
return nil, errors.New("会话ID不能为空")
}
if len(in.UserIds) == 0 {
return nil, errors.New("用户列表不能为空")
}
// 检查会话是否存在
var conversation chat_models.ChatConversationMeta
if err := l.svcCtx.DB.Where("conversation_id = ?", in.ConversationId).First(&conversation).Error; err != nil {
l.Errorf("会话不存在: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("会话不存在")
}
// 开启事务
tx := l.svcCtx.DB.Begin()
if tx.Error != nil {
return nil, tx.Error
}
// 确保在函数返回时处理事务
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 删除用户的会话关系记录（软删除或标记为隐藏）
for _, userId := range in.UserIds {
if err := tx.Model(&chat_models.ChatUserConversation{}).
Where("conversation_id = ? AND user_id = ?", in.ConversationId, userId).
Update("is_hidden", true).Error; err != nil {
l.Errorf("移除用户会话关系失败: userId=%s, conversationId=%s, error=%v", userId, in.ConversationId, err)
tx.Rollback()
return nil, errors.New("移除用户会话关系失败")
}
}
// 提交事务
if err := tx.Commit().Error; err != nil {
return nil, err
}
l.Infof("成功移除会话成员: conversationId=%s, userIds=%v", in.ConversationId, in.UserIds)
return &chat_rpc.RemoveConversationMembersRes{
Success: true,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/addconversationmemberslogic.go | app/chat/chat_rpc/internal/logic/addconversationmemberslogic.go | package logic
import (
"context"
"errors"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type AddConversationMembersLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewAddConversationMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddConversationMembersLogic {
return &AddConversationMembersLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *AddConversationMembersLogic) AddConversationMembers(in *chat_rpc.AddConversationMembersReq) (*chat_rpc.AddConversationMembersRes, error) {
if in.ConversationId == "" {
return nil, errors.New("会话ID不能为空")
}
if len(in.UserIds) == 0 {
return nil, errors.New("用户列表不能为空")
}
// 检查会话是否存在
var conversation chat_models.ChatConversationMeta
if err := l.svcCtx.DB.Where("conversation_id = ?", in.ConversationId).First(&conversation).Error; err != nil {
l.Errorf("会话不存在: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("会话不存在")
}
// 开启事务
tx := l.svcCtx.DB.Begin()
if tx.Error != nil {
return nil, tx.Error
}
// 确保在函数返回时处理事务
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 为新成员创建用户会话关系记录
for _, userId := range in.UserIds {
// 检查是否已存在
var existing chat_models.ChatUserConversation
err := tx.Where("conversation_id = ? AND user_id = ?", in.ConversationId, userId).First(&existing).Error
if err == nil {
// 已存在，跳过
continue
}
// 创建新的用户会话关系
userConversation := chat_models.ChatUserConversation{
UserID: userId,
ConversationID: in.ConversationId,
IsPinned: false,
IsMuted: false,
UserReadSeq: conversation.MaxSeq, // 新成员的已读序列号设为当前最大序列号
Version: 1,
}
if err := tx.Create(&userConversation).Error; err != nil {
l.Errorf("创建用户会话关系失败: userId=%s, conversationId=%s, error=%v", userId, in.ConversationId, err)
tx.Rollback()
return nil, errors.New("创建用户会话关系失败")
}
}
// 提交事务
if err := tx.Commit().Error; err != nil {
return nil, err
}
l.Infof("成功添加会话成员: conversationId=%s, userIds=%v", in.ConversationId, in.UserIds)
return &chat_rpc.AddConversationMembersRes{
Success: true,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/batchupdateconversationlogic.go | app/chat/chat_rpc/internal/logic/batchupdateconversationlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type BatchUpdateConversationLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewBatchUpdateConversationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchUpdateConversationLogic {
return &BatchUpdateConversationLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *BatchUpdateConversationLogic) BatchUpdateConversation(in *chat_rpc.BatchUpdateConversationReq) (*chat_rpc.BatchUpdateConversationRes, error) {
// 开启事务
tx := l.svcCtx.DB.Begin()
if tx.Error != nil {
return nil, tx.Error
}
// 确保在函数返回时处理事务
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 批量更新或创建会话记录
for _, userID := range in.UserIds {
var userConvo chat_models.ChatUserConversation
err := tx.Where("conversation_id = ? AND user_id = ?", in.ConversationId, userID).First(&userConvo).Error
if err != nil {
// 如果记录不存在，创建新记录
if err := tx.Create(&chat_models.ChatUserConversation{
UserID: userID,
ConversationID: in.ConversationId,
IsHidden: false,
IsPinned: false,
IsMuted: false,
UserReadSeq: 0,
Version: 1, // 初始版本
}).Error; err != nil {
tx.Rollback()
return nil, err
}
} else {
// 如果记录存在，不需要更新LastMessage（已在ChatConversationMeta中）
// 这里只确保会话没有被隐藏
if err := tx.Model(&userConvo).Update("is_hidden", false).Error; err != nil {
tx.Rollback()
return nil, err
}
}
}
// 提交事务
if err := tx.Commit().Error; err != nil {
return nil, err
}
return &chat_rpc.BatchUpdateConversationRes{
Success: true,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/initializeconversationlogic.go | app/chat/chat_rpc/internal/logic/initializeconversationlogic.go | package logic
import (
"context"
"errors"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type InitializeConversationLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewInitializeConversationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *InitializeConversationLogic {
return &InitializeConversationLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *InitializeConversationLogic) InitializeConversation(in *chat_rpc.InitializeConversationReq) (*chat_rpc.InitializeConversationRes, error) {
// 参数验证
if in.ConversationId == "" {
return nil, errors.New("会话ID不能为空")
}
if len(in.UserIds) == 0 {
return nil, errors.New("用户列表不能为空")
}
if in.Type < 1 || in.Type > 4 {
return nil, errors.New("无效的会话类型")
}
// 检查会话是否已存在
var existingConversation chat_models.ChatConversationMeta
err := l.svcCtx.DB.Where("conversation_id = ?", in.ConversationId).First(&existingConversation).Error
if err == nil {
// 会话已存在，直接返回
l.Logger.Infof("会话已存在: conversationId=%s", in.ConversationId)
return &chat_rpc.InitializeConversationRes{
ConversationId: in.ConversationId,
}, nil
}
// 创建会话元数据
conversationMeta := chat_models.ChatConversationMeta{
ConversationID: in.ConversationId,
Type: int(in.Type), // 转换类型
MaxSeq: 0, // 初始消息序列号
Version: 1, // 初始版本
}
// 注意：GORM会自动处理时间字段，无需手动赋值
if err := l.svcCtx.DB.Create(&conversationMeta).Error; err != nil {
l.Logger.Errorf("创建会话元数据失败: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("创建会话元数据失败")
}
// 为所有参与用户创建用户会话关系记录
for _, userId := range in.UserIds {
userConversation := chat_models.ChatUserConversation{
UserID: userId,
ConversationID: in.ConversationId,
IsPinned: false,
IsMuted: false,
UserReadSeq: 0,
Version: 1,
}
// 注意：GORM会自动处理时间字段，无需手动赋值
if err := l.svcCtx.DB.Create(&userConversation).Error; err != nil {
l.Logger.Errorf("创建用户会话关系失败: userId=%s, conversationId=%s, error=%v", userId, in.ConversationId, err)
return nil, errors.New("创建用户会话关系失败")
}
}
l.Logger.Infof("初始化会话成功: conversationId=%s, type=%d, users=%v", in.ConversationId, in.Type, in.UserIds)
return &chat_rpc.InitializeConversationRes{
ConversationId: in.ConversationId,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/getuserconversationsettingslistbyidslogic.go | app/chat/chat_rpc/internal/logic/getuserconversationsettingslistbyidslogic.go | package logic
import (
"context"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserConversationSettingsListByIdsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserConversationSettingsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserConversationSettingsListByIdsLogic {
return &GetUserConversationSettingsListByIdsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetUserConversationSettingsListByIdsLogic) GetUserConversationSettingsListByIds(in *chat_rpc.GetUserConversationSettingsListByIdsReq) (*chat_rpc.GetUserConversationSettingsListByIdsRes, error) {
// 查询用户对指定会话的设置信息
var userConversations []chat_models.ChatUserConversation
err := l.svcCtx.DB.Where("user_id = ? AND conversation_id IN (?)", in.UserId, in.ConversationIds).Find(&userConversations).Error
if err != nil {
l.Errorf("查询用户会话设置失败: %v", err)
return nil, err
}
var userConversationSettings []*chat_rpc.UserConversationSettingListById
for _, uc := range userConversations {
userConversationSettings = append(userConversationSettings, &chat_rpc.UserConversationSettingListById{
ConversationId: uc.ConversationID,
Version: uc.Version,
})
}
return &chat_rpc.GetUserConversationSettingsListByIdsRes{
UserConversationSettings: userConversationSettings,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/updateconversationlogic.go | app/chat/chat_rpc/internal/logic/updateconversationlogic.go | package logic
import (
"context"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type UpdateConversationLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewUpdateConversationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateConversationLogic {
return &UpdateConversationLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *UpdateConversationLogic) UpdateConversation(in *chat_rpc.UpdateConversationReq) (*chat_rpc.UpdateConversationRes, error) {
var userConvo chat_models.ChatUserConversation
err := l.svcCtx.DB.Where("conversation_id = ? AND user_id = ?", in.ConversationId, in.UserId).First(&userConvo).Error
if err != nil {
// 如果记录不存在，创建新记录
if err := l.svcCtx.DB.Create(&chat_models.ChatUserConversation{
UserID: in.UserId,
ConversationID: in.ConversationId,
IsPinned: in.IsPinned,
IsHidden: in.IsDeleted, // 兼容旧的IsDeleted参数
IsMuted: false,
UserReadSeq: 0,
Version: 1, // 初始版本
}).Error; err != nil {
return nil, err
}
} else {
// 如果记录存在，更新记录
updates := map[string]interface{}{
"is_hidden": in.IsDeleted, // 兼容旧的IsDeleted参数
}
// LastMessage 不再存储在用户会话表中，已移至ChatConversationMeta表
if in.IsPinned != userConvo.IsPinned {
updates["is_pinned"] = in.IsPinned
}
if err := l.svcCtx.DB.Model(&userConvo).Updates(updates).Error; err != nil {
return nil, err
}
}
return &chat_rpc.UpdateConversationRes{
Success: true,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/getuserconversationversionslogic.go | app/chat/chat_rpc/internal/logic/getuserconversationversionslogic.go | package logic
import (
"context"
"time"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserConversationVersionsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserConversationVersionsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserConversationVersionsLogic {
return &GetUserConversationVersionsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetUserConversationVersionsLogic) GetUserConversationVersions(in *chat_rpc.GetUserConversationVersionsReq) (*chat_rpc.GetUserConversationVersionsRes, error) {
// 查询用户的所有会话设置
var userConversations []chat_models.ChatUserConversation
query := l.svcCtx.DB.Where("user_id = ?", in.UserId)
// 如果提供了since参数，只返回更新时间大于since的记录
if in.Since > 0 {
sinceTime := time.UnixMilli(in.Since)
query = query.Where("updated_at > ?", sinceTime)
}
err := query.Find(&userConversations).Error
if err != nil {
l.Errorf("查询用户会话设置失败: %v", err)
return nil, err
}
// 转换为响应格式
var userConversationVersions []*chat_rpc.UserConversationVersion
for _, userConv := range userConversations {
userConversationVersions = append(userConversationVersions, &chat_rpc.UserConversationVersion{
ConversationId: userConv.ConversationID,
Version: userConv.Version,
})
}
return &chat_rpc.GetUserConversationVersionsRes{
UserConversationVersions: userConversationVersions,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/getconversationslistbyidslogic.go | app/chat/chat_rpc/internal/logic/getconversationslistbyidslogic.go | package logic
import (
"context"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetConversationsListByIdsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetConversationsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetConversationsListByIdsLogic {
return &GetConversationsListByIdsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetConversationsListByIdsLogic) GetConversationsListByIds(in *chat_rpc.GetConversationsListByIdsReq) (*chat_rpc.GetConversationsListByIdsRes, error) {
// 构建查询条件
query := l.svcCtx.DB.Where("conversation_id IN (?)", in.ConversationIds)
// 如果提供了since参数，只返回版本有变更的记录
if in.Since > 0 {
query = query.Where("version >= ?", in.Since)
}
// 查询指定会话的完整信息
var conversations []chat_models.ChatConversationMeta
err := query.Find(&conversations).Error
if err != nil {
l.Errorf("查询会话信息失败: %v", err)
return nil, err
}
var conversationList []*chat_rpc.ConversationListById
for _, conv := range conversations {
conversationList = append(conversationList, &chat_rpc.ConversationListById{
ConversationId: conv.ConversationID,
Type: int32(conv.Type),
Seq: conv.MaxSeq,
Version: conv.Version,
})
}
return &chat_rpc.GetConversationsListByIdsRes{
Conversations: conversationList,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/dissolveconversationlogic.go | app/chat/chat_rpc/internal/logic/dissolveconversationlogic.go | package logic
import (
"context"
"errors"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type DissolveConversationLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewDissolveConversationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DissolveConversationLogic {
return &DissolveConversationLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *DissolveConversationLogic) DissolveConversation(in *chat_rpc.DissolveConversationReq) (*chat_rpc.DissolveConversationRes, error) {
if in.ConversationId == "" {
return nil, errors.New("会话ID不能为空")
}
// 检查会话是否存在
var conversation chat_models.ChatConversationMeta
if err := l.svcCtx.DB.Where("conversation_id = ?", in.ConversationId).First(&conversation).Error; err != nil {
l.Errorf("会话不存在: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("会话不存在")
}
// 开启事务
tx := l.svcCtx.DB.Begin()
if tx.Error != nil {
return nil, tx.Error
}
// 确保在函数返回时处理事务
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 1. 删除会话元数据
if err := tx.Where("conversation_id = ?", in.ConversationId).Delete(&chat_models.ChatConversationMeta{}).Error; err != nil {
l.Errorf("删除会话元数据失败: conversationId=%s, error=%v", in.ConversationId, err)
tx.Rollback()
return nil, errors.New("删除会话元数据失败")
}
// 2. 删除所有用户的会话关系记录
if err := tx.Where("conversation_id = ?", in.ConversationId).Delete(&chat_models.ChatUserConversation{}).Error; err != nil {
l.Errorf("删除用户会话关系失败: conversationId=%s, error=%v", in.ConversationId, err)
tx.Rollback()
return nil, errors.New("删除用户会话关系失败")
}
// 注意：消息记录通常保留作为历史记录，不在解散时删除
// 如果需要删除消息，可以添加相应的逻辑
// 提交事务
if err := tx.Commit().Error; err != nil {
return nil, err
}
l.Infof("成功解散会话: conversationId=%s", in.ConversationId)
return &chat_rpc.DissolveConversationRes{
Success: true,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/getuserconversationslogic.go | app/chat/chat_rpc/internal/logic/getuserconversationslogic.go | package logic
import (
"context"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserConversationsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserConversationsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserConversationsLogic {
return &GetUserConversationsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetUserConversationsLogic) GetUserConversations(in *chat_rpc.GetUserConversationsReq) (*chat_rpc.GetUserConversationsRes, error) {
var userConversations []chat_models.ChatUserConversation
err := l.svcCtx.DB.Where("user_id = ?", in.UserId).Find(&userConversations).Error
if err != nil {
l.Errorf("查询用户会话失败: %v", err)
return nil, err
}
var conversations []*chat_rpc.ConversationItem
for _, uc := range userConversations {
// 查询会话类型
var conversation chat_models.ChatConversationMeta
err := l.svcCtx.DB.Where("conversation_id = ?", uc.ConversationID).First(&conversation).Error
if err != nil {
l.Errorf("查询会话信息失败: %v", err)
continue
}
conversations = append(conversations, &chat_rpc.ConversationItem{
ConversationId: uc.ConversationID,
Type: int32(conversation.Type),
})
}
return &chat_rpc.GetUserConversationsRes{
Conversations: conversations,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/sendmsglogic.go | app/chat/chat_rpc/internal/logic/sendmsglogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
chat_models "beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/chat/chat_utils"
"beaver/app/friend/friend_models"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/common/ajax"
"beaver/common/models/ctype"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"beaver/utils/conversation"
"github.com/zeromicro/go-zero/core/logx"
)
type SendMsgLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSendMsgLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SendMsgLogic {
return &SendMsgLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *SendMsgLogic) SendMsg(in *chat_rpc.SendMsgReq) (*chat_rpc.SendMsgRes, error) {
conversationType, userIds := conversation.ParseConversationWithType(in.ConversationId)
if conversationType == 1 {
// 私聊需要验证好友关系
if !strings.Contains(in.ConversationId, in.UserId) {
logx.Errorf("用户id不匹配，用户id：%s，会话id：%s", in.UserId, in.ConversationId)
return nil, errors.New("异常操作")
}
if len(userIds) != 2 {
logx.Errorf("私聊会话ID解析失败，期望2个用户ID，实际: %v", userIds)
return nil, errors.New("无效的私聊会话ID")
}
var friend friend_models.FriendModel
if !friend.IsFriend(l.svcCtx.DB, userIds[0], userIds[1]) {
logx.Errorf("不是好友关系，用户IDs: %v", userIds)
return nil, errors.New("不是好友关系")
}
}
msgType := ctype.MsgType(in.Msg.Type)
var msg ctype.Msg
switch msgType {
case ctype.TextMsgType:
msg = ctype.Msg{
Type: ctype.TextMsgType,
TextMsg: &ctype.TextMsg{
Content: in.Msg.TextMsg.Content,
},
}
case ctype.ImageMsgType:
imageMsg := &ctype.ImageMsg{
FileKey: in.Msg.ImageMsg.FileKey,
}
// 设置可选字段（proto 字段名是小写开头，但 Go 生成的是大写开头）
// 注意：需要重新生成 proto 后，字段名会是 Width, Height, Size
if in.Msg.ImageMsg.Width > 0 {
imageMsg.Width = int(in.Msg.ImageMsg.Width)
}
if in.Msg.ImageMsg.Height > 0 {
imageMsg.Height = int(in.Msg.ImageMsg.Height)
}
if in.Msg.ImageMsg.Size > 0 {
imageMsg.Size = in.Msg.ImageMsg.Size
}
msg = ctype.Msg{
Type: ctype.ImageMsgType,
ImageMsg: imageMsg,
}
case ctype.VideoMsgType:
videoMsg := &ctype.VideoMsg{
FileKey: in.Msg.VideoMsg.FileKey,
}
// 设置可选字段
if in.Msg.VideoMsg.Width > 0 {
videoMsg.Width = int(in.Msg.VideoMsg.Width)
}
if in.Msg.VideoMsg.Height > 0 {
videoMsg.Height = int(in.Msg.VideoMsg.Height)
}
if in.Msg.VideoMsg.Duration > 0 {
videoMsg.Duration = int(in.Msg.VideoMsg.Duration)
}
if in.Msg.VideoMsg.ThumbnailKey != "" {
videoMsg.ThumbnailKey = in.Msg.VideoMsg.ThumbnailKey
}
if in.Msg.VideoMsg.Size > 0 {
videoMsg.Size = in.Msg.VideoMsg.Size
}
msg = ctype.Msg{
Type: ctype.VideoMsgType,
VideoMsg: videoMsg,
}
case ctype.FileMsgType:
fileMsg := &ctype.FileMsg{
FileKey: in.Msg.FileMsg.FileKey,
}
// 设置可选字段
if in.Msg.FileMsg.FileName != "" {
fileMsg.FileName = in.Msg.FileMsg.FileName
}
if in.Msg.FileMsg.Size > 0 {
fileMsg.Size = in.Msg.FileMsg.Size
}
if in.Msg.FileMsg.MimeType != "" {
fileMsg.MimeType = in.Msg.FileMsg.MimeType
}
msg = ctype.Msg{
Type: ctype.FileMsgType,
FileMsg: fileMsg,
}
case ctype.VoiceMsgType:
voiceMsg := &ctype.VoiceMsg{
FileKey: in.Msg.VoiceMsg.FileKey,
}
// 设置可选字段
if in.Msg.VoiceMsg.Duration > 0 {
voiceMsg.Duration = int(in.Msg.VoiceMsg.Duration)
}
if in.Msg.VoiceMsg.Size > 0 {
voiceMsg.Size = in.Msg.VoiceMsg.Size
}
msg = ctype.Msg{
Type: ctype.VoiceMsgType,
VoiceMsg: voiceMsg,
}
case ctype.EmojiMsgType:
msg = ctype.Msg{
Type: ctype.EmojiMsgType,
EmojiMsg: &ctype.EmojiMsg{
FileKey: in.Msg.EmojiMsg.FileKey,
EmojiID: in.Msg.EmojiMsg.EmojiId,
PackageID: in.Msg.EmojiMsg.PackageId,
Width: in.Msg.EmojiMsg.Width,
Height: in.Msg.EmojiMsg.Height,
},
}
case ctype.NotificationMsgType:
notificationMsg := &ctype.NotificationMsg{
Type: int(in.Msg.NotificationMsg.Type),
Actors: in.Msg.NotificationMsg.Actors,
}
msg = ctype.Msg{
Type: ctype.NotificationMsgType,
NotificationMsg: notificationMsg,
}
case ctype.AudioFileMsgType:
audioFileMsg := &ctype.AudioFileMsg{
FileKey: in.Msg.AudioFileMsg.FileKey,
}
// 设置可选字段
if in.Msg.AudioFileMsg.FileName != "" {
audioFileMsg.FileName = in.Msg.AudioFileMsg.FileName
}
if in.Msg.AudioFileMsg.Duration > 0 {
audioFileMsg.Duration = int(in.Msg.AudioFileMsg.Duration)
}
if in.Msg.AudioFileMsg.Size > 0 {
audioFileMsg.Size = in.Msg.AudioFileMsg.Size
}
msg = ctype.Msg{
Type: ctype.AudioFileMsgType,
AudioFileMsg: audioFileMsg,
}
default:
return nil, fmt.Errorf("未识别到该类型: %d", msgType)
}
// 获取下一个消息序列号（消息表内部序列号）
var maxSeq int64
err := l.svcCtx.DB.Model(&chat_models.ChatMessage{}).
Where("conversation_id = ?", in.ConversationId).
Select("COALESCE(MAX(seq), 0)").
Scan(&maxSeq).Error
if err != nil {
l.Logger.Errorf("获取消息序列号失败: conversationId=%s, error=%v", in.ConversationId, err)
return nil, err
}
nextSeq := maxSeq + 1
chatModel := chat_models.ChatMessage{
SendUserID: &in.UserId,
MessageID: in.MessageId,
ConversationID: in.ConversationId,
ConversationType: conversationType,
Seq: nextSeq, // 设置正确的序列号
MsgType: msgType,
Msg: &msg,
}
// 1. 创建消息记录并设置预览
chatModel.MsgPreview = chatModel.MsgPreviewMethod()
err = l.svcCtx.DB.Create(&chatModel).Error
if err != nil {
l.Logger.Errorf("创建消息记录失败: conversationId=%s, userId=%s, error=%v", in.ConversationId, in.UserId, err)
return nil, err
}
// 1.1 构建 Messages 表更新数据
messagesUpdate := map[string]interface{}{
"table": "messages",
"conversationId": in.ConversationId,
"data": []map[string]interface{}{
{
"seq": chatModel.Seq,
},
},
}
// 2. 更新会话级别的信息
conversationVersion, err := chat_utils.CreateOrUpdateConversation(l.svcCtx.DB, l.svcCtx.VersionGen, in.ConversationId, conversationType, chatModel.Seq, chatModel.MsgPreview)
if err != nil {
l.Logger.Errorf("更新会话信息失败: conversationId=%s, error=%v", in.ConversationId, err)
return nil, err
}
// 2.1 构建 Conversations 表更新数据
conversationsUpdate := map[string]interface{}{
"table": "conversations",
"conversationId": in.ConversationId,
"data": []map[string]interface{}{
{
"version": int32(conversationVersion),
},
},
}
// 3. 批量更新该会话所有用户的会话关系（包括发送者：恢复隐藏状态，更新版本号，更新已读序列号）
allUserConversationUpdates, err := chat_utils.UpdateAllUserConversationsInChat(l.svcCtx.DB, l.svcCtx.VersionGen, in.ConversationId, in.UserId, chatModel.Seq)
if err != nil {
l.Logger.Errorf("批量更新用户会话关系失败: conversationId=%s, error=%v", in.ConversationId, err)
// 不影响消息发送成功，只记录错误
allUserConversationUpdates = []chat_utils.UserConversationUpdate{}
}
// 转换消息格式
convertedMsg, err := l.convertCtypeMsgToGrpcMsg(msg)
if err != nil {
l.Logger.Errorf("转换消息格式失败: %v", err)
return nil, err
}
// 获取发送者信息
sender, err := l.getSenderInfo(chatModel)
if err != nil {
l.Logger.Errorf("获取发送者信息失败: %v", err)
return nil, err
}
// 5. 异步推送消息更新给会话成员（按表分组，一次推送包含所有相关更新）
go func() {
l.notifyMessageUpdateGrouped(in.ConversationId, in.UserId, conversationType, messagesUpdate, conversationsUpdate, allUserConversationUpdates)
}()
return &chat_rpc.SendMsgRes{
Id: uint32(chatModel.Id),
MessageId: chatModel.MessageID,
ConversationId: chatModel.ConversationID,
Msg: convertedMsg,
MsgPreview: chatModel.MsgPreview,
Sender: sender,
CreatedAt: chatModel.CreatedAt.String(),
Status: 1,
ConversationType: uint32(chatModel.ConversationType),
Seq: chatModel.Seq,
}, nil
}
// notifyMessageUpdateGrouped 按会话分组推送消息更新（给该会话的所有用户推送）
func (l *SendMsgLogic) notifyMessageUpdateGrouped(conversationId, senderId string, conversationType int, messagesUpdate, conversationsUpdate map[string]interface{}, allUserConversationUpdates []chat_utils.UserConversationUpdate) {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("推送消息更新时发生panic: %v", r)
}
}()
// 获取该会话的所有用户ID（包括发送者，给所有人推送）
var recipientIds []string
for _, update := range allUserConversationUpdates {
if update.ConversationID == conversationId {
recipientIds = append(recipientIds, update.UserID)
}
}
// 构建按表分组的更新数据结构
tableUpdates := []map[string]interface{}{
messagesUpdate, // 已经构建好的 Messages 更新
conversationsUpdate, // 已经构建好的 Conversations 更新
}
// 3. User_conversations 表更新（直接循环 allUserConversationUpdates）
for _, update := range allUserConversationUpdates {
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations",
"userId": update.UserID,
"conversationId": update.ConversationID,
"data": []map[string]interface{}{
{
"version": int32(update.Version),
},
},
}
tableUpdates = append(tableUpdates, userConversationsUpdate)
}
// 为每个接收者推送批量更新
messageType := wsTypeConst.ChatConversationMessageReceive
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println("推送消息更新给会话成员: ", recipientIds)
for _, recipientId := range recipientIds {
// 一次性推送所有表的更新信息
ajax.SendMessageToWs(l.svcCtx.Config.Etcd.Hosts[0], wsCommandConst.CHAT_MESSAGE, messageType, senderId, recipientId, map[string]interface{}{
"tableUpdates": tableUpdates, // 按表分组的更新数组
}, conversationId)
l.Logger.Infof("分组推送消息相关更新: recipient=%s, conversation=%s, tableUpdateCount=%d",
recipientId, conversationId, len(tableUpdates))
}
}
// getSenderInfo 获取发送者信息
func (l *SendMsgLogic) getSenderInfo(chatModel chat_models.ChatMessage) (*chat_rpc.Sender, error) {
sendUserID := ""
if chatModel.SendUserID != nil {
sendUserID = *chatModel.SendUserID
}
if sendUserID == "" {
// 通知消息：SendUserID为空
return &chat_rpc.Sender{
UserId: "",
NickName: "通知消息",
Avatar: "",
}, nil
}
// 调用UserRpc获取用户信息
userInfoResp, err := l.svcCtx.UserRpc.UserInfo(l.ctx, &user_rpc.UserInfoReq{
UserID: sendUserID,
})
if err != nil {
l.Logger.Errorf("获取用户信息失败: userId=%s, error=%v", sendUserID, err)
// 返回默认发送者信息，不影响消息发送
return &chat_rpc.Sender{
UserId: sendUserID,
NickName: "未知用户",
Avatar: "",
}, nil
}
// 使用结构化用户信息
userInfo := userInfoResp.UserInfo
return &chat_rpc.Sender{
UserId: sendUserID,
NickName: userInfo.NickName,
Avatar: userInfo.Avatar,
}, nil
}
func (l *SendMsgLogic) convertCtypeMsgToGrpcMsg(msg ctype.Msg) (*chat_rpc.Msg, error) {
// 将 ctype.Msg 转换为 JSON
jsonData, err := json.Marshal(msg)
if err != nil {
return nil, err
}
// 将 JSON 解析为 chat_rpc.Msg
var convertedMsg chat_rpc.Msg
err = json.Unmarshal(jsonData, &convertedMsg)
if err != nil {
return nil, err
}
return &convertedMsg, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_rpc/internal/logic/sendnotificationmessagelogic.go | app/chat/chat_rpc/internal/logic/sendnotificationmessagelogic.go | package logic
import (
"context"
"errors"
"fmt"
"beaver/app/chat/chat_models"
"beaver/app/chat/chat_rpc/internal/svc"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/chat/chat_utils"
"beaver/common/ajax"
"beaver/common/models/ctype"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/google/uuid"
"github.com/zeromicro/go-zero/core/logx"
)
type SendNotificationMessageLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewSendNotificationMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SendNotificationMessageLogic {
return &SendNotificationMessageLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *SendNotificationMessageLogic) SendNotificationMessage(in *chat_rpc.SendNotificationMessageReq) (*chat_rpc.SendNotificationMessageRes, error) {
// 参数验证
if in.ConversationId == "" {
return nil, errors.New("会话ID不能为空")
}
if in.Content == "" {
return nil, errors.New("消息内容不能为空")
}
// 构建通知消息的结构化数据
actors := []string{}
if in.RelatedUserId != "" {
actors = append(actors, in.RelatedUserId)
}
// 检查会话是否存在
var conversation chat_models.ChatConversationMeta
err := l.svcCtx.DB.Where("conversation_id = ?", in.ConversationId).First(&conversation).Error
if err != nil {
l.Logger.Errorf("会话不存在: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("会话不存在")
}
// 生成消息ID
messageId := uuid.New().String()
// 获取下一个序列号
var maxSeq int64
err = l.svcCtx.DB.Model(&chat_models.ChatMessage{}).
Where("conversation_id = ?", in.ConversationId).
Select("COALESCE(MAX(seq), 0)").
Scan(&maxSeq).Error
if err != nil {
l.Logger.Errorf("获取序列号失败: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("获取序列号失败")
}
nextSeq := maxSeq + 1
// 为通知消息创建Msg结构（使用NotificationMsg类型）
notificationMsg := &ctype.Msg{
Type: ctype.NotificationMsgType, // 使用通知消息类型
NotificationMsg: &ctype.NotificationMsg{
Type: int(in.MessageType), // 通知类型
Actors: actors, // 相关用户ID列表
},
}
notificationMessage := chat_models.ChatMessage{
MessageID: messageId,
ConversationID: in.ConversationId,
ConversationType: conversation.Type,
Seq: nextSeq,
SendUserID: nil, // 通知消息SendUserID为null
MsgType: 7, // 通知消息类型
MsgPreview: in.Content,
Msg: notificationMsg, // 通知消息的结构化内容
}
if err := l.svcCtx.DB.Create(¬ificationMessage).Error; err != nil {
l.Logger.Errorf("创建通知消息失败: conversationId=%s, error=%v", in.ConversationId, err)
return nil, errors.New("创建通知消息失败")
}
// 更新会话级别的信息，获取会话版本号
conversationVersion, err := chat_utils.CreateOrUpdateConversation(l.svcCtx.DB, l.svcCtx.VersionGen, in.ConversationId, conversation.Type, nextSeq, in.Content)
if err != nil {
l.Logger.Errorf("更新会话信息失败: conversationId=%s, error=%v", in.ConversationId, err)
// 这里不返回错误，因为消息已经创建成功
conversationVersion = 0
}
// 构建会话更新数据
conversationsUpdate := map[string]interface{}{
"table": "conversations",
"conversationId": in.ConversationId,
"data": []map[string]interface{}{
{
"version": int32(conversationVersion),
},
},
}
// 批量更新该会话所有用户的会话关系（恢复隐藏状态，更新版本号）
// 如果指定了readUserIds，只更新这些用户的已读状态；否则所有用户都标记为已读
allUserConversationUpdates, err := chat_utils.UpdateUserConversationsReadSeq(l.svcCtx.DB, l.svcCtx.VersionGen, in.ConversationId, in.ReadUserIds, nextSeq)
if err != nil {
l.Logger.Errorf("批量更新用户会话关系失败: conversationId=%s, error=%v", in.ConversationId, err)
// 不影响消息发送成功，只记录错误
allUserConversationUpdates = []chat_utils.UserConversationUpdate{}
}
// 如果有发送者（RelatedUserId），则推送通知消息给所有相关用户
if in.RelatedUserId != "" {
// 构建 Messages 表更新数据
messagesUpdate := map[string]interface{}{
"table": "messages",
"conversationId": in.ConversationId,
"data": []map[string]interface{}{
{
"seq": nextSeq,
},
},
}
// 异步推送消息更新给会话成员
go func() {
l.notifyNotificationUpdateGrouped(in.ConversationId, conversation.Type, messagesUpdate, conversationsUpdate, allUserConversationUpdates)
}()
}
l.Logger.Infof("发送通知消息成功: conversationId=%s, messageId=%s, type=%d", in.ConversationId, messageId, in.MessageType)
return &chat_rpc.SendNotificationMessageRes{
MessageId: messageId,
}, nil
}
// notifyNotificationUpdateGrouped 按会话分组推送通知更新（给该会话的所有用户推送）
func (l *SendNotificationMessageLogic) notifyNotificationUpdateGrouped(conversationId string, conversationType int, messagesUpdate, conversationsUpdate map[string]interface{}, allUserConversationUpdates []chat_utils.UserConversationUpdate) {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("推送通知更新时发生panic: %v", r)
}
}()
// 获取该会话的所有用户ID
var recipientIds []string
for _, update := range allUserConversationUpdates {
if update.ConversationID == conversationId {
recipientIds = append(recipientIds, update.UserID)
}
}
// 构建按表分组的更新数据结构
tableUpdates := []map[string]interface{}{
messagesUpdate, // Messages 更新
conversationsUpdate, // Conversations 更新
}
// User_conversations 表更新
for _, update := range allUserConversationUpdates {
userConversationsUpdate := map[string]interface{}{
"table": "user_conversations",
"userId": update.UserID,
"conversationId": update.ConversationID,
"data": []map[string]interface{}{
{
"version": int32(update.Version),
},
},
}
tableUpdates = append(tableUpdates, userConversationsUpdate)
}
// 为每个接收者推送批量更新
messageType := wsTypeConst.ChatConversationMessageReceive
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println(("111111111111111111111"))
fmt.Println("推送通知更新给会话成员: ", recipientIds)
for _, recipientId := range recipientIds {
// 一次性推送所有表的更新信息
ajax.SendMessageToWs(l.svcCtx.Config.Etcd.Hosts[0], wsCommandConst.CHAT_MESSAGE, messageType, "", recipientId, map[string]interface{}{
"tableUpdates": tableUpdates, // 按表分组的更新数组
}, conversationId)
l.Logger.Infof("分组推送通知相关更新: recipient=%s, conversation=%s, tableUpdateCount=%d",
recipientId, conversationId, len(tableUpdates))
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/auth.go | app/auth/auth_api/auth.go | package main
import (
"flag"
"fmt"
"beaver/app/auth/auth_api/internal/config"
"beaver/app/auth/auth_api/internal/handler"
"beaver/app/auth/auth_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/auth.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
server.Use(middleware.UserAgentMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/svc/servicecontext.go | app/auth/auth_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/auth/auth_api/internal/config"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/app/user/user_rpc/user"
"beaver/common/zrpc_interceptor"
"beaver/core"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
Redis *redis.Client
UserRpc user_rpc.UserClient
DB *gorm.DB
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
return &ServiceContext{
DB: mysqlDb,
Redis: client,
Config: c,
UserRpc: user.NewUser(zrpc.MustNewClient(c.UserRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/types/types.go | app/auth/auth_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type AuthenticationReq struct {
Token string `header:"Token,optional"`
ValidPath string `header:"ValidPath,optional"`
}
type AuthenticationRes struct {
UserID string `json:"userId"`
}
type EmailLoginReq struct {
Email string `json:"email"`
Code string `json:"code"` // 验证码
DeviceID string `header:"deviceId"` // 客户端生成的设备唯一标识符
}
type EmailLoginRes struct {
Token string `json:"token"`
UserID string `json:"userId"`
}
type EmailPasswordLoginReq struct {
Email string `json:"email"`
Password string `json:"password"`
DeviceID string `header:"deviceId"` // 客户端生成的设备唯一标识符
}
type EmailPasswordLoginRes struct {
Token string `json:"token"`
UserID string `json:"userId"`
}
type EmailRegisterReq struct {
Email string `json:"email"`
Password string `json:"password"`
Code string `json:"code"` // 邮箱验证码
}
type EmailRegisterRes struct {
Message string `json:"message"`
}
type GetEmailCodeReq struct {
Email string `json:"email"`
Type string `json:"type"` // 验证码类型：register(注册)、reset_password(重置密码)、login(登录)
}
type GetEmailCodeRes struct {
Message string `json:"message"`
}
type GetPhoneCodeReq struct {
Phone string `json:"phone"`
Type string `json:"type"` // 验证码类型：register(注册)、reset_password(重置密码)、login(登录)
}
type GetPhoneCodeRes struct {
Message string `json:"message"`
}
type LogoutReq struct {
UserID string `header:"Beaver-User-Id"`
}
type LogoutRes struct {
}
type PhoneLoginReq struct {
Phone string `json:"phone"`
Password string `json:"password"`
DeviceID string `header:"deviceId"` // 客户端生成的设备唯一标识符
}
type PhoneLoginRes struct {
Token string `json:"token"`
UserID string `json:"userId"`
}
type PhoneRegisterReq struct {
Phone string `json:"phone"`
Password string `json:"password"`
Code string `json:"code"` // 手机验证码
}
type PhoneRegisterRes struct {
Message string `json:"message"`
}
type ResetPasswordReq struct {
Email string `json:"email"` // 用户邮箱地址
Code string `json:"code"` // 邮箱验证码
Password string `json:"password"` // 新密码
}
type ResetPasswordRes struct {
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/config/config.go | app/auth/auth_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
Etcd string
WhiteList []string //白名单
UserRpc zrpc.RpcClientConf
Auth struct {
AccessSecret string
AccessExpire int
}
Email struct {
QQ struct {
Host string
Port int
Username string
Password string
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/getphonecodehandler.go | app/auth/auth_api/internal/handler/getphonecodehandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/common/validator"
"beaver/utils/email"
"errors"
"fmt"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getPhoneCodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetPhoneCodeReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证手机号格式
if !validator.IsValidPhone(req.Phone) {
response.Response(r, w, nil, errors.New("手机号格式不正确"))
return
}
// 验证验证码类型
if !email.IsValidCodeType(req.Type) {
response.Response(r, w, nil, errors.New("验证码类型不正确"))
return
}
// 检查发送频率限制（60秒内只能发送一次）
rateLimitKey := fmt.Sprintf("phone_rate_limit_%s", req.Phone)
exists, err := svcCtx.Redis.Exists(rateLimitKey).Result()
if err != nil {
response.Response(r, w, nil, errors.New("服务内部异常"))
return
}
if exists == 1 {
response.Response(r, w, nil, errors.New("发送过于频繁，请60秒后再试"))
return
}
l := logic.NewGetPhoneCodeLogic(r.Context(), svcCtx)
resp, err := l.GetPhoneCode(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/logouthandler.go | app/auth/auth_api/internal/handler/logouthandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func logoutHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.LogoutReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewLogoutLogic(r.Context(), svcCtx)
resp, err := l.Logout(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/emailregisterhandler.go | app/auth/auth_api/internal/handler/emailregisterhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/common/validator"
"beaver/utils/email"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func emailRegisterHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.EmailRegisterReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证邮箱格式
if !email.IsValidEmail(req.Email) {
response.Response(r, w, nil, errors.New("邮箱格式不正确"))
return
}
// 验证验证码格式（6位纯数字）
if !email.IsValidVerificationCode(req.Code) {
response.Response(r, w, nil, errors.New("验证码格式不正确"))
return
}
// 验证密码强度
if !validator.IsValidPassword(req.Password) {
response.Response(r, w, nil, errors.New("密码必须包含数字和字母,且长度至少8位"))
return
}
l := logic.NewEmailRegisterLogic(r.Context(), svcCtx)
resp, err := l.EmailRegister(&req)
response.Response(r, w, resp, err, "注册成功")
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/resetpasswordhandler.go | app/auth/auth_api/internal/handler/resetpasswordhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func resetPasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ResetPasswordReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewResetPasswordLogic(r.Context(), svcCtx)
resp, err := l.ResetPassword(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/phoneloginhandler.go | app/auth/auth_api/internal/handler/phoneloginhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/common/validator"
"beaver/utils/device"
"errors"
"fmt"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
)
// 获取登录失败次数
func getLoginFailCount(svcCtx *svc.ServiceContext, phone string) (int, error) {
key := fmt.Sprintf("login_fail_%s", phone)
count, err := svcCtx.Redis.Get(key).Int()
if err != nil {
return 0, nil
}
return count, nil
}
// 增加登录失败次数
func incLoginFailCount(svcCtx *svc.ServiceContext, phone string) error {
key := fmt.Sprintf("login_fail_%s", phone)
return svcCtx.Redis.Incr(key).Err()
}
// 重置登录失败次数
func resetLoginFailCount(svcCtx *svc.ServiceContext, phone string) error {
key := fmt.Sprintf("login_fail_%s", phone)
return svcCtx.Redis.Del(key).Err()
}
func phoneLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.PhoneLoginReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证登录参数
if err := validator.ValidateLoginParams(req.Phone, req.Password); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证设备ID
if !device.IsValidDeviceID(req.DeviceID) {
response.Response(r, w, nil, errors.New("设备ID格式不正确"))
return
}
// 检查登录失败次数
failCount, err := getLoginFailCount(svcCtx, req.Phone)
if err != nil {
response.Response(r, w, nil, errors.New("服务内部异常"))
return
}
if failCount >= 10 {
response.Response(r, w, nil, errors.New("登录失败次数过多,请稍后再试"))
return
}
l := logic.NewPhoneLoginLogic(r.Context(), svcCtx)
resp, err := l.PhoneLogin(&req)
if err != nil {
// 增加登录失败次数
if err := incLoginFailCount(svcCtx, req.Phone); err != nil {
}
response.Response(r, w, nil, err)
return
}
// 登录成功，重置失败次数
if err := resetLoginFailCount(svcCtx, req.Phone); err != nil {
// 重置失败次数失败不影响登录成功
logx.Errorf("重置登录失败次数失败: %v", err)
}
response.Response(r, w, resp, nil)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/authenticationhandler.go | app/auth/auth_api/internal/handler/authenticationhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"fmt"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func authenticationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AuthenticationReq
if err := httpx.Parse(r, &req); err != nil {
fmt.Println("参数错误", r, err.Error())
response.Response(r, w, nil, err)
return
}
l := logic.NewAuthenticationLogic(r.Context(), svcCtx)
resp, err := l.Authentication(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/emailpasswordloginhandler.go | app/auth/auth_api/internal/handler/emailpasswordloginhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func emailPasswordLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.EmailPasswordLoginReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewEmailPasswordLoginLogic(r.Context(), svcCtx)
resp, err := l.EmailPasswordLogin(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/phoneregisterhandler.go | app/auth/auth_api/internal/handler/phoneregisterhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/common/validator"
"errors"
"net/http"
"regexp"
"github.com/zeromicro/go-zero/rest/httpx"
)
func phoneRegisterHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.PhoneRegisterReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证手机号格式
if !validator.IsValidPhone(req.Phone) {
response.Response(r, w, nil, errors.New("手机号格式不正确"))
return
}
// 验证验证码格式（6位纯数字）
if !isValidVerificationCode(req.Code) {
response.Response(r, w, nil, errors.New("验证码格式不正确"))
return
}
// 验证密码强度
if !validator.IsValidPassword(req.Password) {
response.Response(r, w, nil, errors.New("密码必须包含数字和字母,且长度至少8位"))
return
}
l := logic.NewPhoneRegisterLogic(r.Context(), svcCtx)
resp, err := l.PhoneRegister(&req)
response.Response(r, w, resp, err, "注册成功")
}
}
// 验证验证码格式（6位纯数字）
func isValidVerificationCode(code string) bool {
if len(code) != 6 {
return false
}
matched, _ := regexp.MatchString(`^\d{6}$`, code)
return matched
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/emailloginhandler.go | app/auth/auth_api/internal/handler/emailloginhandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/utils/device"
"beaver/utils/email"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func emailLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.EmailLoginReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证邮箱格式
if !email.IsValidEmail(req.Email) {
response.Response(r, w, nil, errors.New("邮箱格式不正确"))
return
}
// 验证验证码格式（6位纯数字）
if !email.IsValidVerificationCode(req.Code) {
response.Response(r, w, nil, errors.New("验证码格式不正确"))
return
}
// 验证设备ID
if !device.IsValidDeviceID(req.DeviceID) {
response.Response(r, w, nil, errors.New("设备ID格式不正确"))
return
}
l := logic.NewEmailLoginLogic(r.Context(), svcCtx)
resp, err := l.EmailLogin(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/getemailcodehandler.go | app/auth/auth_api/internal/handler/getemailcodehandler.go | package handler
import (
"beaver/app/auth/auth_api/internal/logic"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/common/response"
"beaver/utils/email"
"errors"
"fmt"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getEmailCodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEmailCodeReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证邮箱格式
if !email.IsValidEmail(req.Email) {
response.Response(r, w, nil, errors.New("邮箱格式不正确"))
return
}
// 验证验证码类型
if !email.IsValidCodeType(req.Type) {
response.Response(r, w, nil, errors.New("验证码类型不正确"))
return
}
// 检查发送频率限制（60秒内只能发送一次）
rateLimitKey := fmt.Sprintf("email_rate_limit_%s", req.Email)
exists, err := svcCtx.Redis.Exists(rateLimitKey).Result()
if err != nil {
response.Response(r, w, nil, errors.New("服务内部异常"))
return
}
if exists == 1 {
response.Response(r, w, nil, errors.New("发送过于频繁，请60秒后再试"))
return
}
l := logic.NewGetEmailCodeLogic(r.Context(), svcCtx)
resp, err := l.GetEmailCode(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/handler/routes.go | app/auth/auth_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/auth/auth_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 用户认证
Method: http.MethodGet,
Path: "/api/auth/authentication",
Handler: authenticationHandler(serverCtx),
},
{
// 邮箱登录
Method: http.MethodPost,
Path: "/api/auth/email_login",
Handler: emailLoginHandler(serverCtx),
},
{
// 邮箱密码登录
Method: http.MethodPost,
Path: "/api/auth/email_password_login",
Handler: emailPasswordLoginHandler(serverCtx),
},
{
// 邮箱注册
Method: http.MethodPost,
Path: "/api/auth/email_register",
Handler: emailRegisterHandler(serverCtx),
},
{
// 获取邮箱验证码
Method: http.MethodPost,
Path: "/api/auth/emailcode",
Handler: getEmailCodeHandler(serverCtx),
},
{
// 用户登出
Method: http.MethodPost,
Path: "/api/auth/logout",
Handler: logoutHandler(serverCtx),
},
{
// 手机号登录
Method: http.MethodPost,
Path: "/api/auth/phone_login",
Handler: phoneLoginHandler(serverCtx),
},
{
// 手机号注册
Method: http.MethodPost,
Path: "/api/auth/phone_register",
Handler: phoneRegisterHandler(serverCtx),
},
{
// 获取手机验证码
Method: http.MethodPost,
Path: "/api/auth/phonecode",
Handler: getPhoneCodeHandler(serverCtx),
},
{
// 找回密码（通过邮箱验证码重置密码）
Method: http.MethodPost,
Path: "/api/auth/reset_password",
Handler: resetPasswordHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/getemailcodelogic.go | app/auth/auth_api/internal/logic/getemailcodelogic.go | package logic
import (
"context"
"crypto/tls"
"errors"
"fmt"
"net/smtp"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/utils/email"
"github.com/zeromicro/go-zero/core/logx"
)
type GetEmailCodeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetEmailCodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetEmailCodeLogic {
return &GetEmailCodeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetEmailCodeLogic) GetEmailCode(req *types.GetEmailCodeReq) (resp *types.GetEmailCodeRes, err error) {
// 生成6位数字验证码
code := email.GenerateCode()
// 发送验证码邮件
err = l.sendEmail(req.Email, code, req.Type)
if err != nil {
logx.Errorf("发送邮件失败: %v", err)
return nil, errors.New("发送验证码失败，请稍后重试")
}
// 存储验证码到Redis（5分钟有效期）
codeKey := fmt.Sprintf("email_code_%s_%s", req.Email, req.Type)
err = l.svcCtx.Redis.Set(codeKey, code, 5*time.Minute).Err()
if err != nil {
logx.Errorf("存储验证码失败: %v", err)
return nil, errors.New("服务内部异常")
}
// 设置发送频率限制（60秒）
rateLimitKey := fmt.Sprintf("email_rate_limit_%s", req.Email)
err = l.svcCtx.Redis.Set(rateLimitKey, "1", 60*time.Second).Err()
if err != nil {
logx.Errorf("设置发送频率限制失败: %v", err)
}
return &types.GetEmailCodeRes{
Message: "验证码发送成功",
}, nil
}
// 发送邮件
func (l *GetEmailCodeLogic) sendEmail(to, code, codeType string) error {
var host, username, password string
var port int
// 直接使用系统配置的邮箱服务商
host = l.svcCtx.Config.Email.QQ.Host
port = l.svcCtx.Config.Email.QQ.Port
username = l.svcCtx.Config.Email.QQ.Username
password = l.svcCtx.Config.Email.QQ.Password
logx.Infof("QQ邮箱配置: Host=%s, Port=%d, Username=%s", host, port, username)
// 构建邮件内容
subject := email.GetEmailSubject(codeType)
body := email.GetEmailBody(code, codeType)
// 构建邮件头
headers := make(map[string]string)
headers["From"] = username // 发送方邮箱
headers["To"] = to // 接收方邮箱（用户传入的）
headers["Subject"] = subject
headers["MIME-Version"] = "1.0"
headers["Content-Type"] = "text/html; charset=UTF-8"
// 构建邮件内容
message := ""
for k, v := range headers {
message += fmt.Sprintf("%s: %s\r\n", k, v)
}
message += "\r\n" + body
logx.Infof("准备发送邮件: From=%s, To=%s, Subject=%s", username, to, subject)
// 根据端口选择发送方式
var err error
if port == 465 {
// SSL连接
err = l.sendEmailSSL(host, port, username, password, to, message)
} else {
// 普通SMTP连接
auth := smtp.PlainAuth("", username, password, host)
addr := fmt.Sprintf("%s:%d", host, port)
err = smtp.SendMail(addr, auth, username, []string{to}, []byte(message))
}
if err != nil {
logx.Errorf("SMTP发送失败: %v, host=%s, port=%d, username=%s, to=%s", err, host, port, username, to)
return fmt.Errorf("发送邮件失败: %v", err)
}
logx.Infof("邮件发送成功: To=%s", to)
return nil
}
// SSL方式发送邮件
func (l *GetEmailCodeLogic) sendEmailSSL(host string, port int, username, password, to, message string) error {
// 连接到SMTP服务器
addr := fmt.Sprintf("%s:%d", host, port)
conn, err := tls.Dial("tcp", addr, &tls.Config{
ServerName: host,
})
if err != nil {
return fmt.Errorf("连接SMTP服务器失败: %v", err)
}
defer conn.Close()
// 创建SMTP客户端
client, err := smtp.NewClient(conn, host)
if err != nil {
return fmt.Errorf("创建SMTP客户端失败: %v", err)
}
defer client.Close()
// 认证
auth := smtp.PlainAuth("", username, password, host)
if err := client.Auth(auth); err != nil {
return fmt.Errorf("SMTP认证失败: %v", err)
}
// 设置发件人
if err := client.Mail(username); err != nil {
return fmt.Errorf("设置发件人失败: %v", err)
}
// 设置收件人
if err := client.Rcpt(to); err != nil {
return fmt.Errorf("设置收件人失败: %v", err)
}
// 发送邮件内容
writer, err := client.Data()
if err != nil {
return fmt.Errorf("获取邮件写入器失败: %v", err)
}
defer writer.Close()
_, err = writer.Write([]byte(message))
if err != nil {
return fmt.Errorf("写入邮件内容失败: %v", err)
}
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/emailregisterlogic.go | app/auth/auth_api/internal/logic/emailregisterlogic.go | package logic
import (
"context"
"errors"
"fmt"
"strings"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/app/user/user_rpc/types/user_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type EmailRegisterLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewEmailRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *EmailRegisterLogic {
return &EmailRegisterLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *EmailRegisterLogic) EmailRegister(req *types.EmailRegisterReq) (resp *types.EmailRegisterRes, err error) {
// 验证邮箱验证码
err = l.verifyEmailCode(req.Email, req.Code, "register")
if err != nil {
return nil, err
}
// 检查用户是否已存在
var user user_models.UserModel
err = l.svcCtx.DB.Take(&user, "email = ?", req.Email).Error
if err == nil {
return nil, errors.New("该邮箱已被注册")
}
// 生成随机昵称
nickName := fmt.Sprintf("用户%s", req.Email[:strings.Index(req.Email, "@")])
// 创建用户
_, err = l.svcCtx.UserRpc.UserCreate(l.ctx, &user_rpc.UserCreateReq{
Email: req.Email,
NickName: nickName,
Password: req.Password,
Source: 2, // 2: 邮箱注册
Phone: "", // 邮箱注册时不传手机号
})
if err != nil {
logx.Errorf("创建用户失败: %v", err)
return nil, errors.New("注册失败")
}
return &types.EmailRegisterRes{
Message: "注册成功",
}, nil
}
// 验证邮箱验证码
func (l *EmailRegisterLogic) verifyEmailCode(email, code, codeType string) error {
// 从Redis获取存储的验证码
codeKey := fmt.Sprintf("email_code_%s_%s", email, codeType)
storedCode, err := l.svcCtx.Redis.Get(codeKey).Result()
if err != nil {
return fmt.Errorf("验证码已过期或不存在")
}
// 验证验证码
if storedCode != code {
return fmt.Errorf("验证码错误")
}
// 验证成功后删除验证码
l.svcCtx.Redis.Del(codeKey)
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/logoutlogic.go | app/auth/auth_api/internal/logic/logoutlogic.go | package logic
import (
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"context"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type LogoutLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewLogoutLogic(ctx context.Context, svcCtx *svc.ServiceContext) *LogoutLogic {
return &LogoutLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *LogoutLogic) Logout(req *types.LogoutReq) (*types.LogoutRes, error) {
// 删除用户token
tokenKey := fmt.Sprintf("login_%s", req.UserID)
if err := l.svcCtx.Redis.Del(tokenKey).Err(); err != nil {
l.Logger.Errorf("删除用户token失败: %v", err)
return nil, fmt.Errorf("登出失败")
}
// 删除设备信息
deviceKey := fmt.Sprintf("device_%s", req.UserID)
if err := l.svcCtx.Redis.Del(deviceKey).Err(); err != nil {
l.Logger.Errorf("删除设备信息失败: %v", err)
return nil, fmt.Errorf("登出失败")
}
// 记录登出日志
l.Logger.Infof("用户 %s 登出成功,时间: %s", req.UserID, time.Now().Format("2006-01-02 15:04:05"))
return &types.LogoutRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/authenticationlogic.go | app/auth/auth_api/internal/logic/authenticationlogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/utils"
"beaver/utils/device"
"beaver/utils/jwts"
"github.com/zeromicro/go-zero/core/logx"
)
type AuthenticationLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewAuthenticationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AuthenticationLogic {
return &AuthenticationLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AuthenticationLogic) Authentication(req *types.AuthenticationReq) (resp *types.AuthenticationRes, err error) {
if utils.InListByRegex(l.svcCtx.Config.WhiteList, req.ValidPath) {
return
}
if req.Token == "" {
return nil, errors.New("token不能为空")
}
claims, err := jwts.ParseToken(req.Token, l.svcCtx.Config.Auth.AccessSecret)
if err != nil {
logx.Errorf("解析token失败: %v", err)
return nil, errors.New("认证失败")
}
// 从context获取User-Agent
userAgent := l.ctx.Value("user-agent")
logx.Infof("User-Agent: %s", userAgent)
var deviceType string
if userAgent == nil {
deviceType = "unknown"
logx.Errorf("User-Agent为空，用户: %s", claims.UserID)
} else {
deviceType = device.GetDeviceType(userAgent.(string))
logx.Infof("认证设备类型识别 - 用户: %s, User-Agent: %s, 识别结果: %s", claims.UserID, userAgent.(string), deviceType)
}
// 直接构建特定设备类型的key
key := fmt.Sprintf("login_%s_%s", claims.UserID, deviceType)
loginInfoStr, err := l.svcCtx.Redis.Get(key).Result()
if err != nil {
logx.Errorf("获取登录信息失败: %v, Key: %s", err, key)
return nil, errors.New("token已失效")
}
// 解析登录信息并验证token
var loginInfo map[string]interface{}
if err := json.Unmarshal([]byte(loginInfoStr), &loginInfo); err != nil {
return nil, errors.New("登录信息格式错误")
}
storedToken, ok := loginInfo["token"].(string)
if !ok || storedToken != req.Token {
return nil, errors.New("token已失效或不匹配")
}
// 更新最后活跃时间
loginInfo["last_active"] = time.Now().Format("2006-01-02 15:04:05")
updatedInfo, _ := json.Marshal(loginInfo)
l.svcCtx.Redis.Set(key, string(updatedInfo), time.Hour*48)
resp = &types.AuthenticationRes{
UserID: claims.UserID,
}
return resp, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/getphonecodelogic.go | app/auth/auth_api/internal/logic/getphonecodelogic.go | package logic
import (
"context"
"errors"
"fmt"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/utils/email"
"github.com/zeromicro/go-zero/core/logx"
)
type GetPhoneCodeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetPhoneCodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPhoneCodeLogic {
return &GetPhoneCodeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetPhoneCodeLogic) GetPhoneCode(req *types.GetPhoneCodeReq) (resp *types.GetPhoneCodeRes, err error) {
// 生成6位数字验证码
code := email.GenerateCode()
// 发送手机验证码（这里需要集成短信服务）
err = l.sendSMS(req.Phone, code, req.Type)
if err != nil {
logx.Errorf("发送短信失败: %v", err)
return nil, errors.New("发送验证码失败，请稍后重试")
}
// 存储验证码到Redis（5分钟有效期）
codeKey := fmt.Sprintf("phone_code_%s_%s", req.Phone, req.Type)
err = l.svcCtx.Redis.Set(codeKey, code, 5*time.Minute).Err()
if err != nil {
logx.Errorf("存储验证码失败: %v", err)
return nil, errors.New("服务内部异常")
}
// 设置发送频率限制（60秒）
rateLimitKey := fmt.Sprintf("phone_rate_limit_%s", req.Phone)
err = l.svcCtx.Redis.Set(rateLimitKey, "1", 60*time.Second).Err()
if err != nil {
logx.Errorf("设置发送频率限制失败: %v", err)
}
return &types.GetPhoneCodeRes{
Message: "验证码发送成功",
}, nil
}
// 发送短信验证码
func (l *GetPhoneCodeLogic) sendSMS(phone, code, codeType string) error {
// TODO: 集成短信服务商（如阿里云、腾讯云等）
// 这里暂时返回成功，实际项目中需要集成真实的短信服务
logx.Infof("发送短信验证码到 %s: %s (类型: %s)", phone, code, codeType)
// 示例：调用短信服务API
// smsClient := sms.NewClient(accessKeyId, accessKeySecret)
// request := &sms.SendSmsRequest{
// PhoneNumbers: phone,
// SignName: "海狸IM",
// TemplateCode: getSMSTemplate(codeType),
// TemplateParam: fmt.Sprintf(`{"code":"%s"}`, code),
// }
// _, err := smsClient.SendSms(request)
// return err
return nil
}
// 获取短信模板代码
func getSMSTemplate(codeType string) string {
switch codeType {
case "register":
return "SMS_123456789" // 注册模板
case "reset":
return "SMS_987654321" // 重置密码模板
case "login":
return "SMS_456789123" // 登录模板
default:
return "SMS_123456789" // 默认模板
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/emailpasswordloginlogic.go | app/auth/auth_api/internal/logic/emailpasswordloginlogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/utils/device"
"beaver/utils/jwts"
"beaver/utils/pwd"
"github.com/zeromicro/go-zero/core/logx"
)
type EmailPasswordLoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewEmailPasswordLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *EmailPasswordLoginLogic {
return &EmailPasswordLoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *EmailPasswordLoginLogic) EmailPasswordLogin(req *types.EmailPasswordLoginReq) (resp *types.EmailPasswordLoginRes, err error) {
// 查询用户信息
var user user_models.UserModel
err = l.svcCtx.DB.Take(&user, "email = ?", req.Email).Error
if err != nil {
return nil, errors.New("用户不存在")
}
// 调试日志：检查用户数据
logx.Infof("登录用户信息: UserID=%s, NickName=%s, Email=%s", user.UserID, user.NickName, user.Email)
// 验证密码
if !pwd.CheckPad(user.Password, req.Password) {
return nil, errors.New("密码错误")
}
// 根据User-Agent识别设备类型
userAgent := l.ctx.Value("user-agent")
fmt.Println("user-agent:", userAgent)
var deviceType string
if userAgent == nil {
deviceType = "unknown" // 如果没有UA信息，使用默认类型
logx.Info("无法识别设备类型，使用默认类型：unknown")
} else {
deviceType = device.GetDeviceType(userAgent.(string))
}
// 生成token，包含设备信息
token, err := jwts.GenToken(jwts.JwtPayLoad{
NickName: user.NickName,
UserID: user.UserID,
}, l.svcCtx.Config.Auth.AccessSecret, l.svcCtx.Config.Auth.AccessExpire)
if err != nil {
logx.Errorf("生成token失败: %v", err)
return nil, errors.New("服务内部异常")
}
// 检查是否已有其他设备登录
key := fmt.Sprintf("login_%s_%s", user.UserID, deviceType)
oldLoginInfo, err := l.svcCtx.Redis.Get(key).Result()
if err == nil && oldLoginInfo != "" {
// 解析旧登录信息
var loginInfo map[string]interface{}
if err := json.Unmarshal([]byte(oldLoginInfo), &loginInfo); err == nil {
oldDeviceID := loginInfo["device_id"].(string)
if oldDeviceID != req.DeviceID {
fmt.Println("不是同一设备，需要通知踢出旧设备:", oldDeviceID)
// 不是同一设备，需要通知踢出旧设备
// notifyForceOffline(user.UserID, oldDeviceID)
}
}
}
// 存储新的登录信息（包含token和设备信息）
loginInfo := map[string]interface{}{
"token": token,
"device_id": req.DeviceID,
"device_type": deviceType,
"login_time": time.Now().Format("2006-01-02 15:04:05"),
"user_agent": userAgent,
}
loginInfoJson, _ := json.Marshal(loginInfo)
err = l.svcCtx.Redis.Set(key, string(loginInfoJson), time.Hour*48).Err()
if err != nil {
logx.Errorf("存储登录信息失败: %v", err)
return nil, errors.New("服务内部异常")
}
return &types.EmailPasswordLoginRes{
Token: token,
UserID: user.UserID,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/resetpasswordlogic.go | app/auth/auth_api/internal/logic/resetpasswordlogic.go | package logic
import (
"context"
"fmt"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/utils/pwd"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type ResetPasswordLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 找回密码（通过邮箱验证码重置密码）
func NewResetPasswordLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetPasswordLogic {
return &ResetPasswordLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ResetPasswordLogic) ResetPassword(req *types.ResetPasswordReq) (resp *types.ResetPasswordRes, err error) {
// 根据邮箱查找用户
var user user_models.UserModel
if err := l.svcCtx.DB.Where("email = ?", req.Email).First(&user).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("用户不存在")
}
return nil, err
}
// 验证邮箱验证码
err = l.verifyEmailCode(req.Email, req.Code, "reset_password")
if err != nil {
return nil, err
}
// 加密新密码
hashedPassword := pwd.HahPwd(req.Password)
if err != nil {
return nil, fmt.Errorf("密码加密失败")
}
// 更新用户密码
err = l.svcCtx.DB.Model(&user).Update("password", hashedPassword).Error
if err != nil {
return nil, err
}
logx.Infof("用户 %s 密码重置成功", req.Email)
return &types.ResetPasswordRes{}, nil
}
// 验证邮箱验证码
func (l *ResetPasswordLogic) verifyEmailCode(email, code, codeType string) error {
// 从Redis获取存储的验证码
codeKey := fmt.Sprintf("email_code_%s_%s", email, codeType)
storedCode, err := l.svcCtx.Redis.Get(codeKey).Result()
if err != nil {
return fmt.Errorf("验证码已过期或不存在")
}
// 验证验证码
if storedCode != code {
return fmt.Errorf("验证码错误")
}
// 验证成功后删除验证码
l.svcCtx.Redis.Del(codeKey)
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/phoneregisterlogic.go | app/auth/auth_api/internal/logic/phoneregisterlogic.go | package logic
import (
"context"
"errors"
"fmt"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/app/user/user_rpc/types/user_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type PhoneRegisterLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewPhoneRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PhoneRegisterLogic {
return &PhoneRegisterLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *PhoneRegisterLogic) PhoneRegister(req *types.PhoneRegisterReq) (resp *types.PhoneRegisterRes, err error) {
// 验证手机验证码
err = l.verifyPhoneCode(req.Phone, req.Code, "register")
if err != nil {
return nil, err
}
// 检查用户是否已存在
var user user_models.UserModel
err = l.svcCtx.DB.Take(&user, "phone = ?", req.Phone).Error
if err == nil {
return nil, errors.New("该手机号已被注册")
}
// 创建用户
_, err = l.svcCtx.UserRpc.UserCreate(l.ctx, &user_rpc.UserCreateReq{
Phone: req.Phone,
Password: req.Password,
Source: 1, // 1: 手机号注册
})
if err != nil {
logx.Errorf("创建用户失败: %v", err)
return nil, errors.New("注册失败")
}
return &types.PhoneRegisterRes{
Message: "注册成功",
}, nil
}
// 验证手机验证码
func (l *PhoneRegisterLogic) verifyPhoneCode(phone, code, codeType string) error {
// 从Redis获取存储的验证码
codeKey := fmt.Sprintf("phone_code_%s_%s", phone, codeType)
storedCode, err := l.svcCtx.Redis.Get(codeKey).Result()
if err != nil {
return fmt.Errorf("验证码已过期或不存在")
}
// 验证验证码
if storedCode != code {
return fmt.Errorf("验证码错误")
}
// 验证成功后删除验证码
l.svcCtx.Redis.Del(codeKey)
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/phoneloginlogic.go | app/auth/auth_api/internal/logic/phoneloginlogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/utils/device"
"beaver/utils/jwts"
"beaver/utils/pwd"
"github.com/zeromicro/go-zero/core/logx"
)
type PhoneLoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewPhoneLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PhoneLoginLogic {
return &PhoneLoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *PhoneLoginLogic) PhoneLogin(req *types.PhoneLoginReq) (resp *types.PhoneLoginRes, err error) {
// 查询用户信息
var user user_models.UserModel
err = l.svcCtx.DB.Take(&user, "phone = ?", req.Phone).Error
if err != nil {
return nil, errors.New("用户不存在")
}
// 验证密码
if !pwd.CheckPad(user.Password, req.Password) {
return nil, errors.New("密码错误")
}
// 根据User-Agent识别设备类型
userAgent := l.ctx.Value("user-agent")
fmt.Println("user-agent:", userAgent)
var deviceType string
if userAgent == nil {
deviceType = "unknown" // 如果没有UA信息，使用默认类型
logx.Info("无法识别设备类型，使用默认类型：unknown")
return nil, errors.New("无法识别设备类型")
} else {
deviceType = device.GetDeviceType(userAgent.(string))
}
// 生成token，包含设备信息
token, err := jwts.GenToken(jwts.JwtPayLoad{
NickName: user.NickName,
UserID: user.UserID,
}, l.svcCtx.Config.Auth.AccessSecret, l.svcCtx.Config.Auth.AccessExpire)
if err != nil {
logx.Errorf("生成token失败: %v", err)
return nil, errors.New("服务内部异常")
}
key := fmt.Sprintf("login_%s_%s", user.UserID, deviceType)
oldLoginInfo, err := l.svcCtx.Redis.Get(key).Result()
if err == nil && oldLoginInfo != "" {
// 解析旧登录信息
var loginInfo map[string]interface{}
if err := json.Unmarshal([]byte(oldLoginInfo), &loginInfo); err == nil {
oldDeviceID := loginInfo["device_id"].(string)
if oldDeviceID != req.DeviceID {
fmt.Println("不是同一设备，需要通知踢出旧设备:", oldDeviceID)
// 不是同一设备，需要通知踢出旧设备
// notifyForceOffline(user.UserID, oldDeviceID)
}
}
}
// 存储新的登录信息（包含token和设备信息）
loginInfo := map[string]interface{}{
"token": token,
"device_id": req.DeviceID,
"device_type": deviceType,
"login_time": time.Now().Format("2006-01-02 15:04:05"),
"user_agent": userAgent,
}
loginInfoJson, _ := json.Marshal(loginInfo)
err = l.svcCtx.Redis.Set(key, string(loginInfoJson), time.Hour*48).Err()
if err != nil {
logx.Errorf("存储登录信息失败: %v", err)
return nil, errors.New("服务内部异常")
}
return &types.PhoneLoginRes{
Token: token,
UserID: user.UserID,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/auth/auth_api/internal/logic/emailloginlogic.go | app/auth/auth_api/internal/logic/emailloginlogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"beaver/app/auth/auth_api/internal/svc"
"beaver/app/auth/auth_api/internal/types"
"beaver/app/user/user_models"
"beaver/utils/device"
"beaver/utils/jwts"
"github.com/zeromicro/go-zero/core/logx"
)
type EmailLoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewEmailLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *EmailLoginLogic {
return &EmailLoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *EmailLoginLogic) EmailLogin(req *types.EmailLoginReq) (resp *types.EmailLoginRes, err error) {
// 验证验证码
err = l.verifyEmailCode(req.Email, req.Code, "login")
if err != nil {
return nil, err
}
// 查询用户信息
var user user_models.UserModel
err = l.svcCtx.DB.Take(&user, "email = ?", req.Email).Error
if err != nil {
// 如果用户不存在，自动注册
user, err = l.createUserByEmail(req.Email)
if err != nil {
return nil, errors.New("用户注册失败")
}
}
// 根据User-Agent识别设备类型
userAgent := l.ctx.Value("user-agent")
fmt.Println("user-agent:", userAgent)
var deviceType string
if userAgent == nil {
deviceType = "unknown"
logx.Info("无法识别设备类型，使用默认类型：unknown")
} else {
deviceType = device.GetDeviceType(userAgent.(string))
}
// 生成token，包含设备信息
token, err := jwts.GenToken(jwts.JwtPayLoad{
NickName: user.NickName,
UserID: user.UserID,
}, l.svcCtx.Config.Auth.AccessSecret, l.svcCtx.Config.Auth.AccessExpire)
if err != nil {
logx.Errorf("生成token失败: %v", err)
return nil, errors.New("服务内部异常")
}
// 检查是否已有其他设备登录
key := fmt.Sprintf("login_%s_%s", user.UserID, deviceType)
oldLoginInfo, err := l.svcCtx.Redis.Get(key).Result()
if err == nil && oldLoginInfo != "" {
// 解析旧登录信息
var loginInfo map[string]interface{}
if err := json.Unmarshal([]byte(oldLoginInfo), &loginInfo); err == nil {
oldDeviceID := loginInfo["device_id"].(string)
if oldDeviceID != req.DeviceID {
fmt.Println("不是同一设备，需要通知踢出旧设备:", oldDeviceID)
// 不是同一设备，需要通知踢出旧设备
// notifyForceOffline(user.UserID, oldDeviceID)
}
}
}
// 存储新的登录信息（包含token和设备信息）
loginInfo := map[string]interface{}{
"token": token,
"device_id": req.DeviceID,
"device_type": deviceType,
"login_time": time.Now().Format("2006-01-02 15:04:05"),
"user_agent": userAgent,
}
loginInfoJson, _ := json.Marshal(loginInfo)
err = l.svcCtx.Redis.Set(key, string(loginInfoJson), time.Hour*48).Err()
if err != nil {
logx.Errorf("存储登录信息失败: %v", err)
return nil, errors.New("服务内部异常")
}
return &types.EmailLoginRes{
Token: token,
UserID: user.UserID,
}, nil
}
// 通过邮箱创建新用户
func (l *EmailLoginLogic) createUserByEmail(email string) (user_models.UserModel, error) {
// 生成随机昵称
nickName := fmt.Sprintf("用户%s", email[:strings.Index(email, "@")])
// 创建用户
user := user_models.UserModel{
Email: email,
NickName: nickName,
UserID: generateUUID(),
// 其他字段使用默认值
}
err := l.svcCtx.DB.Create(&user).Error
if err != nil {
return user_models.UserModel{}, err
}
return user, nil
}
// 生成UUID
func generateUUID() string {
// 这里可以使用现有的UUID生成工具
// 暂时使用简单的实现
return fmt.Sprintf("user_%d", time.Now().UnixNano())
}
// 验证邮箱验证码
func (l *EmailLoginLogic) verifyEmailCode(email, code, codeType string) error {
// 从Redis获取存储的验证码
codeKey := fmt.Sprintf("email_code_%s_%s", email, codeType)
storedCode, err := l.svcCtx.Redis.Get(codeKey).Result()
if err != nil {
return fmt.Errorf("验证码已过期或不存在")
}
// 验证验证码
if storedCode != code {
return fmt.Errorf("验证码错误")
}
// 验证成功后删除验证码
l.svcCtx.Redis.Del(codeKey)
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/filerpc.go | app/file/file_rpc/filerpc.go | package main
import (
"flag"
"fmt"
"beaver/app/file/file_rpc/internal/config"
"beaver/app/file/file_rpc/internal/server"
"beaver/app/file/file_rpc/internal/svc"
"beaver/app/file/file_rpc/types/file_rpc"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/core/service"
"github.com/zeromicro/go-zero/zrpc"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
)
var configFile = flag.String("f", "etc/filerpc.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
ctx := svc.NewServiceContext(c)
s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
file_rpc.RegisterFileServer(grpcServer, server.NewFileServer(ctx))
if c.Mode == service.DevMode || c.Mode == service.TestMode {
reflection.Register(grpcServer)
}
})
defer s.Stop()
fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
s.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/file/file.go | app/file/file_rpc/file/file.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
// Source: file_rpc.proto
package file
import (
"context"
"beaver/app/file/file_rpc/types/file_rpc"
"github.com/zeromicro/go-zero/zrpc"
"google.golang.org/grpc"
)
type (
GetFileDetailReq = file_rpc.GetFileDetailReq
GetFileDetailRes = file_rpc.GetFileDetailRes
GetQiniuUploadTokenReq = file_rpc.GetQiniuUploadTokenReq
GetQiniuUploadTokenRes = file_rpc.GetQiniuUploadTokenRes
File interface {
// 通过fileName查询文件详情
GetFileDetail(ctx context.Context, in *GetFileDetailReq, opts ...grpc.CallOption) (*GetFileDetailRes, error)
// 获取七牛云上传token
GetQiniuUploadToken(ctx context.Context, in *GetQiniuUploadTokenReq, opts ...grpc.CallOption) (*GetQiniuUploadTokenRes, error)
}
defaultFile struct {
cli zrpc.Client
}
)
func NewFile(cli zrpc.Client) File {
return &defaultFile{
cli: cli,
}
}
// 通过fileName查询文件详情
func (m *defaultFile) GetFileDetail(ctx context.Context, in *GetFileDetailReq, opts ...grpc.CallOption) (*GetFileDetailRes, error) {
client := file_rpc.NewFileClient(m.cli.Conn())
return client.GetFileDetail(ctx, in, opts...)
}
// 获取七牛云上传token
func (m *defaultFile) GetQiniuUploadToken(ctx context.Context, in *GetQiniuUploadTokenReq, opts ...grpc.CallOption) (*GetQiniuUploadTokenRes, error) {
client := file_rpc.NewFileClient(m.cli.Conn())
return client.GetQiniuUploadToken(ctx, in, opts...)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/types/file_rpc/file_rpc.pb.go | app/file/file_rpc/types/file_rpc/file_rpc.pb.go | // Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.36.7
// protoc v4.25.3
// source: file_rpc.proto
package file_rpc
import (
reflect "reflect"
sync "sync"
unsafe "unsafe"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 文件详情请求
type GetFileDetailReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 文件ID
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetFileDetailReq) Reset() {
*x = GetFileDetailReq{}
mi := &file_file_rpc_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetFileDetailReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetFileDetailReq) ProtoMessage() {}
func (x *GetFileDetailReq) ProtoReflect() protoreflect.Message {
mi := &file_file_rpc_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetFileDetailReq.ProtoReflect.Descriptor instead.
func (*GetFileDetailReq) Descriptor() ([]byte, []int) {
return file_file_rpc_proto_rawDescGZIP(), []int{0}
}
func (x *GetFileDetailReq) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
// 文件详情响应
type GetFileDetailRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
FileKey string `protobuf:"bytes,1,opt,name=fileKey,proto3" json:"fileKey,omitempty"` // 文件唯一ID
OriginalName string `protobuf:"bytes,2,opt,name=originalName,proto3" json:"originalName,omitempty"` // 文件名
Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` // 文件大小
Path string `protobuf:"bytes,4,opt,name=path,proto3" json:"path,omitempty"` // 文件实际存储路径
Md5 string `protobuf:"bytes,5,opt,name=md5,proto3" json:"md5,omitempty"` // 文件MD5
Type string `protobuf:"bytes,6,opt,name=type,proto3" json:"type,omitempty"` // 文件类型
CreatedAt string `protobuf:"bytes,7,opt,name=createdAt,proto3" json:"createdAt,omitempty"` // 创建时间
UpdatedAt string `protobuf:"bytes,8,opt,name=updatedAt,proto3" json:"updatedAt,omitempty"` // 更新时间
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetFileDetailRes) Reset() {
*x = GetFileDetailRes{}
mi := &file_file_rpc_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetFileDetailRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetFileDetailRes) ProtoMessage() {}
func (x *GetFileDetailRes) ProtoReflect() protoreflect.Message {
mi := &file_file_rpc_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetFileDetailRes.ProtoReflect.Descriptor instead.
func (*GetFileDetailRes) Descriptor() ([]byte, []int) {
return file_file_rpc_proto_rawDescGZIP(), []int{1}
}
func (x *GetFileDetailRes) GetFileKey() string {
if x != nil {
return x.FileKey
}
return ""
}
func (x *GetFileDetailRes) GetOriginalName() string {
if x != nil {
return x.OriginalName
}
return ""
}
func (x *GetFileDetailRes) GetSize() int64 {
if x != nil {
return x.Size
}
return 0
}
func (x *GetFileDetailRes) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *GetFileDetailRes) GetMd5() string {
if x != nil {
return x.Md5
}
return ""
}
func (x *GetFileDetailRes) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *GetFileDetailRes) GetCreatedAt() string {
if x != nil {
return x.CreatedAt
}
return ""
}
func (x *GetFileDetailRes) GetUpdatedAt() string {
if x != nil {
return x.UpdatedAt
}
return ""
}
// 获取七牛云上传token请求
type GetQiniuUploadTokenReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetQiniuUploadTokenReq) Reset() {
*x = GetQiniuUploadTokenReq{}
mi := &file_file_rpc_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetQiniuUploadTokenReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetQiniuUploadTokenReq) ProtoMessage() {}
func (x *GetQiniuUploadTokenReq) ProtoReflect() protoreflect.Message {
mi := &file_file_rpc_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetQiniuUploadTokenReq.ProtoReflect.Descriptor instead.
func (*GetQiniuUploadTokenReq) Descriptor() ([]byte, []int) {
return file_file_rpc_proto_rawDescGZIP(), []int{2}
}
// 获取七牛云上传token响应
type GetQiniuUploadTokenRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
UploadToken string `protobuf:"bytes,1,opt,name=uploadToken,proto3" json:"uploadToken,omitempty"` // 上传token
ExpiresIn int64 `protobuf:"varint,2,opt,name=expiresIn,proto3" json:"expiresIn,omitempty"` // token过期时间 (秒)
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetQiniuUploadTokenRes) Reset() {
*x = GetQiniuUploadTokenRes{}
mi := &file_file_rpc_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetQiniuUploadTokenRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetQiniuUploadTokenRes) ProtoMessage() {}
func (x *GetQiniuUploadTokenRes) ProtoReflect() protoreflect.Message {
mi := &file_file_rpc_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetQiniuUploadTokenRes.ProtoReflect.Descriptor instead.
func (*GetQiniuUploadTokenRes) Descriptor() ([]byte, []int) {
return file_file_rpc_proto_rawDescGZIP(), []int{3}
}
func (x *GetQiniuUploadTokenRes) GetUploadToken() string {
if x != nil {
return x.UploadToken
}
return ""
}
func (x *GetQiniuUploadTokenRes) GetExpiresIn() int64 {
if x != nil {
return x.ExpiresIn
}
return 0
}
var File_file_rpc_proto protoreflect.FileDescriptor
const file_file_rpc_proto_rawDesc = "" +
"\n" +
"\x0efile_rpc.proto\x12\bfile_rpc\",\n" +
"\x10GetFileDetailReq\x12\x18\n" +
"\afileKey\x18\x01 \x01(\tR\afileKey\"\xda\x01\n" +
"\x10GetFileDetailRes\x12\x18\n" +
"\afileKey\x18\x01 \x01(\tR\afileKey\x12\"\n" +
"\foriginalName\x18\x02 \x01(\tR\foriginalName\x12\x12\n" +
"\x04size\x18\x03 \x01(\x03R\x04size\x12\x12\n" +
"\x04path\x18\x04 \x01(\tR\x04path\x12\x10\n" +
"\x03md5\x18\x05 \x01(\tR\x03md5\x12\x12\n" +
"\x04type\x18\x06 \x01(\tR\x04type\x12\x1c\n" +
"\tcreatedAt\x18\a \x01(\tR\tcreatedAt\x12\x1c\n" +
"\tupdatedAt\x18\b \x01(\tR\tupdatedAt\"\x18\n" +
"\x16GetQiniuUploadTokenReq\"X\n" +
"\x16GetQiniuUploadTokenRes\x12 \n" +
"\vuploadToken\x18\x01 \x01(\tR\vuploadToken\x12\x1c\n" +
"\texpiresIn\x18\x02 \x01(\x03R\texpiresIn2\xaa\x01\n" +
"\x04file\x12G\n" +
"\rGetFileDetail\x12\x1a.file_rpc.GetFileDetailReq\x1a\x1a.file_rpc.GetFileDetailRes\x12Y\n" +
"\x13GetQiniuUploadToken\x12 .file_rpc.GetQiniuUploadTokenReq\x1a .file_rpc.GetQiniuUploadTokenResB\fZ\n" +
"./file_rpcb\x06proto3"
var (
file_file_rpc_proto_rawDescOnce sync.Once
file_file_rpc_proto_rawDescData []byte
)
func file_file_rpc_proto_rawDescGZIP() []byte {
file_file_rpc_proto_rawDescOnce.Do(func() {
file_file_rpc_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_file_rpc_proto_rawDesc), len(file_file_rpc_proto_rawDesc)))
})
return file_file_rpc_proto_rawDescData
}
var file_file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
var file_file_rpc_proto_goTypes = []any{
(*GetFileDetailReq)(nil), // 0: file_rpc.GetFileDetailReq
(*GetFileDetailRes)(nil), // 1: file_rpc.GetFileDetailRes
(*GetQiniuUploadTokenReq)(nil), // 2: file_rpc.GetQiniuUploadTokenReq
(*GetQiniuUploadTokenRes)(nil), // 3: file_rpc.GetQiniuUploadTokenRes
}
var file_file_rpc_proto_depIdxs = []int32{
0, // 0: file_rpc.file.GetFileDetail:input_type -> file_rpc.GetFileDetailReq
2, // 1: file_rpc.file.GetQiniuUploadToken:input_type -> file_rpc.GetQiniuUploadTokenReq
1, // 2: file_rpc.file.GetFileDetail:output_type -> file_rpc.GetFileDetailRes
3, // 3: file_rpc.file.GetQiniuUploadToken:output_type -> file_rpc.GetQiniuUploadTokenRes
2, // [2:4] is the sub-list for method output_type
0, // [0:2] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_file_rpc_proto_init() }
func file_file_rpc_proto_init() {
if File_file_rpc_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_file_rpc_proto_rawDesc), len(file_file_rpc_proto_rawDesc)),
NumEnums: 0,
NumMessages: 4,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_file_rpc_proto_goTypes,
DependencyIndexes: file_file_rpc_proto_depIdxs,
MessageInfos: file_file_rpc_proto_msgTypes,
}.Build()
File_file_rpc_proto = out.File
file_file_rpc_proto_goTypes = nil
file_file_rpc_proto_depIdxs = nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/types/file_rpc/file_rpc_grpc.pb.go | app/file/file_rpc/types/file_rpc/file_rpc_grpc.pb.go | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc v4.25.3
// source: file_rpc.proto
package file_rpc
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9
const (
File_GetFileDetail_FullMethodName = "/file_rpc.file/GetFileDetail"
File_GetQiniuUploadToken_FullMethodName = "/file_rpc.file/GetQiniuUploadToken"
)
// FileClient is the client API for File service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
//
// 文件服务
type FileClient interface {
// 通过fileName查询文件详情
GetFileDetail(ctx context.Context, in *GetFileDetailReq, opts ...grpc.CallOption) (*GetFileDetailRes, error)
// 获取七牛云上传token
GetQiniuUploadToken(ctx context.Context, in *GetQiniuUploadTokenReq, opts ...grpc.CallOption) (*GetQiniuUploadTokenRes, error)
}
type fileClient struct {
cc grpc.ClientConnInterface
}
func NewFileClient(cc grpc.ClientConnInterface) FileClient {
return &fileClient{cc}
}
func (c *fileClient) GetFileDetail(ctx context.Context, in *GetFileDetailReq, opts ...grpc.CallOption) (*GetFileDetailRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetFileDetailRes)
err := c.cc.Invoke(ctx, File_GetFileDetail_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *fileClient) GetQiniuUploadToken(ctx context.Context, in *GetQiniuUploadTokenReq, opts ...grpc.CallOption) (*GetQiniuUploadTokenRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetQiniuUploadTokenRes)
err := c.cc.Invoke(ctx, File_GetQiniuUploadToken_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
// FileServer is the server API for File service.
// All implementations must embed UnimplementedFileServer
// for forward compatibility.
//
// 文件服务
type FileServer interface {
// 通过fileName查询文件详情
GetFileDetail(context.Context, *GetFileDetailReq) (*GetFileDetailRes, error)
// 获取七牛云上传token
GetQiniuUploadToken(context.Context, *GetQiniuUploadTokenReq) (*GetQiniuUploadTokenRes, error)
mustEmbedUnimplementedFileServer()
}
// UnimplementedFileServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedFileServer struct{}
func (UnimplementedFileServer) GetFileDetail(context.Context, *GetFileDetailReq) (*GetFileDetailRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetFileDetail not implemented")
}
func (UnimplementedFileServer) GetQiniuUploadToken(context.Context, *GetQiniuUploadTokenReq) (*GetQiniuUploadTokenRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetQiniuUploadToken not implemented")
}
func (UnimplementedFileServer) mustEmbedUnimplementedFileServer() {}
func (UnimplementedFileServer) testEmbeddedByValue() {}
// UnsafeFileServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to FileServer will
// result in compilation errors.
type UnsafeFileServer interface {
mustEmbedUnimplementedFileServer()
}
func RegisterFileServer(s grpc.ServiceRegistrar, srv FileServer) {
// If the following call pancis, it indicates UnimplementedFileServer was
// embedded by pointer and is nil. This will cause panics if an
// unimplemented method is ever invoked, so we test this at initialization
// time to prevent it from happening at runtime later due to I/O.
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
t.testEmbeddedByValue()
}
s.RegisterService(&File_ServiceDesc, srv)
}
func _File_GetFileDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetFileDetailReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(FileServer).GetFileDetail(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: File_GetFileDetail_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(FileServer).GetFileDetail(ctx, req.(*GetFileDetailReq))
}
return interceptor(ctx, in, info, handler)
}
func _File_GetQiniuUploadToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetQiniuUploadTokenReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(FileServer).GetQiniuUploadToken(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: File_GetQiniuUploadToken_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(FileServer).GetQiniuUploadToken(ctx, req.(*GetQiniuUploadTokenReq))
}
return interceptor(ctx, in, info, handler)
}
// File_ServiceDesc is the grpc.ServiceDesc for File service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var File_ServiceDesc = grpc.ServiceDesc{
ServiceName: "file_rpc.file",
HandlerType: (*FileServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetFileDetail",
Handler: _File_GetFileDetail_Handler,
},
{
MethodName: "GetQiniuUploadToken",
Handler: _File_GetQiniuUploadToken_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "file_rpc.proto",
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/internal/svc/servicecontext.go | app/file/file_rpc/internal/svc/servicecontext.go | package svc
import (
"beaver/app/file/file_rpc/internal/config"
"beaver/core"
"github.com/go-redis/redis"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
DB *gorm.DB
Redis *redis.Client
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.RedisConf.Addr, c.RedisConf.Password, c.RedisConf.Db)
return &ServiceContext{
Config: c,
Redis: client,
DB: mysqlDb,
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/internal/server/fileserver.go | app/file/file_rpc/internal/server/fileserver.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
// Source: file_rpc.proto
package server
import (
"context"
"beaver/app/file/file_rpc/internal/logic"
"beaver/app/file/file_rpc/internal/svc"
"beaver/app/file/file_rpc/types/file_rpc"
)
type FileServer struct {
svcCtx *svc.ServiceContext
file_rpc.UnimplementedFileServer
}
func NewFileServer(svcCtx *svc.ServiceContext) *FileServer {
return &FileServer{
svcCtx: svcCtx,
}
}
// 通过fileName查询文件详情
func (s *FileServer) GetFileDetail(ctx context.Context, in *file_rpc.GetFileDetailReq) (*file_rpc.GetFileDetailRes, error) {
l := logic.NewGetFileDetailLogic(ctx, s.svcCtx)
return l.GetFileDetail(in)
}
// 获取七牛云上传token
func (s *FileServer) GetQiniuUploadToken(ctx context.Context, in *file_rpc.GetQiniuUploadTokenReq) (*file_rpc.GetQiniuUploadTokenRes, error) {
l := logic.NewGetQiniuUploadTokenLogic(ctx, s.svcCtx)
return l.GetQiniuUploadToken(in)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/internal/config/config.go | app/file/file_rpc/internal/config/config.go | package config
import "github.com/zeromicro/go-zero/zrpc"
type Config struct {
zrpc.RpcServerConf
Mysql struct {
DataSource string
}
RedisConf struct {
Addr string
Password string
Db int
}
Qiniu struct {
AK string
SK string
Bucket string
ExpireTime int64
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/internal/logic/getqiniuuploadtokenlogic.go | app/file/file_rpc/internal/logic/getqiniuuploadtokenlogic.go | package logic
import (
"context"
"time"
"beaver/app/file/file_rpc/internal/svc"
"beaver/app/file/file_rpc/types/file_rpc"
"github.com/qiniu/go-sdk/v7/auth/qbox"
"github.com/qiniu/go-sdk/v7/storage"
"github.com/zeromicro/go-zero/core/logx"
)
type GetQiniuUploadTokenLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetQiniuUploadTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetQiniuUploadTokenLogic {
return &GetQiniuUploadTokenLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
// 获取七牛云上传token
func (l *GetQiniuUploadTokenLogic) GetQiniuUploadToken(in *file_rpc.GetQiniuUploadTokenReq) (*file_rpc.GetQiniuUploadTokenRes, error) {
// 创建七牛云认证对象
mac := qbox.NewMac(l.svcCtx.Config.Qiniu.AK, l.svcCtx.Config.Qiniu.SK)
// 创建上传策略
putPolicy := storage.PutPolicy{
Scope: l.svcCtx.Config.Qiniu.Bucket, // 指定上传的目标资源空间
Expires: uint64(time.Now().Add(time.Duration(l.svcCtx.Config.Qiniu.ExpireTime) * time.Second).Unix()), // 使用配置的过期时间
}
// 生成上传token
uploadToken := putPolicy.UploadToken(mac)
// 使用配置的过期时间（秒）
expiresIn := l.svcCtx.Config.Qiniu.ExpireTime
l.Logger.Infof("生成七牛云上传token成功，过期时间: %d秒", expiresIn)
return &file_rpc.GetQiniuUploadTokenRes{
UploadToken: uploadToken,
ExpiresIn: expiresIn,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_rpc/internal/logic/getfiledetaillogic.go | app/file/file_rpc/internal/logic/getfiledetaillogic.go | package logic
import (
"context"
"errors"
"beaver/app/file/file_models"
"beaver/app/file/file_rpc/internal/svc"
"beaver/app/file/file_rpc/types/file_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetFileDetailLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetFileDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetFileDetailLogic {
return &GetFileDetailLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
// 通过fileName查询文件详情
func (l *GetFileDetailLogic) GetFileDetail(in *file_rpc.GetFileDetailReq) (*file_rpc.GetFileDetailRes, error) {
var file file_models.FileModel
// 通过fileName查询文件信息
err := l.svcCtx.DB.Take(&file, "file_key = ?", in.FileKey).Error
if err != nil {
logx.Errorf("查询文件失败: %s", err.Error())
return nil, errors.New("文件不存在")
}
// 返回文件详情
return &file_rpc.GetFileDetailRes{
FileKey: file.FileKey,
OriginalName: file.OriginalName,
Size: file.Size,
Path: file.Path,
Md5: file.Md5,
Type: file.Type,
CreatedAt: file.CreatedAt.String(),
UpdatedAt: file.UpdatedAt.String(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_models/file_models.go | app/file/file_models/file_models.go | package file_models
import (
"beaver/common/models"
"database/sql/driver"
"encoding/json"
"errors"
)
// FileType 文件类型
type FileType string
const (
ImageFileType FileType = "image"
VideoFileType FileType = "video"
AudioFileType FileType = "audio"
DocumentFileType FileType = "document"
ArchiveFileType FileType = "archive"
OtherFileType FileType = "other"
)
// ImageFile 图片文件信息
type ImageFile struct {
Width int `json:"width"` // 图片宽度
Height int `json:"height"` // 图片高度
}
// VideoFile 视频文件信息
type VideoFile struct {
Width int `json:"width"` // 视频宽度
Height int `json:"height"` // 视频高度
Duration int `json:"duration"` // 视频时长（秒）
}
// AudioFile 音频文件信息
type AudioFile struct {
Duration int `json:"duration"` // 音频时长（秒）
}
// FileInfo 文件信息，类似ctype.Msg的结构
type FileInfo struct {
Type FileType `json:"type"` // 文件类型
ImageFile *ImageFile `json:"imageFile,omitempty"` // 图片文件信息
VideoFile *VideoFile `json:"videoFile,omitempty"` // 视频文件信息
AudioFile *AudioFile `json:"audioFile,omitempty"` // 音频文件信息
}
// Value converts the FileInfo to a JSON-encoded string for database storage
func (f *FileInfo) Value() (driver.Value, error) {
return json.Marshal(f)
}
// Scan converts a JSON-encoded string from the database to a FileInfo
func (f *FileInfo) Scan(value interface{}) error {
if value == nil {
return nil
}
bytes, ok := value.([]byte)
if !ok {
return errors.New("type assertion to []byte failed")
}
return json.Unmarshal(bytes, f)
}
// FileSource 文件来源
type FileSource string
const (
QiniuSource FileSource = "qiniu" // 七牛云
LocalSource FileSource = "local" // 本地存储
)
type FileModel struct {
models.Model
FileKey string `json:"fileKey"` // 文件唯一ID /api/file/{uuid}
OriginalName string `json:"originalName"` // 原始文件名（带后缀名）
Size int64 `json:"size"` // 文件大小
Path string `json:"path"` // 文件实际存储路径
Md5 string `json:"md5"` // 文件md5
Type string `json:"type"` // 文件类型
Source FileSource `json:"source" default:"qiniu"` // 文件来源：qiniu(七牛云) 或 local(本地)
FileInfo *FileInfo `gorm:"type:longtext" json:"fileInfo"` // 文件详细信息（JSON格式）
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/file.go | app/file/file_api/file.go | package main
import (
"beaver/app/file/file_api/internal/config"
"beaver/app/file/file_api/internal/handler"
"beaver/app/file/file_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"flag"
"fmt"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/file.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
server.Use(middleware.LogMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/svc/servicecontext.go | app/file/file_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/file/file_api/internal/config"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/app/user/user_rpc/user"
"beaver/common/zrpc_interceptor"
"beaver/core"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
UserRpc user_rpc.UserClient
DB *gorm.DB
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
return &ServiceContext{
Config: c,
DB: mysqlDb,
UserRpc: user.NewUser(zrpc.MustNewClient(c.UserRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/types/types.go | app/file/file_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type AudioFile struct {
Duration int `json:"duration"`
}
type FileInfo struct {
Type string `json:"type"`
ImageFile *ImageFile `json:"imageFile,optional"`
VideoFile *VideoFile `json:"videoFile,optional"`
AudioFile *AudioFile `json:"audioFile,optional"`
}
type FileReq struct {
UserID string `header:"Beaver-User-Id"`
}
type FileRes struct {
FileKey string `json:"fileKey"`
OriginalName string `json:"originalName"`
FileInfo *FileInfo `json:"fileInfo,optional"`
}
type ImageFile struct {
Width int `json:"width"`
Height int `json:"height"`
}
type PreviewReq struct {
FileKey string `path:"fileKey"`
}
type PreviewRes struct {
}
type VideoFile struct {
Width int `json:"width"`
Height int `json:"height"`
Duration int `json:"duration"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/config/config.go | app/file/file_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Mysql struct {
DataSource string
}
Etcd string
Redis struct {
Addr string
Password string
Db int
}
FileMaxSize map[string]float64
WhiteList []string
BlackList []string
UserRpc zrpc.RpcClientConf
Local struct {
UploadDir string
}
Qiniu struct {
AK string
SK string
Bucket string
Domain string
ExpireTime int64
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/handler/previewhandler.go | app/file/file_api/internal/handler/previewhandler.go | package handler
import (
"beaver/app/file/file_api/internal/handler/common"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"beaver/app/file/file_models"
"fmt"
"net/http"
"os"
"path/filepath"
"time"
"github.com/qiniu/go-sdk/v7/auth/qbox"
"github.com/qiniu/go-sdk/v7/storage"
"github.com/zeromicro/go-zero/rest/httpx"
)
func PreviewHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.PreviewReq
if err := httpx.Parse(r, &req); err != nil {
fmt.Println("err:", err)
http.Error(w, "请求参数错误", http.StatusBadRequest)
return
}
// l := logic.NewPreviewLogic(r.Context(), svcCtx)
// resp, err := l.Preview(&req)
// response.Response(r, w, resp, err)
var fileModel file_models.FileModel
err := svcCtx.DB.Take(&fileModel, "file_key = ?", req.FileKey).Error
if err != nil {
// 文件记录不存在，返回404
http.NotFound(w, r)
return
}
// 根据文件来源提供不同的预览方式
switch fileModel.Source {
case file_models.QiniuSource:
// 七牛云文件预览
filePath := fileModel.Path
// 生成带有时效限制的签名URL
mac := qbox.NewMac(svcCtx.Config.Qiniu.AK, svcCtx.Config.Qiniu.SK)
deadline := time.Now().Add(time.Duration(svcCtx.Config.Qiniu.ExpireTime) * time.Second).Unix()
privateAccessURL := storage.MakePrivateURL(mac, svcCtx.Config.Qiniu.Domain, filePath, deadline)
fmt.Println("七牛云文件预览URL:", privateAccessURL)
// 返回重定向到签名URL
http.Redirect(w, r, privateAccessURL, http.StatusFound)
case file_models.LocalSource:
// 本地文件预览
// fileModel.Path 存储的是相对路径，需要拼接 UploadDir
localFilePath := filepath.Join(svcCtx.Config.Local.UploadDir, fileModel.Path)
// 检查文件是否存在
if _, err := os.Stat(localFilePath); os.IsNotExist(err) {
// 文件不存在，返回404
http.NotFound(w, r)
return
}
// 设置响应头
w.Header().Set("Content-Type", common.GetContentType(fileModel.Type))
w.Header().Set("Content-Disposition", fmt.Sprintf("inline; FileKey=%s", fileModel.OriginalName))
// 直接返回文件内容
http.ServeFile(w, r, localFilePath)
default:
// 不支持的文件来源，返回400错误
http.Error(w, "不支持的文件来源", http.StatusBadRequest)
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/handler/fileuploadlocalhandler.go | app/file/file_api/internal/handler/fileuploadlocalhandler.go | package handler
import (
"encoding/json"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"beaver/app/file/file_api/internal/handler/common"
"beaver/app/file/file_api/internal/logic"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"beaver/app/file/file_models"
"beaver/common/response"
)
func FileUploadLocalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.FileReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
file, fileHead, err := r.FormFile("file")
if err != nil {
logx.Error(err)
response.Response(r, w, nil, err)
return
}
defer file.Close()
// 使用公共工具函数验证和处理文件
fileReq, err := common.ValidateAndProcessFile(file, fileHead, svcCtx)
if err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewFileUploadLocalLogic(r.Context(), svcCtx)
resp, _ := l.FileUploadLocal(&req)
// 检查文件是否已经存在于数据库中
existingFile, err := common.CheckFileExists(fileReq.FileMd5, svcCtx)
if err == nil {
resp.FileKey = existingFile.FileKey
resp.OriginalName = existingFile.OriginalName
// 转换FileInfo为API响应格式
if existingFile.FileInfo != nil {
resp.FileInfo = common.ConvertFileInfoToAPI(existingFile.FileInfo)
}
response.Response(r, w, resp, nil)
return
}
// 创建本地存储目录
uploadDir := svcCtx.Config.Local.UploadDir
// 生成本地文件路径
localFilePath := common.GenerateFilePath(uploadDir, fileReq.FileType, fileReq.FileMd5, fileReq.Suffix)
// 保存文件到本地
if err := common.SaveFileToLocal(localFilePath, fileReq.ByteData); err != nil {
response.Response(r, w, nil, err)
return
}
// 初始化文件信息
var fileInfo *file_models.FileInfo
// 手动解析FormData中的fileInfo字段
if fileInfoStr := r.FormValue("fileInfo"); fileInfoStr != "" {
var apiFileInfo types.FileInfo
if err := json.Unmarshal([]byte(fileInfoStr), &apiFileInfo); err == nil {
fileInfo = common.ConvertAPIFileInfoToModel(&apiFileInfo)
}
}
// 生成相对路径用于数据库存储（不包含uploadDir）
relativePath := common.GenerateRelativePath(fileReq.FileType, fileReq.FileMd5, fileReq.Suffix)
// 创建文件记录
newFileModel, err := common.CreateFileRecord(fileReq, relativePath, file_models.LocalSource, svcCtx)
if err != nil {
// 如果数据库保存失败，删除已保存的文件
// TODO: 可以添加删除文件的公共函数
response.Response(r, w, nil, err)
return
}
// 更新文件信息
if fileInfo != nil {
newFileModel.FileInfo = fileInfo
svcCtx.DB.Save(newFileModel)
}
resp.FileKey = newFileModel.FileKey
resp.OriginalName = newFileModel.OriginalName
// 转换FileInfo为API响应格式
if fileInfo != nil {
resp.FileInfo = common.ConvertFileInfoToAPI(fileInfo)
}
logx.Infof("本地文件上传成功: %s", newFileModel.FileKey)
response.Response(r, w, resp, nil)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/handler/fileuploadqiniuhandler.go | app/file/file_api/internal/handler/fileuploadqiniuhandler.go | package handler
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"github.com/qiniu/go-sdk/v7/storagev2/credentials"
"github.com/qiniu/go-sdk/v7/storagev2/http_client"
"github.com/qiniu/go-sdk/v7/storagev2/uploader"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"beaver/app/file/file_api/internal/handler/common"
"beaver/app/file/file_api/internal/logic"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"beaver/app/file/file_models"
"beaver/common/response"
)
func FileUploadQiniuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.FileReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
file, fileHead, err := r.FormFile("file")
if err != nil {
logx.Error(err)
response.Response(r, w, nil, err)
return
}
// 使用公共工具函数验证和处理文件
fileReq, err := common.ValidateAndProcessFile(file, fileHead, svcCtx)
if err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewFileUploadQiniuLogic(r.Context(), svcCtx)
resp, _ := l.FileUploadQiniu(&req)
// 检查文件是否已经存在于数据库中
existingFile, err := common.CheckFileExists(fileReq.FileMd5, svcCtx)
if err == nil {
resp.FileKey = existingFile.FileKey
resp.OriginalName = existingFile.OriginalName
// 如果文件已存在但FileInfo为空，可以设置默认值
if existingFile.FileInfo == nil {
existingFile.FileInfo = &file_models.FileInfo{
Type: file_models.FileType(existingFile.Type),
}
svcCtx.DB.Save(existingFile)
logx.Infof("已存在文件元数据设置默认值: %s", existingFile.FileKey)
}
// 转换FileInfo为API响应格式
if existingFile.FileInfo != nil {
resp.FileInfo = common.ConvertFileInfoToAPI(existingFile.FileInfo)
}
response.Response(r, w, resp, nil)
return
}
// 根据文件类型创建目录结构，并生成七牛云文件路径
fileMd5Name := fileReq.FileMd5 + "." + fileReq.Suffix
qiniuFilePath := fmt.Sprintf("%s/%s", fileReq.FileType, fileMd5Name)
// 上传文件到七牛云
qiniuURL, err := uploadToQiniu(qiniuFilePath, fileReq.ByteData, svcCtx)
if err != nil {
response.Response(r, w, nil, err)
return
}
// 创建文件记录
newFileModel, err := common.CreateFileRecord(fileReq, qiniuURL, file_models.QiniuSource, svcCtx)
if err != nil {
response.Response(r, w, nil, err)
return
}
// 初始化文件信息
var fileInfo *file_models.FileInfo
// 手动解析FormData中的fileInfo字段
if fileInfoStr := r.FormValue("fileInfo"); fileInfoStr != "" {
var apiFileInfo types.FileInfo
if err := json.Unmarshal([]byte(fileInfoStr), &apiFileInfo); err == nil {
fileInfo = common.ConvertAPIFileInfoToModel(&apiFileInfo)
}
}
if fileInfo != nil {
// 更新数据库中的FileInfo
newFileModel.FileInfo = fileInfo
svcCtx.DB.Save(newFileModel)
logx.Infof("文件元数据获取成功: %s", newFileModel.FileKey)
}
resp.FileKey = newFileModel.FileKey
resp.OriginalName = newFileModel.OriginalName
// 转换FileInfo为API响应格式
if fileInfo != nil {
resp.FileInfo = common.ConvertFileInfoToAPI(fileInfo)
}
response.Response(r, w, resp, nil)
}
}
func uploadToQiniu(filePath string, fileData []byte, config *svc.ServiceContext) (string, error) {
// 设置认证信息
mac := credentials.NewCredentials(config.Config.Qiniu.AK, config.Config.Qiniu.SK)
uploadManager := uploader.NewUploadManager(&uploader.UploadManagerOptions{
Options: http_client.Options{
Credentials: mac,
},
})
reader := bytes.NewReader(fileData)
err := uploadManager.UploadReader(context.Background(), reader, &uploader.ObjectOptions{
BucketName: config.Config.Qiniu.Bucket,
FileName: filePath,
ObjectName: &filePath,
}, nil)
if err != nil {
return "", fmt.Errorf("failed to upload file to Qiniu: %v", err)
}
return filePath, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/handler/routes.go | app/file/file_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/file/file_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 文件预览
Method: http.MethodGet,
Path: "/api/file/preview/:fileKey",
Handler: PreviewHandler(serverCtx),
},
{
// 文件上传本地
Method: http.MethodPost,
Path: "/api/file/uploadLocal",
Handler: FileUploadLocalHandler(serverCtx),
},
{
// 文件上传七牛云
Method: http.MethodPost,
Path: "/api/file/uploadQiniu",
Handler: FileUploadQiniuHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/handler/common/file_utils.go | app/file/file_api/internal/handler/common/file_utils.go | package common
import (
"errors"
"fmt"
_ "image/gif"
_ "image/jpeg"
_ "image/png"
"io"
"mime/multipart"
"os"
"path/filepath"
"strings"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"beaver/app/file/file_models"
"beaver/utils"
"beaver/utils/md5"
"github.com/zeromicro/go-zero/core/logx"
)
// FileTypeMapper maps file extensions to file types.
var FileTypeMapper = map[string]string{
"jpg": "image",
"jpeg": "image",
"png": "image",
"gif": "image",
"bmp": "image",
"webp": "image",
"mp4": "video",
"avi": "video",
"mkv": "video",
"mov": "video",
"mp3": "audio",
"wav": "audio",
"ogg": "audio",
"zip": "archive",
"rar": "archive",
"7z": "archive",
"html": "document",
"pdf": "document",
"doc": "document",
"docx": "document",
"txt": "document",
}
// FileUploadRequest 文件上传请求结构
type FileUploadRequest struct {
File multipart.File
FileHeader *multipart.FileHeader
ByteData []byte
FileMd5 string
FileType string
Suffix string
Size int64
}
// ValidateAndProcessFile 验证并处理文件上传
func ValidateAndProcessFile(file multipart.File, fileHeader *multipart.FileHeader, svcCtx *svc.ServiceContext) (*FileUploadRequest, error) {
// 文件后缀白名单验证
originalName := fileHeader.Filename
nameList := strings.Split(originalName, ".")
if len(nameList) < 2 {
return nil, errors.New("文件格式不正确")
}
suffix := strings.ToLower(nameList[len(nameList)-1])
if !utils.InList(svcCtx.Config.WhiteList, suffix) {
return nil, errors.New("文件类型不在白名单中")
}
// 确定文件类型
fileType := getFileType(suffix)
if fileType == "unknown" {
return nil, errors.New("未知文件类型")
}
// 检查文件大小
maxSize, ok := svcCtx.Config.FileMaxSize[fileType]
if !ok {
return nil, errors.New("配置中未找到该文件类型的最大大小")
}
fileSizeMB := float64(fileHeader.Size) / (1024 * 1024)
if fileSizeMB > maxSize {
return nil, fmt.Errorf("文件大小超过最大限制: %.2fMB", maxSize)
}
// 读取文件内容
byteData, err := io.ReadAll(file)
if err != nil {
return nil, fmt.Errorf("读取文件失败: %v", err)
}
// 计算文件MD5
fileMd5 := md5.MD5(byteData)
return &FileUploadRequest{
File: file,
FileHeader: fileHeader,
ByteData: byteData,
FileMd5: fileMd5,
FileType: fileType,
Suffix: suffix,
Size: fileHeader.Size,
}, nil
}
// CheckFileExists 检查文件是否已存在于数据库中
func CheckFileExists(fileMd5 string, svcCtx *svc.ServiceContext) (*file_models.FileModel, error) {
var fileModel file_models.FileModel
err := svcCtx.DB.Take(&fileModel, "md5 = ?", fileMd5).Error
if err != nil {
return nil, err
}
return &fileModel, nil
}
// CreateFileRecord 创建文件记录
func CreateFileRecord(req *FileUploadRequest, filePath string, source file_models.FileSource, svcCtx *svc.ServiceContext) (*file_models.FileModel, error) {
FileKeyWithSuffix := req.FileMd5 + "." + req.Suffix
// 创建文件记录
newFileModel := &file_models.FileModel{
OriginalName: strings.TrimSuffix(req.FileHeader.Filename, "."+req.Suffix),
Size: req.Size,
Path: filePath,
Md5: req.FileMd5,
FileKey: FileKeyWithSuffix,
Type: req.FileType,
Source: source,
}
// 保存到数据库
err := svcCtx.DB.Create(newFileModel).Error
if err != nil {
return nil, fmt.Errorf("保存文件记录失败: %v", err)
}
logx.Infof("文件记录创建成功: %s, 来源: %s", newFileModel.FileKey, source)
return newFileModel, nil
}
// getFileType 根据文件后缀获取文件类型
func getFileType(suffix string) string {
if fileType, ok := FileTypeMapper[suffix]; ok {
return fileType
}
return "unknown"
}
// GetFileTypeFromMimeType 从MIME类型获取文件类型（公共函数）
func GetFileTypeFromMimeType(mimeType string) string {
if strings.HasPrefix(mimeType, "image/") {
return "image"
} else if strings.HasPrefix(mimeType, "video/") {
return "video"
} else if strings.HasPrefix(mimeType, "audio/") {
return "audio"
} else if strings.HasPrefix(mimeType, "application/") {
return "document"
}
return "other"
}
// GetContentType 根据文件类型获取Content-Type
func GetContentType(fileType string) string {
switch fileType {
case "image":
return "image/*"
case "video":
return "video/*"
case "audio":
return "audio/*"
case "document":
return "application/pdf"
case "archive":
return "application/zip"
default:
return "application/octet-stream"
}
}
// ConvertFileInfoToAPI 转换FileInfo为API响应格式
func ConvertFileInfoToAPI(fileInfo *file_models.FileInfo) *types.FileInfo {
if fileInfo == nil {
return nil
}
result := &types.FileInfo{
Type: string(fileInfo.Type),
}
if fileInfo.ImageFile != nil {
result.ImageFile = &types.ImageFile{
Width: fileInfo.ImageFile.Width,
Height: fileInfo.ImageFile.Height,
}
}
if fileInfo.VideoFile != nil {
result.VideoFile = &types.VideoFile{
Width: fileInfo.VideoFile.Width,
Height: fileInfo.VideoFile.Height,
Duration: fileInfo.VideoFile.Duration,
}
}
if fileInfo.AudioFile != nil {
result.AudioFile = &types.AudioFile{
Duration: fileInfo.AudioFile.Duration,
}
}
return result
}
// ConvertAPIFileInfoToModel 转换API FileInfo为数据库模型格式
func ConvertAPIFileInfoToModel(apiFileInfo *types.FileInfo) *file_models.FileInfo {
if apiFileInfo == nil {
return nil
}
result := &file_models.FileInfo{
Type: file_models.FileType(apiFileInfo.Type),
}
if apiFileInfo.ImageFile != nil {
result.ImageFile = &file_models.ImageFile{
Width: apiFileInfo.ImageFile.Width,
Height: apiFileInfo.ImageFile.Height,
}
}
if apiFileInfo.VideoFile != nil {
result.VideoFile = &file_models.VideoFile{
Width: apiFileInfo.VideoFile.Width,
Height: apiFileInfo.VideoFile.Height,
Duration: apiFileInfo.VideoFile.Duration,
}
}
if apiFileInfo.AudioFile != nil {
result.AudioFile = &file_models.AudioFile{
Duration: apiFileInfo.AudioFile.Duration,
}
}
return result
}
// SaveFileToLocal 保存文件到本地（公共函数）
func SaveFileToLocal(filePath string, data []byte) error {
// 确保目录存在
dir := filepath.Dir(filePath)
if err := os.MkdirAll(dir, 0755); err != nil {
return fmt.Errorf("创建目录失败: %v", err)
}
// 保存文件
if err := os.WriteFile(filePath, data, 0644); err != nil {
return fmt.Errorf("保存文件失败: %v", err)
}
logx.Infof("文件保存成功: %s", filePath)
return nil
}
// GenerateFilePath 生成文件路径（公共函数）
func GenerateFilePath(uploadDir, fileType, fileMd5, suffix string) string {
fileMd5Name := fileMd5 + "." + suffix
return filepath.Join(uploadDir, fileType, fileMd5Name)
}
// GenerateRelativePath 生成相对路径（不包含uploadDir，用于数据库存储）
func GenerateRelativePath(fileType, fileMd5, suffix string) string {
fileMd5Name := fileMd5 + "." + suffix
// 使用 filepath.Join 生成路径，然后转换为正斜杠格式，确保跨平台一致性
path := filepath.Join(fileType, fileMd5Name)
return filepath.ToSlash(path)
}
// ParseDuration 解析时长字符串为秒数（公共函数）
func ParseDuration(durationStr string) int {
// 时长格式可能是 "123.456" 秒
if durationStr == "" {
return 0
}
// 简单处理，取整数部分
if idx := strings.Index(durationStr, "."); idx != -1 {
durationStr = durationStr[:idx]
}
var duration int
if _, err := fmt.Sscanf(durationStr, "%d", &duration); err == nil {
return duration
}
return 0
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/logic/fileuploadqiniulogic.go | app/file/file_api/internal/logic/fileuploadqiniulogic.go | package logic
import (
"context"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type FileUploadQiniuLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewFileUploadQiniuLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FileUploadQiniuLogic {
return &FileUploadQiniuLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FileUploadQiniuLogic) FileUploadQiniu(req *types.FileReq) (resp *types.FileRes, err error) {
// todo: add your logic here and delete this line
return &types.FileRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/logic/fileuploadlocallogic.go | app/file/file_api/internal/logic/fileuploadlocallogic.go | package logic
import (
"context"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type FileUploadLocalLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 文件上传本地
func NewFileUploadLocalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FileUploadLocalLogic {
return &FileUploadLocalLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FileUploadLocalLogic) FileUploadLocal(req *types.FileReq) (resp *types.FileRes, err error) {
// todo: add your logic here and delete this line
return &types.FileRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/file/file_api/internal/logic/previewlogic.go | app/file/file_api/internal/logic/previewlogic.go | package logic
import (
"context"
"beaver/app/file/file_api/internal/svc"
"beaver/app/file/file_api/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type PreviewLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewPreviewLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PreviewLogic {
return &PreviewLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *PreviewLogic) Preview(req *types.PreviewReq) (resp *types.PreviewRes, err error) {
// todo: add your logic here and delete this line
return &types.PreviewRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/user.go | app/user/user_api/user.go | package main
import (
"flag"
"fmt"
"beaver/app/user/user_api/internal/config"
"beaver/app/user/user_api/internal/handler"
"beaver/app/user/user_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/user.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
server.Use(middleware.RequestLogMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/svc/servicecontext.go | app/user/user_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/friend/friend_rpc/friend"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/group"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/user/user_api/internal/config"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/app/user/user_rpc/user"
"beaver/core"
versionPkg "beaver/core/version"
"beaver/common/zrpc_interceptor"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
DB *gorm.DB
Redis *redis.Client
UserRpc user_rpc.UserClient
FriendRpc friend_rpc.FriendClient
GroupRpc group_rpc.GroupClient
VersionGen *versionPkg.VersionGenerator
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
versionGen := versionPkg.NewVersionGenerator(client, mysqlDb)
return &ServiceContext{
Config: c,
DB: mysqlDb,
Redis: client,
UserRpc: user.NewUser(zrpc.MustNewClient(c.UserRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
FriendRpc: friend.NewFriend(zrpc.MustNewClient(c.FriendRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
GroupRpc: group.NewGroup(zrpc.MustNewClient(c.GroupRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
VersionGen: versionGen,
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/types/types.go | app/user/user_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type DeviceInfo struct {
DeviceID string `json:"deviceId"` // 设备ID
DeviceType string `json:"deviceType"` // 设备类型：desktop/mobile/web
DeviceOS string `json:"deviceOs"` // 操作系统：windows/macos/linux/android/ios/harmonyos
DeviceName string `json:"deviceName"` // 设备名称
LastLoginTime string `json:"lastLoginTime"` // 最后登录时间
IsActive bool `json:"isActive"` // 是否活跃
LastLoginIP string `json:"lastLoginIp"` // 最后登录IP
}
type GetDevicesReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
}
type GetDevicesRes struct {
Devices []DeviceInfo `json:"devices"` // 设备列表
}
type UpdateEmailReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Email string `json:"email"` // 新邮箱地址
Code string `json:"code"` // 验证码
}
type UpdateEmailRes struct {
}
type UpdateInfoReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
NickName *string `json:"nickName,optional"` // 新昵称（可选）
Avatar *string `json:"avatar,optional"` // 新头像URL（可选）
Abstract *string `json:"abstract,optional"` // 新个性签名（可选）
Gender *int8 `json:"gender,optional"` // 性别：1-男 2-女 0-未知（可选）
}
type UpdateInfoRes struct {
}
type UpdatePasswordReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
OldPassword string `json:"oldPassword"` // 旧密码
NewPassword string `json:"newPassword"` // 新密码
}
type UpdatePasswordRes struct {
}
type UserInfoReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
}
type UserInfoRes struct {
UserID string `json:"userId"` // 用户唯一标识
NickName string `json:"nickName"` // 用户昵称
Avatar string `json:"avatar"` // 用户头像URL
Abstract string `json:"abstract"` // 用户个性签名
Phone string `json:"phone,optional"` // 用户手机号
Email string `json:"email,optional"` // 用户邮箱（可选）
Gender int8 `json:"gender"` // 用户性别：1-男 2-女 0-未知
Version int64 `json:"version"` // 用户数据版本号
}
type UserSyncItem struct {
UserID string `json:"userId"` // 用户ID
NickName string `json:"nickName"` // 用户昵称
Avatar string `json:"avatar"` // 用户头像
Abstract string `json:"abstract"` // 个性签名
Phone string `json:"phone"` // 手机号
Email string `json:"email"` // 邮箱
Gender int8 `json:"gender"` // 性别
Status int8 `json:"status"` // 状态
Version int64 `json:"version"` // 版本号
CreatedAt int64 `json:"createdAt"` // 创建时间戳
UpdatedAt int64 `json:"updatedAt"` // 更新时间戳
}
type UserSyncReq struct {
UserID string `header:"Beaver-User-Id"`
UserVersions []UserVersion `json:"userVersions"` // 用户版本号数组
}
type UserSyncRes struct {
Users []UserSyncItem `json:"users"` // 用户列表
}
type UserVersion struct {
UserID string `json:"userId"` // 用户ID
Version int64 `json:"version"` // 该用户的最后同步版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/config/config.go | app/user/user_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Etcd string
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
UserRpc zrpc.RpcClientConf
FriendRpc zrpc.RpcClientConf
GroupRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/updateinfohandler.go | app/user/user_api/internal/handler/updateinfohandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func updateInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateInfoReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateInfoLogic(r.Context(), svcCtx)
resp, err := l.UpdateInfo(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/userinfohandler.go | app/user/user_api/internal/handler/userinfohandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func userInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UserInfoReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUserInfoLogic(r.Context(), svcCtx)
resp, err := l.UserInfo(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/getdeviceshandler.go | app/user/user_api/internal/handler/getdeviceshandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getDevicesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetDevicesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetDevicesLogic(r.Context(), svcCtx)
resp, err := l.GetDevices(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/usersynchandler.go | app/user/user_api/internal/handler/usersynchandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func userSyncHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UserSyncReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUserSyncLogic(r.Context(), svcCtx)
resp, err := l.UserSync(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/updateemailhandler.go | app/user/user_api/internal/handler/updateemailhandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func updateEmailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateEmailReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateEmailLogic(r.Context(), svcCtx)
resp, err := l.UpdateEmail(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/routes.go | app/user/user_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/user/user_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 获取用户设备列表
Method: http.MethodGet,
Path: "/api/user/devices",
Handler: getDevicesHandler(serverCtx),
},
{
// 用户数据增量同步（基于用户独立版本号，大厂标准方式）
Method: http.MethodPost,
Path: "/api/user/sync",
Handler: userSyncHandler(serverCtx),
},
{
// 修改用户邮箱（需要验证码）
Method: http.MethodPost,
Path: "/api/user/update_email",
Handler: updateEmailHandler(serverCtx),
},
{
// 更新用户基础信息（昵称、头像、个性签名、性别）
Method: http.MethodPost,
Path: "/api/user/update_info",
Handler: updateInfoHandler(serverCtx),
},
{
// 修改用户密码
Method: http.MethodPost,
Path: "/api/user/update_password",
Handler: updatePasswordHandler(serverCtx),
},
{
// 获取用户基础信息
Method: http.MethodGet,
Path: "/api/user/user_info",
Handler: userInfoHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/handler/updatepasswordhandler.go | app/user/user_api/internal/handler/updatepasswordhandler.go | package handler
import (
"beaver/app/user/user_api/internal/logic"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func updatePasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdatePasswordReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdatePasswordLogic(r.Context(), svcCtx)
resp, err := l.UpdatePassword(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/logic/updateinfologic.go | app/user/user_api/internal/logic/updateinfologic.go | package logic
import (
"context"
"errors"
"fmt"
"time"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/app/user/user_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UpdateInfoLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateInfoLogic {
return &UpdateInfoLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateInfoLogic) UpdateInfo(req *types.UpdateInfoReq) (resp *types.UpdateInfoRes, err error) {
// 获取要更新的用户信息
var user user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", req.UserID).First(&user).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("user not found")
}
return nil, err
}
// 准备更新的字段
updateFields := make(map[string]interface{})
if req.NickName != nil {
updateFields["nick_name"] = *req.NickName
}
if req.Avatar != nil {
updateFields["avatar"] = *req.Avatar
}
if req.Abstract != nil {
updateFields["abstract"] = *req.Abstract
}
if req.Gender != nil {
updateFields["gender"] = *req.Gender
}
var version int64 // 定义version变量在更外层作用域
// 执行更新操作
if len(updateFields) > 0 {
// 获取新版本号（用户独立递增）
version = l.svcCtx.VersionGen.GetNextVersion("users", "user_id", req.UserID)
if version == -1 {
l.Errorf("获取版本号失败")
return nil, errors.New("获取版本号失败")
}
// 添加版本号到更新字段
updateFields["version"] = version
err = l.svcCtx.DB.Model(&user).Updates(updateFields).Error
if err != nil {
return nil, err
}
l.Infof("用户信息更新成功: userID=%s, version=%d", req.UserID, version)
// 记录用户变更日志
l.recordUserChangeLog(req.UserID, version, updateFields)
}
// 异步获取所有相关用户并推送通知（只有在有更新的情况下才推送）
if version > 0 {
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取所有需要推送的用户ID
allRecipients, err := l.getAllRelatedUserIds(ctx, req.UserID)
if err != nil {
logx.Errorf("获取相关用户ID失败: %v", err)
return
}
logx.Infof("推送用户信息变更给 %d 个用户: %v", len(allRecipients), allRecipients)
// 通过ws推送给所有相关用户
for _, recipientID := range allRecipients {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.USER_PROFILE, wsTypeConst.UserReceive, req.UserID, recipientID, map[string]interface{}{
"table": "users", // 涉及的数据库表
"version": int32(version), // 最新版本号（转换为int32类型）
"targetId": req.UserID, // 变更的记录ID
}, "")
}
}()
}
return &types.UpdateInfoRes{}, nil
}
/**
* 记录用户变更日志
*/
func (l *UpdateInfoLogic) recordUserChangeLog(userID string, version int64, updateFields map[string]interface{}) {
var changeLogs []user_models.UserChangeLogModel
// 为每个变更的字段创建日志记录
for field, newValue := range updateFields {
if field == "version" {
continue // 跳过版本字段
}
var changeType string
switch field {
case "nick_name":
changeType = "nickName"
case "avatar":
changeType = "avatar"
case "abstract":
changeType = "abstract"
case "gender":
changeType = "gender"
case "status":
changeType = "status"
default:
changeType = field
}
changeLog := user_models.UserChangeLogModel{
UserID: userID,
ChangeType: changeType,
NewValue: fmt.Sprintf("%v", newValue),
ChangeTime: time.Now().Unix(),
Version: version,
}
changeLogs = append(changeLogs, changeLog)
}
// 批量插入变更日志
if len(changeLogs) > 0 {
if err := l.svcCtx.DB.Create(&changeLogs).Error; err != nil {
l.Errorf("记录用户变更日志失败: userID=%s, error=%v", userID, err)
} else {
l.Infof("用户变更日志记录成功: userID=%s, 变更数=%d", userID, len(changeLogs))
}
}
}
/**
* 获取所有需要推送的用户ID（自己 + 好友 + 群成员）
*/
func (l *UpdateInfoLogic) getAllRelatedUserIds(ctx context.Context, userID string) ([]string, error) {
// 使用map进行去重
userMap := make(map[string]bool)
// 始终包含自己的ID
userMap[userID] = true
// 1. 获取好友列表
friendResp, err := l.svcCtx.FriendRpc.GetFriendIds(ctx, &friend_rpc.GetFriendIdsRequest{
UserID: userID,
})
if err != nil {
l.Errorf("获取好友列表失败: %v", err)
return nil, err
}
for _, uid := range friendResp.FriendIds {
userMap[uid] = true
}
// 2. 获取群成员列表
groupResp, err := l.svcCtx.GroupRpc.GetUserGroupMembers(ctx, &group_rpc.GetUserGroupMembersReq{
UserID: userID,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return nil, err
}
for _, uid := range groupResp.MemberIDs {
userMap[uid] = true
}
// 转换为切片
var result []string
for uid := range userMap {
result = append(result, uid)
}
return result, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/user/user_api/internal/logic/updateemaillogic.go | app/user/user_api/internal/logic/updateemaillogic.go | package logic
import (
"context"
"fmt"
"beaver/app/user/user_api/internal/svc"
"beaver/app/user/user_api/internal/types"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UpdateEmailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateEmailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateEmailLogic {
return &UpdateEmailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateEmailLogic) UpdateEmail(req *types.UpdateEmailReq) (resp *types.UpdateEmailRes, err error) {
// 获取要更新的用户信息
var user user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", req.UserID).First(&user).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("user not found")
}
return nil, err
}
fmt.Println("当前邮箱:", user.Email)
fmt.Println("修改的邮箱", req.Email)
// 检查新邮箱是否与当前邮箱相同
if user.Email == req.Email {
return nil, fmt.Errorf("新邮箱不能与当前邮箱相同")
}
// 验证邮箱验证码
err = l.verifyEmailCode(req.Email, req.Code, "update_email")
if err != nil {
return nil, err
}
// 检查新邮箱是否已被其他用户使用
var existingUser user_models.UserModel
if err := l.svcCtx.DB.Where("email = ? AND user_id != ?", req.Email, req.UserID).First(&existingUser).Error; err == nil {
return nil, fmt.Errorf("email already exists")
} else if err != gorm.ErrRecordNotFound {
return nil, err
}
// 更新用户邮箱
err = l.svcCtx.DB.Model(&user).Update("email", req.Email).Error
if err != nil {
return nil, err
}
return &types.UpdateEmailRes{}, nil
}
// 验证邮箱验证码
func (l *UpdateEmailLogic) verifyEmailCode(email, code, codeType string) error {
// 从Redis获取存储的验证码
codeKey := fmt.Sprintf("email_code_%s_%s", email, codeType)
storedCode, err := l.svcCtx.Redis.Get(codeKey).Result()
if err != nil {
return fmt.Errorf("验证码已过期或不存在")
}
// 验证验证码
if storedCode != code {
return fmt.Errorf("验证码错误")
}
// 验证成功后删除验证码
l.svcCtx.Redis.Del(codeKey)
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.