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/group/group_api/internal/logic/searchgroupslogic.go | app/group/group_api/internal/logic/searchgroupslogic.go | package logic
import (
"context"
"strings"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type SearchGroupsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 搜索群组
func NewSearchGroupsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SearchGroupsLogic {
return &SearchGroupsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *SearchGroupsLogic) SearchGroups(req *types.GroupSearchReq) (resp *types.GroupSearchRes, err error) {
resp = &types.GroupSearchRes{
List: []types.GroupSearchItem{},
}
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
limit := req.Limit
if limit <= 0 {
limit = 20
}
if limit > 100 {
limit = 100 // 限制最大每页数量
}
offset := (page - 1) * limit
// 构建查询条件
query := l.svcCtx.DB.Model(&group_models.GroupModel{}).Where("status = 1") // 只搜索正常状态的群组
// 如果有搜索关键词，按群组名称模糊搜索（大小写不敏感）
if req.Keyword != "" {
// 使用ILIKE进行大小写不敏感的搜索，如果数据库不支持，则回退到LIKE
keyword := strings.TrimSpace(req.Keyword)
if keyword != "" {
// 尝试使用ILIKE（PostgreSQL风格的大小写不敏感搜索）
query = query.Where("LOWER(title) LIKE LOWER(?)", "%"+keyword+"%")
}
}
// 获取总数
var total int64
err = query.Count(&total).Error
if err != nil {
l.Errorf("查询群组总数失败: %v", err)
return nil, err
}
// 分页查询群组信息
var groups []group_models.GroupModel
err = query.Order("created_at DESC").Limit(limit).Offset(offset).Find(&groups).Error
if err != nil {
l.Errorf("查询群组列表失败: %v", err)
return nil, err
}
// 为每个群组获取成员数量
for _, group := range groups {
var memberCount int64
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? AND status = 1", group.GroupID).
Count(&memberCount).Error
if err != nil {
l.Errorf("查询群组成员数量失败, groupId: %s, error: %v", group.GroupID, err)
memberCount = 0
}
resp.List = append(resp.List, types.GroupSearchItem{
GroupID: group.GroupID,
Title: group.Title,
Avatar: group.Avatar,
MemberCount: int(memberCount),
JoinType: group.JoinType,
CreatorID: group.CreatorID,
})
}
resp.Count = total
l.Infof("搜索群组完成，关键词: %s, 返回群组数: %d, 总数: %d", req.Keyword, len(resp.List), total)
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/group/group_api/internal/logic/groupcreatelogic.go | app/group/group_api/internal/logic/groupcreatelogic.go | package logic
import (
"context"
"errors"
"fmt"
"time"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
utils "beaver/utils/rand"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupCreateLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGroupCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupCreateLogic {
return &GroupCreateLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupCreateLogic) GroupCreate(req *types.GroupCreateReq) (resp *types.GroupCreateRes, err error) {
//先生成群组ID
groupID := utils.GenerateUUId()
// 获取该群组的版本号（每个群独立递增）
groupVersion := l.svcCtx.VersionGen.GetNextVersion("groups", "group_id", groupID)
if groupVersion == -1 {
logx.Errorf("获取群组版本号失败")
return nil, errors.New("获取版本号失败")
}
var groupModel = group_models.GroupModel{
CreatorID: req.UserID,
GroupID: groupID,
Version: groupVersion, // 该群的独立版本
}
if len(req.UserIdList) == 0 {
return nil, errors.New("请选择用户")
}
var groupUserList = []string{req.UserID}
groupUserList = append(groupUserList, req.UserIdList...)
groupModel.Title = req.Title
err = l.svcCtx.DB.Create(&groupModel).Error
if err != nil {
logx.Errorf("创建群失败: %v", err)
return nil, errors.New("创建群失败")
}
var members []group_models.GroupMemberModel
for i, u := range groupUserList {
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", groupID)
memberMode := group_models.GroupMemberModel{
GroupID: groupID,
UserID: u,
Role: 3,
JoinTime: time.Now(),
Version: memberVersion, // 该群成员的独立版本
}
if i == 0 {
memberMode.Role = 1
}
members = append(members, memberMode)
}
err = l.svcCtx.DB.Create(&members).Error
if err != nil {
logx.Errorf("创建群成员失败: %v", err)
return nil, errors.New("创建群成员失败")
}
// 创建成员变更日志
var changeLogs []group_models.GroupMemberChangeLogModel
for _, member := range members {
// 获取全局递增的变更日志版本号
logVersion := l.svcCtx.VersionGen.GetNextVersion("group_member_logs", "", "")
if logVersion == -1 {
logx.Errorf("获取变更日志版本号失败，用户ID: %s", member.UserID)
return nil, errors.New("获取版本号失败")
}
changeLog := group_models.GroupMemberChangeLogModel{
GroupID: member.GroupID,
UserID: member.UserID,
ChangeType: "join",
OperatedBy: req.UserID, // 创建者操作
ChangeTime: member.JoinTime,
Version: logVersion,
}
changeLogs = append(changeLogs, changeLog)
}
err = l.svcCtx.DB.Create(&changeLogs).Error
if err != nil {
logx.Errorf("创建群成员变更日志失败: %v", err)
// 这里不返回错误，因为主要功能已经完成，只是日志记录失败
}
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: groupModel.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 初始化群聊会话（创建chat_conversation_meta和chat_user_conversations）
allUserIDs := append([]string{req.UserID}, req.UserIdList...)
fmt.Println("初始化群聊会话")
_, err = l.svcCtx.ChatRpc.InitializeConversation(ctx, &chat_rpc.InitializeConversationReq{
ConversationId: "group_" + groupModel.GroupID,
Type: 2, // 群聊类型
UserIds: allUserIDs,
})
if err != nil {
l.Logger.Errorf("初始化群聊会话失败: %v", err)
return
}
// 异步发送群创建成功的系统消息
go func() {
defer func() {
if r := recover(); r != nil {
l.Logger.Errorf("异步发送群创建消息时发生panic: %v", r)
}
}()
// 调用Chat服务的通知消息发送接口，发送群创建通知
_, err := l.svcCtx.ChatRpc.SendNotificationMessage(context.Background(), &chat_rpc.SendNotificationMessageReq{
ConversationId: "group_" + groupModel.GroupID,
MessageType: 2, // 群创建成功消息
Content: fmt.Sprintf("%s 创建了群聊", req.UserID), // 这里应该用实际的用户名，但简化处理
RelatedUserId: req.UserID, // 创建者ID
})
if err != nil {
l.Logger.Errorf("异步发送群创建消息失败: %v", err)
} else {
l.Logger.Infof("异步发送群创建消息成功: groupID=%s", groupModel.GroupID)
}
}()
// 通过ws推送给群成员 - 群组信息同步（推送groups和group_members两张表的更新）
// 构建所有群成员的数据（包含每个成员的版本号）
var memberData []map[string]interface{}
for _, rpcMember := range response.Members {
// 为每个成员查找其对应的版本号
var memberVersion int64 = 0
for _, createdMember := range members {
if createdMember.UserID == rpcMember.UserID {
memberVersion = createdMember.Version
break
}
}
memberData = append(memberData, map[string]interface{}{
"version": memberVersion,
"groupId": groupModel.GroupID,
"userId": rpcMember.UserID,
})
}
// 推送给每个群成员相同的完整数据
for _, member := range response.Members {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupReceive, req.UserID, member.UserID, map[string]interface{}{
"tables": []map[string]interface{}{
{
"table": "groups",
"data": []map[string]interface{}{
{
"version": groupVersion,
"groupId": groupModel.GroupID,
},
},
},
{
"table": "group_members",
"data": memberData, // 推送所有群成员的信息
},
},
}, groupModel.GroupID)
}
}()
return &types.GroupCreateRes{
GroupID: groupModel.GroupID,
Version: groupVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/updategroupinfologic.go | app/group/group_api/internal/logic/updategroupinfologic.go | package logic
import (
"context"
"errors"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type UpdateGroupInfoLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateGroupInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateGroupInfoLogic {
return &UpdateGroupInfoLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateGroupInfoLogic) UpdateGroupInfo(req *types.UpdateGroupInfoReq) (resp *types.UpdateGroupInfoRes, err error) {
var newVersion int64 // 定义newVersion变量在更外层作用域
// 检查操作者权限
var member group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&member, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("操作者不是群组成员")
}
if !(member.Role == 1 || member.Role == 2) {
return nil, errors.New("没有权限更新群组信息")
}
// 构建更新字段
updateFields := make(map[string]interface{})
if req.Title != "" {
updateFields["title"] = req.Title
}
if req.Avatar != "" {
updateFields["avatar"] = req.Avatar
}
if req.Notice != "" {
updateFields["notice"] = req.Notice
}
// 执行更新
if len(updateFields) > 0 {
// 获取该群的新版本号（独立递增）
newVersion = l.svcCtx.VersionGen.GetNextVersion("groups", "group_id", req.GroupID)
if newVersion == -1 {
l.Logger.Errorf("获取群组版本号失败")
return nil, errors.New("获取版本号失败")
}
// 添加版本号到更新字段
updateFields["version"] = newVersion
err = l.svcCtx.DB.Model(&group_models.GroupModel{}).
Where("group_id = ?", req.GroupID).
Updates(updateFields).Error
if err != nil {
l.Logger.Errorf("更新群组信息失败: %v", err)
return nil, errors.New("更新群组信息失败")
}
}
// 异步通知群成员（只有在有更新的情况下才推送）
if newVersion > 0 {
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 通过ws推送给自己和群成员 - 群组信息同步
allRecipients := append(response.Members, &group_rpc.GroupMemberInfo{UserID: req.UserID}) // 包含自己
for _, member := range allRecipients {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupReceive, req.UserID, member.UserID, map[string]interface{}{
"table": "groups",
"data": []map[string]interface{}{
{
"version": newVersion,
"groupId": req.GroupID,
},
},
}, req.GroupID)
}
}()
}
return &types.UpdateGroupInfoRes{
Version: newVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/groupminelogic.go | app/group/group_api/internal/logic/groupminelogic.go | package logic
import (
"context"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupMineLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取我加入的群组列表
func NewGroupMineLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupMineLogic {
return &GroupMineLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupMineLogic) GroupMine(req *types.GroupMineReq) (resp *types.GroupMineRes, err error) {
var groupMembers []group_models.GroupMemberModel
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
limit := req.Limit
if limit <= 0 {
limit = 20
}
offset := (page - 1) * limit
// 查询用户加入的群组
err = l.svcCtx.DB.Where("user_id = ? AND status = ?", req.UserID, 1).
Order("join_time DESC").
Offset(offset).
Limit(limit).
Find(&groupMembers).Error
if err != nil {
l.Errorf("查询用户群组失败: %v", err)
return nil, err
}
// 获取总数
var total int64
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("user_id = ? AND status = ?", req.UserID, 1).
Count(&total).Error
if err != nil {
l.Errorf("获取用户群组总数失败: %v", err)
return nil, err
}
// 转换为响应格式
var groupItems []types.GroupMineItem
for _, member := range groupMembers {
// 查询群组信息
var group group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ?", member.GroupID).First(&group).Error
if err != nil {
l.Errorf("查询群组信息失败，群组ID: %s, 错误: %v", member.GroupID, err)
continue
}
// 获取群成员数量
var memberCount int64
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? AND status = ?", group.GroupID, 1).
Count(&memberCount).Error
if err != nil {
l.Errorf("获取群成员数量失败，群组ID: %s, 错误: %v", group.GroupID, err)
continue
}
groupItems = append(groupItems, types.GroupMineItem{
GroupID: group.GroupID,
Title: group.Title,
Avatar: group.Avatar,
MemberCount: int(memberCount),
ConversationID: group.GroupID, // 群组ID作为会话ID
Version: group.Version,
})
}
resp = &types.GroupMineRes{
List: groupItems,
Count: int(total),
}
l.Infof("获取用户群组列表完成，用户ID: %s, 返回群组数: %d", req.UserID, len(groupItems))
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/group/group_api/internal/logic/groupmemberremovelogic.go | app/group/group_api/internal/logic/groupmemberremovelogic.go | package logic
import (
"context"
"errors"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupMemberRemoveLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGroupMemberRemoveLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupMemberRemoveLogic {
return &GroupMemberRemoveLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupMemberRemoveLogic) GroupMemberRemove(req *types.GroupMemberRemoveReq) (resp *types.GroupMemberRemoveRes, err error) {
// 检查操作者权限
var operator group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&operator, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("操作者不是群组成员")
}
if !(operator.Role == 1 || operator.Role == 2) {
return nil, errors.New("没有权限移除成员")
}
// 检查要移除的成员
var members []group_models.GroupMemberModel
err = l.svcCtx.DB.Where("group_id = ? and user_id in ?", req.GroupID, req.UserIds).Find(&members).Error
if err != nil {
return nil, errors.New("查询成员信息失败")
}
// 检查权限
for _, member := range members {
// 群主可以移除管理员和普通成员
if operator.Role == 1 {
if member.Role == 1 {
return nil, errors.New("不能移除群主")
}
} else if operator.Role == 2 {
// 管理员只能移除普通成员
if member.Role != 3 {
return nil, errors.New("管理员只能移除普通成员")
}
}
}
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Logger.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
// 批量更新成员状态为被踢（Status = 3）
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? and user_id in ?", req.GroupID, req.UserIds).
Updates(map[string]interface{}{
"status": 3, // 3被踢
"version": memberVersion,
}).Error
if err != nil {
l.Logger.Errorf("移除成员失败: %v", err)
return nil, errors.New("移除成员失败")
}
// 注意：群成员移除时，groups 表信息没有变化，不需要更新版本号
// 注意：群成员的版本号通过 GroupMemberModel 的 Version 字段管理，不需要更新 GroupModel
// 异步通知群成员
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 构建被移除成员的数据列表
var removedMemberData []map[string]interface{}
for _, memberID := range req.UserIds {
removedMemberData = append(removedMemberData, map[string]interface{}{
"version": memberVersion,
"groupId": req.GroupID,
"userId": memberID,
})
}
// 通知所有人（当前群成员 + 被移除的成员）：group_members变化
// 前端收到通知后，自己判断是否还在这群里，如果不在了就删除群信息
// 去重，避免重复通知
memberMap := make(map[string]bool)
var allMembers []string
// 添加当前群成员
for _, member := range response.Members {
if !memberMap[member.UserID] {
memberMap[member.UserID] = true
allMembers = append(allMembers, member.UserID)
}
}
// 添加被移除的成员
for _, memberID := range req.UserIds {
if !memberMap[memberID] {
memberMap[memberID] = true
allMembers = append(allMembers, memberID)
}
}
// 统一给所有人发送相同的消息
for _, memberID := range allMembers {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, memberID, map[string]interface{}{
"tables": []map[string]interface{}{
{
"table": "group_members",
"data": removedMemberData, // 推送所有被移除成员的信息列表
},
},
}, "")
}
}()
return &types.GroupMemberRemoveRes{
Version: memberVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/groupinvitelogic.go | app/group/group_api/internal/logic/groupinvitelogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupInviteLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 邀请用户加入群组
func NewGroupInviteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupInviteLogic {
return &GroupInviteLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupInviteLogic) GroupInvite(req *types.GroupInviteReq) (resp *types.GroupInviteRes, err error) {
// 检查群组是否存在
var group group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ? AND status = ?", req.GroupID, 1).First(&group).Error
if err != nil {
l.Errorf("群组不存在或已解散，群组ID: %s", req.GroupID)
return nil, err
}
// 检查邀请者权限（群主或管理员）
var inviterMember group_models.GroupMemberModel
err = l.svcCtx.DB.Where("group_id = ? AND user_id = ? AND status = ?",
req.GroupID, req.UserID, 1).First(&inviterMember).Error
if err != nil {
l.Errorf("邀请者不是群成员，群组ID: %s, 用户ID: %s", req.GroupID, req.UserID)
return nil, err
}
// 检查邀请者角色（群主或管理员）
if inviterMember.Role != 1 && inviterMember.Role != 2 {
l.Errorf("邀请者权限不足，群组ID: %s, 用户ID: %s, 角色: %d", req.GroupID, req.UserID, inviterMember.Role)
return nil, err
}
// 开始事务
tx := l.svcCtx.DB.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
now := time.Now()
// 处理每个被邀请的用户
for _, userId := range req.UserIds {
// 检查用户是否已经是群成员
var existingMember group_models.GroupMemberModel
err = tx.Where("group_id = ? AND user_id = ?", req.GroupID, userId).First(&existingMember).Error
if err == nil {
// 用户已经是群成员，更新状态为正常
if existingMember.Status != 1 {
err = tx.Model(&existingMember).Update("status", 1).Error
if err != nil {
tx.Rollback()
l.Errorf("更新群成员状态失败: %v", err)
return nil, err
}
}
} else {
// 添加新群成员
member := group_models.GroupMemberModel{
GroupID: req.GroupID,
UserID: userId,
Role: 3, // 普通成员
Status: 1, // 正常状态
JoinTime: now,
Version: time.Now().Unix(),
}
err = tx.Create(&member).Error
if err != nil {
tx.Rollback()
l.Errorf("添加群成员失败: %v", err)
return nil, err
}
}
// 记录群成员变更日志
changeLog := group_models.GroupMemberChangeLogModel{
GroupID: req.GroupID,
UserID: userId,
ChangeType: "invite",
OperatedBy: req.UserID,
ChangeTime: now,
Version: time.Now().Unix(),
}
err = tx.Create(&changeLog).Error
if err != nil {
tx.Rollback()
l.Errorf("记录群成员变更日志失败: %v", err)
return nil, err
}
}
// 提交事务
err = tx.Commit().Error
if err != nil {
l.Errorf("提交事务失败: %v", err)
return nil, err
}
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
resp = &types.GroupInviteRes{
Version: memberVersion,
}
// 异步通知相关成员
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表，用于推送通知
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return
}
// 推送给已存在的群成员 - 群成员变动通知
for _, member := range response.Members {
if member.UserID != req.UserID { // 不通知操作者自己
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}
// 通知被邀请的成员
for _, inviteeId := range req.UserIds {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, inviteeId, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}()
l.Infof("群组邀请完成，群组ID: %s, 邀请者: %s, 被邀请用户数: %d", req.GroupID, req.UserID, len(req.UserIds))
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/group/group_api/internal/logic/groupdeletelogic.go | app/group/group_api/internal/logic/groupdeletelogic.go | package logic
import (
"context"
"errors"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupDeleteLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGroupDeleteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupDeleteLogic {
return &GroupDeleteLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupDeleteLogic) GroupDelete(req *types.GroupDeleteReq) (resp *types.GroupDeleteRes, err error) {
// todo: add your logic here and delete this line
var groupMember group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&groupMember, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("用户不是群组成员")
}
if groupMember.Role != 1 {
return nil, errors.New("只有群主才可以删除群组")
}
// 获取该群的版本号（独立递增）
groupVersion := l.svcCtx.VersionGen.GetNextVersion("groups", "group_id", req.GroupID)
if groupVersion == -1 {
l.Logger.Errorf("获取群组版本号失败")
return nil, errors.New("获取版本号失败")
}
// 获取群成员列表，用于推送通知
var memberList []group_models.GroupMemberModel
err = l.svcCtx.DB.Find(&memberList, "group_id = ?", req.GroupID).Error
if err != nil {
return nil, errors.New("获取群成员失败")
}
// 将群组状态改为解散（逻辑删除），并更新版本号
err = l.svcCtx.DB.Model(&group_models.GroupModel{}).
Where("group_id = ?", req.GroupID).
Updates(map[string]interface{}{
"status": 3, // 3=解散
"version": groupVersion,
}).Error
if err != nil {
return nil, errors.New("解散群组失败")
}
// 异步通知所有成员群组已被解散
go func() {
// 推送给所有成员 - 群组信息同步（标记为删除状态）
for _, member := range memberList {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"tables": []map[string]interface{}{
{
"table": "groups",
"data": []map[string]interface{}{
{
"version": groupVersion,
"groupId": req.GroupID,
},
},
},
},
}, "")
}
}()
return &types.GroupDeleteRes{
Version: groupVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/groupjoinrequestsynclogic.go | app/group/group_api/internal/logic/groupjoinrequestsynclogic.go | package logic
import (
"context"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupJoinRequestSyncLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 入群申请同步
func NewGroupJoinRequestSyncLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupJoinRequestSyncLogic {
return &GroupJoinRequestSyncLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupJoinRequestSyncLogic) GroupJoinRequestSync(req *types.GroupJoinRequestSyncReq) (resp *types.GroupJoinRequestSyncRes, err error) {
resp = &types.GroupJoinRequestSyncRes{
GroupJoinRequests: []types.GroupJoinRequestSyncItem{},
}
if len(req.Groups) == 0 {
l.Infof("入群申请同步完成，用户ID: %s, 无需同步的群组", req.UserID)
return resp, nil
}
// 为每个群组查询版本变化的数据
for _, groupReq := range req.Groups {
var requests []group_models.GroupJoinRequestModel
err = l.svcCtx.DB.Where("group_id = ? AND version >= ?", groupReq.GroupID, groupReq.Version).
Find(&requests).Error
if err != nil {
l.Errorf("查询入群申请数据失败，群组ID: %s, 错误: %v", groupReq.GroupID, err)
continue
}
for _, request := range requests {
resp.GroupJoinRequests = append(resp.GroupJoinRequests, types.GroupJoinRequestSyncItem{
GroupID: request.GroupID,
ApplicantUserID: request.ApplicantUserID,
Message: request.Message,
Status: request.Status,
HandledBy: request.HandledBy,
HandledAt: func() int64 {
if request.HandledAt != nil {
return request.HandledAt.Unix()
}
return 0
}(),
Version: request.Version,
CreatedAt: time.Time(request.CreatedAt).Unix(),
UpdatedAt: time.Time(request.UpdatedAt).Unix(),
})
}
}
l.Infof("入群申请同步完成，用户ID: %s, 返回申请变化数: %d", req.UserID, len(resp.GroupJoinRequests))
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/group/group_api/internal/logic/joingrouplogic.go | app/group/group_api/internal/logic/joingrouplogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/notification/notification_models"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type JoinGroupLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewJoinGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *JoinGroupLogic {
return &JoinGroupLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *JoinGroupLogic) JoinGroup(req *types.GroupJoinReq) (resp *types.GroupJoinRes, err error) {
var memberVersion int64 = 0
// 检查群组是否存在
var group group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ? AND status = ?", req.GroupID, 1).First(&group).Error
if err != nil {
l.Errorf("群组不存在或已解散，群组ID: %s", req.GroupID)
return nil, err
}
// 检查用户是否已经是群成员
var existingMember group_models.GroupMemberModel
err = l.svcCtx.DB.Where("group_id = ? AND user_id = ?", req.GroupID, req.UserID).First(&existingMember).Error
if err == nil {
// 用户已经是群成员
if existingMember.Status == 1 {
l.Errorf("用户已经是群成员，群组ID: %s, 用户ID: %s", req.GroupID, req.UserID)
return nil, err
} else {
// 用户之前被踢出，现在重新加入
err = l.svcCtx.DB.Model(&existingMember).Updates(map[string]interface{}{
"status": 1,
"join_time": time.Now(),
}).Error
if err != nil {
l.Errorf("更新群成员状态失败: %v", err)
return nil, err
}
// 注意：群成员的版本号通过 GroupMemberModel 的 Version 字段管理，不需要更新 GroupModel
}
} else {
// 检查群组加入方式
if group.JoinType == 1 {
// 需要申请，创建申请记录
// 获取该群入群申请的版本号（按群独立递增）
requestVersion := l.svcCtx.VersionGen.GetNextVersion("group_join_requests", "group_id", req.GroupID)
if requestVersion == -1 {
l.Errorf("获取入群申请版本号失败")
return nil, errors.New("获取版本号失败")
}
joinRequest := group_models.GroupJoinRequestModel{
GroupID: req.GroupID,
ApplicantUserID: req.UserID,
Message: req.Message,
Status: 0, // 待审核
Version: requestVersion,
}
err = l.svcCtx.DB.Create(&joinRequest).Error
if err != nil {
l.Errorf("创建入群申请失败: %v", err)
return nil, err
}
resp = &types.GroupJoinRes{
Version: requestVersion,
}
l.Infof("用户申请加入群组，群组ID: %s, 用户ID: %s", req.GroupID, req.UserID)
// 异步投递通知给群主/管理员
go func() {
ctx := context.Background()
var admins []group_models.GroupMemberModel
if err := l.svcCtx.DB.WithContext(ctx).
Where("group_id = ? AND status = 1 AND role IN (?)", req.GroupID, []int{1, 2}).
Find(&admins).Error; err != nil {
l.Errorf("获取群管理员/群主失败(用于通知): %v", err)
return
}
var toUsers []string
for _, m := range admins {
toUsers = append(toUsers, m.UserID)
}
if len(toUsers) == 0 {
return
}
payload, _ := json.Marshal(map[string]interface{}{
"requestId": requestVersion,
"groupId": req.GroupID,
"userId": req.UserID,
"message": req.Message,
})
_, err = l.svcCtx.NotifyRpc.PushEvent(ctx, ¬ification_rpc.PushEventReq{
EventType: notification_models.EventTypeGroupJoinRequest,
Category: notification_models.CategoryGroup,
FromUserId: req.UserID,
TargetId: req.GroupID,
TargetType: notification_models.TargetTypeGroup,
PayloadJson: string(payload),
ToUserIds: toUsers,
DedupHash: fmt.Sprintf("%s_%d", req.GroupID, requestVersion),
})
if err != nil {
l.Errorf("投递入群申请通知失败: %v", err)
}
}()
return resp, nil
} else {
// 获取该群成员的版本号（按群独立递增）
memberVersion = l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
// 直接加入
member := group_models.GroupMemberModel{
GroupID: req.GroupID,
UserID: req.UserID,
Role: 3, // 普通成员
Status: 1, // 正常状态
JoinTime: time.Now(),
Version: memberVersion,
}
err = l.svcCtx.DB.Create(&member).Error
if err != nil {
l.Errorf("添加群成员失败: %v", err)
return nil, err
}
// 注意：群成员的版本号通过 GroupMemberModel 的 Version 字段管理，不需要更新 GroupModel
// 记录群成员变更日志
changeLog := group_models.GroupMemberChangeLogModel{
GroupID: req.GroupID,
UserID: req.UserID,
ChangeType: "join",
OperatedBy: req.UserID,
ChangeTime: time.Now(),
}
err = l.svcCtx.DB.Create(&changeLog).Error
if err != nil {
l.Errorf("记录群成员变更日志失败: %v", err)
return nil, err
}
}
}
// 确保memberVersion有值（在直接加入的情况下）
if memberVersion == 0 {
memberVersion = l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
}
// 异步通知群成员新成员加入
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表，用于推送通知
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return
}
// 推送给所有群成员 - 群成员变动通知
for _, member := range response.Members {
if member.UserID != req.UserID { // 不通知操作者自己
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}
}()
resp = &types.GroupJoinRes{
Version: memberVersion,
}
l.Infof("用户加入群组成功，群组ID: %s, 用户ID: %s", req.GroupID, req.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/group/group_api/internal/logic/updatememberrolelogic.go | app/group/group_api/internal/logic/updatememberrolelogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type UpdateMemberRoleLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateMemberRoleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateMemberRoleLogic {
return &UpdateMemberRoleLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateMemberRoleLogic) UpdateMemberRole(req *types.UpdateMemberRoleReq) (resp *types.UpdateMemberRoleRes, err error) {
// 检查群组是否存在
var group group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ? AND status = ?", req.GroupID, 1).First(&group).Error
if err != nil {
l.Errorf("群组不存在或已解散，群组ID: %s", req.GroupID)
return nil, err
}
// 检查操作者权限（群主）
var operatorMember group_models.GroupMemberModel
err = l.svcCtx.DB.Where("group_id = ? AND user_id = ? AND status = ?",
req.GroupID, req.UserID, 1).First(&operatorMember).Error
if err != nil {
l.Errorf("操作者不是群成员，群组ID: %s, 用户ID: %s", req.GroupID, req.UserID)
return nil, err
}
// 检查操作者角色（只有群主可以修改角色）
if operatorMember.Role != 1 {
l.Errorf("只有群主可以修改成员角色，群组ID: %s, 用户ID: %s, 角色: %d", req.GroupID, req.UserID, operatorMember.Role)
return nil, err
}
// 检查目标成员是否存在
var targetMember group_models.GroupMemberModel
err = l.svcCtx.DB.Where("group_id = ? AND user_id = ? AND status = ?",
req.GroupID, req.MemberID, 1).First(&targetMember).Error
if err != nil {
l.Errorf("目标用户不是群成员，群组ID: %s, 目标用户ID: %s", req.GroupID, req.MemberID)
return nil, err
}
// 不能修改自己的角色
if req.UserID == req.MemberID {
l.Errorf("不能修改自己的角色，群组ID: %s, 用户ID: %s", req.GroupID, req.UserID)
return nil, err
}
// 开始事务
tx := l.svcCtx.DB.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
tx.Rollback()
l.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
// 更新成员角色
err = tx.Model(&targetMember).Update("role", req.Role).Error
if err != nil {
tx.Rollback()
l.Errorf("更新成员角色失败: %v", err)
return nil, err
}
// 注意：群成员的版本号通过 GroupMemberModel 的 Version 字段管理，不需要更新 GroupModel
// 记录群成员变更日志
changeLog := group_models.GroupMemberChangeLogModel{
GroupID: req.GroupID,
UserID: req.MemberID,
ChangeType: "role_change",
OperatedBy: req.UserID,
ChangeTime: time.Now(),
}
err = tx.Create(&changeLog).Error
if err != nil {
tx.Rollback()
l.Errorf("记录群成员变更日志失败: %v", err)
return nil, err
}
// 提交事务
err = tx.Commit().Error
if err != nil {
l.Errorf("提交事务失败: %v", err)
return nil, err
}
// 异步通知群成员角色变更
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表，用于推送通知
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return
}
// 推送给所有群成员 - 群成员变动通知
for _, member := range response.Members {
if member.UserID != req.UserID { // 不通知操作者自己
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}
}()
resp = &types.UpdateMemberRoleRes{
Version: memberVersion,
}
l.Infof("更新群成员角色完成，群组ID: %s, 目标用户: %s, 新角色: %d, 操作者: %s", req.GroupID, req.MemberID, req.Role, req.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/group/group_api/internal/logic/groupsynclogic.go | app/group/group_api/internal/logic/groupsynclogic.go | package logic
import (
"context"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupSyncLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 群资料同步
func NewGroupSyncLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupSyncLogic {
return &GroupSyncLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupSyncLogic) GroupSync(req *types.GroupSyncReq) (resp *types.GroupSyncRes, err error) {
resp = &types.GroupSyncRes{
Groups: []types.GroupSyncItem{},
}
if len(req.Groups) == 0 {
l.Infof("群资料同步完成，用户ID: %s, 无需同步的群组", req.UserID)
return resp, nil
}
// 为每个群组查询版本大于等于本地版本的群组变更
for _, groupReq := range req.Groups {
var groups []group_models.GroupModel
err = l.svcCtx.DB.Where("group_id = ? AND version >= ?", groupReq.GroupID, groupReq.Version).
Find(&groups).Error
if err != nil {
l.Errorf("查询群组数据失败，群组ID: %s, 错误: %v", groupReq.GroupID, err)
continue
}
for _, group := range groups {
resp.Groups = append(resp.Groups, types.GroupSyncItem{
GroupID: group.GroupID,
Title: group.Title,
Avatar: group.Avatar,
CreatorID: group.CreatorID,
JoinType: group.JoinType,
Status: group.Status,
Version: group.Version,
CreatedAt: time.Time(group.CreatedAt).Unix(),
UpdatedAt: time.Time(group.UpdatedAt).Unix(),
})
}
}
l.Infof("群资料同步完成，用户ID: %s, 返回群组变化数: %d", req.UserID, len(resp.Groups))
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/group/group_api/internal/logic/groupjoinrequestlistlogic.go | app/group/group_api/internal/logic/groupjoinrequestlistlogic.go | package logic
import (
"context"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupJoinRequestListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取用户管理的群组申请列表
func NewGroupJoinRequestListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupJoinRequestListLogic {
return &GroupJoinRequestListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupJoinRequestListLogic) GroupJoinRequestList(req *types.GroupJoinRequestListReq) (resp *types.GroupJoinRequestListRes, err error) {
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
limit := req.Limit
if limit <= 0 {
limit = 20
}
offset := (page - 1) * limit
// 先获取用户管理的群组ID列表（作为群主或管理员）
var managedGroupIDs []string
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("user_id = ? AND role IN (1, 2)", req.UserID).
Pluck("group_id", &managedGroupIDs).Error
if err != nil {
l.Errorf("获取用户管理的群组失败: %v", err)
return nil, err
}
// 如果用户没有管理的群组，直接返回空结果
if len(managedGroupIDs) == 0 {
return &types.GroupJoinRequestListRes{
List: []types.GroupJoinRequestItem{},
Count: 0,
}, nil
}
var requests []group_models.GroupJoinRequestModel
// 查询用户管理的所有群组的申请列表
err = l.svcCtx.DB.Where("group_id IN (?)", managedGroupIDs).
Order("created_at DESC").
Offset(offset).
Limit(limit).
Find(&requests).Error
if err != nil {
l.Errorf("查询群组申请列表失败: %v", err)
return nil, err
}
// 获取总数
var total int64
err = l.svcCtx.DB.Model(&group_models.GroupJoinRequestModel{}).
Where("group_id IN (?)", managedGroupIDs).
Count(&total).Error
if err != nil {
l.Errorf("获取群组申请总数失败: %v", err)
return nil, err
}
// 转换为响应格式
var requestItems []types.GroupJoinRequestItem
for _, request := range requests {
// 这里需要查询用户信息，但由于没有用户RPC，暂时使用默认值
// 在实际项目中，应该通过用户RPC获取用户昵称和头像
requestItems = append(requestItems, types.GroupJoinRequestItem{
RequestID: request.Id,
GroupID: request.GroupID,
ApplicantID: request.ApplicantUserID,
ApplicantName: "用户" + request.ApplicantUserID, // 临时值，需要从用户服务获取
ApplicantAvatar: "", // 临时值，需要从用户服务获取
Message: request.Message,
Status: request.Status,
CreatedAt: time.Time(request.CreatedAt).Unix(),
Version: request.Version,
})
}
resp = &types.GroupJoinRequestListRes{
List: requestItems,
Count: total,
}
l.Infof("获取群组申请列表完成，用户ID: %s, 返回申请数: %d", req.UserID, len(requestItems))
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/group/group_api/internal/logic/groupmemberaddlogic.go | app/group/group_api/internal/logic/groupmemberaddlogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupMemberAddLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGroupMemberAddLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupMemberAddLogic {
return &GroupMemberAddLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupMemberAddLogic) GroupMemberAdd(req *types.GroupMemberAddReq) (resp *types.GroupMemberAddRes, err error) {
// 群成员邀请好友，isInvite 为true
var member group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&member, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("用户不是群组成员")
}
// 检查哪些用户已经进群了，并分类处理
var existingMembers []group_models.GroupMemberModel
l.svcCtx.DB.Find(&existingMembers, "group_id = ? and user_id in ?", req.GroupID, req.UserIds)
// 构建已存在成员的映射（按userID）
existingMemberMap := make(map[string]*group_models.GroupMemberModel)
for i := range existingMembers {
existingMemberMap[existingMembers[i].UserID] = &existingMembers[i]
}
// 检查是否有正常状态的成员（不允许重复添加）
for _, existingMember := range existingMembers {
if existingMember.Status == 1 {
return nil, errors.New("已经有用户已经是群成员")
}
}
// 分类处理：需要创建的新成员和需要更新的已存在成员
var newMembers []group_models.GroupMemberModel
var updateMembers []group_models.GroupMemberModel
var lastVersion int64 // 记录最后一个版本号，用于返回
for _, memberID := range req.UserIds {
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Logger.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
lastVersion = memberVersion // 记录最后一个版本号
existingMember, exists := existingMemberMap[memberID]
if exists {
// 成员已存在但状态不是正常（Status=2退出 或 3被踢），更新状态为正常
updateMembers = append(updateMembers, group_models.GroupMemberModel{
GroupID: req.GroupID,
UserID: memberID,
Role: existingMember.Role, // 保持原有角色
Status: 1, // 更新为正常状态
JoinTime: time.Now(), // 更新加入时间
Version: memberVersion, // 更新版本号
})
} else {
// 成员不存在，创建新记录
newMembers = append(newMembers, group_models.GroupMemberModel{
GroupID: req.GroupID,
UserID: memberID,
Role: 3, // 普通成员
Status: 1, // 正常状态
JoinTime: time.Now(),
Version: memberVersion,
})
}
}
// 创建新成员
if len(newMembers) > 0 {
err = l.svcCtx.DB.Create(&newMembers).Error
if err != nil {
l.Logger.Errorf("添加群成员失败: %v", err)
return nil, errors.New("添加失败")
}
}
// 更新已存在成员的状态
if len(updateMembers) > 0 {
for _, updateMember := range updateMembers {
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? AND user_id = ?", updateMember.GroupID, updateMember.UserID).
Updates(map[string]interface{}{
"status": 1, // 更新为正常状态
"join_time": time.Now(), // 更新加入时间
"version": updateMember.Version, // 更新版本号
}).Error
if err != nil {
l.Logger.Errorf("更新群成员状态失败: %v", err)
return nil, errors.New("更新成员状态失败")
}
}
}
// 注意：群成员的版本号通过 GroupMemberModel 的 Version 字段管理，不需要更新 GroupModel
// 更新新成员的会话记录
_, err = l.svcCtx.ChatRpc.BatchUpdateConversation(l.ctx, &chat_rpc.BatchUpdateConversationReq{
UserIds: req.UserIds,
ConversationId: req.GroupID,
LastMessage: "",
})
if err != nil {
logx.Errorf("Failed to update conversation: %v", err)
}
// 异步通知群成员
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 构建新加入成员的ID集合
newMemberIds := make(map[string]bool)
for _, newMemberID := range req.UserIds {
newMemberIds[newMemberID] = true
}
// 获取群组版本号（用于通知群组信息变化）
groupVersion := l.svcCtx.VersionGen.GetNextVersion("groups", "group_id", req.GroupID)
if groupVersion == -1 {
l.Logger.Errorf("获取群组版本号失败")
// 这里不影响主要功能，只是日志记录失败
}
// 预构建成员版本号映射表，避免重复查找
memberVersionMap := make(map[string]int64)
for _, member := range append(newMembers, updateMembers...) {
memberVersionMap[member.UserID] = member.Version
}
// 1. 通知已在群的成员：group_members变化（成员列表增加了）
// 构建新加入成员的数据列表
var newMemberData []map[string]interface{}
for _, newMemberID := range req.UserIds {
newMemberVersion := memberVersionMap[newMemberID] // 直接从映射表获取
newMemberData = append(newMemberData, map[string]interface{}{
"version": newMemberVersion,
"groupId": req.GroupID,
"userId": newMemberID,
})
}
for _, member := range response.Members {
if !newMemberIds[member.UserID] { // 不通知新加入的成员（已在群的所有成员都要收到通知，包括操作者自己）
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"tables": []map[string]interface{}{
{
"table": "group_members",
"data": newMemberData, // 推送所有新加入成员的信息列表
},
},
}, "")
}
}
// 2. 通知新加入的成员：group_members变化（他们成为了成员）+ groups变化（群基本信息）
for _, newMemberID := range req.UserIds {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, newMemberID, map[string]interface{}{
"tables": []map[string]interface{}{
{
"table": "groups",
"data": []map[string]interface{}{
{
"version": groupVersion,
"groupId": req.GroupID,
},
},
},
{
"table": "group_members",
"data": newMemberData, // 推送所有新加入成员的信息列表
},
},
}, "")
}
}()
// 创建并返回响应
resp = &types.GroupMemberAddRes{
Version: lastVersion,
}
l.Logger.Infof("成功添加 %d 位成员到群组 %d", len(req.UserIds), req.GroupID)
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/group/group_api/internal/logic/groupmembersynclogic.go | app/group/group_api/internal/logic/groupmembersynclogic.go | package logic
import (
"context"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupMemberSyncLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 群成员同步
func NewGroupMemberSyncLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupMemberSyncLogic {
return &GroupMemberSyncLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupMemberSyncLogic) GroupMemberSync(req *types.GroupMemberSyncReq) (resp *types.GroupMemberSyncRes, err error) {
resp = &types.GroupMemberSyncRes{
GroupMembers: []types.GroupMemberSyncItem{},
}
if len(req.Groups) == 0 {
l.Infof("群成员同步完成，用户ID: %s, 无需同步的群组", req.UserID)
return resp, nil
}
// 为每个群组查询版本大于本地版本的成员变更（包括所有状态：正常、退出、被踢）
for _, groupReq := range req.Groups {
var members []group_models.GroupMemberModel
// 查询 version > groupReq.Version 的成员，包括所有状态
err = l.svcCtx.DB.Where("group_id = ? AND version >= ?", groupReq.GroupID, groupReq.Version).
Find(&members).Error
if err != nil {
l.Errorf("查询群成员数据失败，群组ID: %s, 错误: %v", groupReq.GroupID, err)
continue
}
for _, member := range members {
resp.GroupMembers = append(resp.GroupMembers, types.GroupMemberSyncItem{
GroupID: member.GroupID,
UserID: member.UserID,
Role: member.Role,
Status: member.Status,
JoinTime: member.JoinTime.Unix(),
Version: member.Version,
CreatedAt: time.Time(member.CreatedAt).Unix(),
UpdatedAt: time.Time(member.UpdatedAt).Unix(),
})
}
}
l.Infof("群成员同步完成，用户ID: %s, 返回成员变化数: %d", req.UserID, len(resp.GroupMembers))
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/group/group_api/internal/logic/getgroupmemberslogic.go | app/group/group_api/internal/logic/getgroupmemberslogic.go | package logic
import (
"context"
"errors"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/user/user_rpc/types/user_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupMembersLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetGroupMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupMembersLogic {
return &GetGroupMembersLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetGroupMembersLogic) GetGroupMembers(req *types.GroupMemberListReq) (resp *types.GroupMemberListRes, err error) {
// 参数验证和默认值设置
if req.GroupID == "" {
return nil, errors.New("群组ID不能为空")
}
if req.Page <= 0 {
req.Page = 1
}
if req.Limit <= 0 {
req.Limit = 20
}
offset := (req.Page - 1) * req.Limit
// 查询群成员列表
var members []group_models.GroupMemberModel
var count int64
// 先检查群组是否存在
var groupCount int64
err = l.svcCtx.DB.Model(&group_models.GroupModel{}).Where("group_id = ?", req.GroupID).Count(&groupCount).Error
if err != nil {
l.Logger.Errorf("查询群组失败: %v", err)
return nil, errors.New("查询群组失败")
}
if groupCount == 0 {
return nil, errors.New("群组不存在")
}
// 查询成员总数
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ?", req.GroupID).
Count(&count).Error
if err != nil {
l.Logger.Errorf("统计群成员数量失败: %v", err)
return nil, errors.New("获取群成员列表失败")
}
// 分页查询成员
err = l.svcCtx.DB.Where("group_id = ?", req.GroupID).
Limit(req.Limit).
Offset(offset).
Find(&members).Error
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return nil, errors.New("获取群成员列表失败")
}
// 构建响应
resp = &types.GroupMemberListRes{
List: make([]types.GroupMemberListItem, 0, len(members)),
Count: count,
}
// 如果没有成员，直接返回空列表
if len(members) == 0 {
return resp, nil
}
// 收集所有用户ID
userIDs := make([]string, 0, len(members))
for _, member := range members {
userIDs = append(userIDs, member.UserID)
}
// 通过UserRpc批量获取用户信息
userResp, err := l.svcCtx.UserRpc.UserListInfo(l.ctx, &user_rpc.UserListInfoReq{
UserIdList: userIDs,
})
if err != nil {
l.Logger.Errorf("获取用户信息失败: %v", err)
return nil, errors.New("获取用户信息失败")
}
// 直接使用返回的用户信息映射
userMap := userResp.UserInfo
// 组装最终结果
for _, member := range members {
user, exists := userMap[member.UserID]
groupMember := types.GroupMemberListItem{
UserID: member.UserID,
Role: member.Role,
Status: member.Status,
JoinTime: member.JoinTime.String(),
Version: member.Version,
}
if exists {
groupMember.NickName = user.NickName
groupMember.Avatar = user.Avatar
} else {
groupMember.NickName = "未知用户"
groupMember.Avatar = ""
}
resp.List = append(resp.List, groupMember)
}
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/group/group_api/internal/logic/groupinfologic.go | app/group/group_api/internal/logic/groupinfologic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupInfoLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGroupInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupInfoLogic {
return &GroupInfoLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupInfoLogic) GroupInfo(req *types.GroupInfoReq) (resp *types.GroupInfoRes, err error) {
// 查询群组信息
var group group_models.GroupModel
err = l.svcCtx.DB.Take(&group, "group_id = ?", req.GroupID).Error
if err != nil {
logx.Errorf("查询群组失败: %s", err.Error())
return nil, errors.New("群组不存在")
}
// 统计成员数量
var memberCount int64
_ = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id = ?", req.GroupID).Count(&memberCount).Error
return &types.GroupInfoRes{
GroupID: group.GroupID,
Title: group.Title,
Avatar: group.Avatar,
ConversationID: group.GroupID,
MemberCount: int(memberCount),
CreatorID: group.CreatorID,
Notice: group.Notice,
JoinType: group.JoinType,
Status: group.Status,
CreatedAt: time.Time(group.CreatedAt).Unix(),
UpdatedAt: time.Time(group.UpdatedAt).Unix(),
Version: group.Version,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/quitgrouplogic.go | app/group/group_api/internal/logic/quitgrouplogic.go | package logic
import (
"context"
"encoding/json"
"errors"
"fmt"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/notification/notification_models"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type QuitGroupLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewQuitGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QuitGroupLogic {
return &QuitGroupLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *QuitGroupLogic) QuitGroup(req *types.GroupQuitReq) (resp *types.GroupQuitRes, err error) {
// 检查用户是否为群组成员
var member group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&member, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("用户不是群组成员")
}
// 检查用户是否为群主
if member.Role == 1 {
// 群主退出前需要先转让群主权限
return nil, errors.New("群主不能直接退出，请先转让群主权限")
}
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Logger.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
// 更新成员状态为退出（Status = 2）
err = l.svcCtx.DB.Model(&member).
Updates(map[string]interface{}{
"status": 2, // 2退出
"version": memberVersion,
}).Error
if err != nil {
l.Logger.Errorf("退出群组失败: %v", err)
return nil, errors.New("退出群组失败")
}
// 异步通知群成员
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 通过ws推送给群成员 - 群成员变动通知
for _, member := range response.Members {
if member.UserID != req.UserID { // 不通知操作者自己
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.GroupID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}
// 投递通知给群主/管理员
var toUsers []string
var admins []group_models.GroupMemberModel
if err := l.svcCtx.DB.WithContext(ctx).
Where("group_id = ? AND status = 1 AND role IN (?)", req.GroupID, []int{1, 2}).
Find(&admins).Error; err != nil {
l.Logger.Errorf("获取群管理员/群主失败(用于退出通知): %v", err)
} else {
for _, m := range admins {
toUsers = append(toUsers, m.UserID)
}
}
if len(toUsers) > 0 {
payload, _ := json.Marshal(map[string]interface{}{
"groupId": req.GroupID,
"userId": req.UserID,
})
_, err = l.svcCtx.NotifyRpc.PushEvent(ctx, ¬ification_rpc.PushEventReq{
EventType: notification_models.EventTypeGroupLeft,
Category: notification_models.CategoryGroup,
FromUserId: req.UserID,
TargetId: req.GroupID,
TargetType: notification_models.TargetTypeGroup,
PayloadJson: string(payload),
ToUserIds: toUsers,
DedupHash: fmt.Sprintf("%s_left_%s", req.GroupID, req.UserID),
})
if err != nil {
l.Logger.Errorf("投递退出群通知失败: %v", err)
}
}
}()
return &types.GroupQuitRes{
Version: memberVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/transferownerlogic.go | app/group/group_api/internal/logic/transferownerlogic.go | package logic
import (
"context"
"errors"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type TransferOwnerLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewTransferOwnerLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TransferOwnerLogic {
return &TransferOwnerLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *TransferOwnerLogic) TransferOwner(req *types.TransferOwnerReq) (resp *types.TransferOwnerRes, err error) {
// 检查当前用户是否为群主
var currentOwner group_models.GroupMemberModel
err = l.svcCtx.DB.Take(¤tOwner, "group_id = ? and user_id = ?", req.GroupID, req.UserID).Error
if err != nil {
return nil, errors.New("用户不是群组成员")
}
if currentOwner.Role != 1 {
return nil, errors.New("只有群主可以转让群组")
}
// 检查新群主是否为群组成员
var newOwner group_models.GroupMemberModel
err = l.svcCtx.DB.Take(&newOwner, "group_id = ? and user_id = ?", req.GroupID, req.NewOwnerID).Error
if err != nil {
return nil, errors.New("新群主不是群组成员")
}
// 开始事务
tx := l.svcCtx.DB.Begin()
if tx.Error != nil {
l.Logger.Errorf("开启事务失败: %v", tx.Error)
return nil, errors.New("转让群组失败")
}
// 更新原群主角色为普通成员
err = tx.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? and user_id = ?", req.GroupID, req.UserID).
Update("role", 3).Error
if err != nil {
tx.Rollback()
l.Logger.Errorf("更新原群主角色失败: %v", err)
return nil, errors.New("转让群组失败")
}
// 更新新群主角色
err = tx.Model(&group_models.GroupMemberModel{}).
Where("group_id = ? and user_id = ?", req.GroupID, req.NewOwnerID).
Update("role", 1).Error
if err != nil {
tx.Rollback()
l.Logger.Errorf("更新新群主角色失败: %v", err)
return nil, errors.New("转让群组失败")
}
// 获取该群成员的版本号（按群独立递增）
memberVersion := l.svcCtx.VersionGen.GetNextVersion("group_members", "group_id", req.GroupID)
if memberVersion == -1 {
l.Logger.Errorf("获取群成员版本号失败")
return nil, errors.New("获取版本号失败")
}
// 提交事务
if err = tx.Commit().Error; err != nil {
l.Logger.Errorf("提交事务失败: %v", err)
return nil, errors.New("转让群组失败")
}
// 异步通知群成员
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: req.GroupID,
})
if err != nil {
l.Logger.Errorf("获取群成员列表失败: %v", err)
return
}
// 通过ws推送给群成员 - 群成员变动通知
for _, member := range response.Members {
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.GroupID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": memberVersion,
"groupId": req.GroupID,
},
},
}, "")
}
}()
return &types.TransferOwnerRes{
Version: memberVersion,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_api/internal/logic/groupjoinrequesthandlelogic.go | app/group/group_api/internal/logic/groupjoinrequesthandlelogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/group/group_api/internal/svc"
"beaver/app/group/group_api/internal/types"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/common/ajax"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type GroupJoinRequestHandleLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 处理群组申请
func NewGroupJoinRequestHandleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GroupJoinRequestHandleLogic {
return &GroupJoinRequestHandleLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GroupJoinRequestHandleLogic) GroupJoinRequestHandle(req *types.GroupJoinRequestHandleReq) (resp *types.GroupJoinRequestHandleRes, err error) {
// 查询申请记录
var request group_models.GroupJoinRequestModel
err = l.svcCtx.DB.Where("id = ?", req.RequestID).First(&request).Error
if err != nil {
l.Errorf("查询群组申请记录失败: %v", err)
return nil, err
}
// 检查申请状态
if request.Status != 0 {
l.Errorf("申请已被处理，申请ID: %d, 当前状态: %d", req.RequestID, request.Status)
return nil, err
}
// 开始事务
tx := l.svcCtx.DB.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
// 更新申请状态
now := time.Now()
err = tx.Model(&request).Updates(map[string]interface{}{
"status": req.Status,
"handled_by": req.UserID,
"handled_at": &now,
}).Error
if err != nil {
tx.Rollback()
l.Errorf("更新申请状态失败: %v", err)
return nil, err
}
// 如果同意申请，添加群成员
if req.Status == 1 {
// 检查用户是否已经是群成员
var existingMember group_models.GroupMemberModel
err = tx.Where("group_id = ? AND user_id = ?", request.GroupID, request.ApplicantUserID).First(&existingMember).Error
if err == nil {
// 用户已经是群成员，更新状态为正常
err = tx.Model(&existingMember).Update("status", 1).Error
if err != nil {
tx.Rollback()
l.Errorf("更新群成员状态失败: %v", err)
return nil, err
}
} else {
// 获取群组当前最大版本号并递增
var maxVersion int64
tx.Model(&group_models.GroupMemberModel{}).
Where("group_id = ?", request.GroupID).
Select("COALESCE(MAX(version), 0)").
Scan(&maxVersion)
maxVersion++ // 递增版本号
// 添加新群成员
member := group_models.GroupMemberModel{
GroupID: request.GroupID,
UserID: request.ApplicantUserID,
Role: 3, // 普通成员
Status: 1, // 正常状态
JoinTime: now,
Version: maxVersion,
}
err = tx.Create(&member).Error
if err != nil {
tx.Rollback()
l.Errorf("添加群成员失败: %v", err)
return nil, err
}
}
// 记录群成员变更日志
changeLog := group_models.GroupMemberChangeLogModel{
GroupID: request.GroupID,
UserID: request.ApplicantUserID,
ChangeType: "join",
OperatedBy: req.UserID,
ChangeTime: now,
}
err = tx.Create(&changeLog).Error
if err != nil {
tx.Rollback()
l.Errorf("记录群成员变更日志失败: %v", err)
return nil, err
}
}
// 提交事务
err = tx.Commit().Error
if err != nil {
l.Errorf("提交事务失败: %v", err)
return nil, err
}
// 获取该群入群申请的版本号（按群独立递增）
requestVersion := l.svcCtx.VersionGen.GetNextVersion("group_join_requests", "group_id", request.GroupID)
if requestVersion == -1 {
l.Errorf("获取入群申请版本号失败")
return nil, errors.New("获取版本号失败")
}
resp = &types.GroupJoinRequestHandleRes{
Version: requestVersion,
}
// 如果同意申请，异步通知相关成员
if req.Status == 1 {
go func() {
// 创建新的context，避免使用请求的context
ctx := context.Background()
// 获取群成员列表，用于推送通知
response, err := l.svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
GroupID: request.GroupID,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return
}
// 推送给已存在的群成员 - 群成员变动通知
for _, member := range response.Members {
if member.UserID != req.UserID { // 不通知操作者自己
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, member.UserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": requestVersion,
"groupId": request.GroupID,
},
},
}, "")
}
}
// 通知新加入的成员 - 群成员变动通知
ajax.SendMessageToWs(l.svcCtx.Config.Etcd, wsCommandConst.GROUP_OPERATION, wsTypeConst.GroupMemberReceive, req.UserID, request.ApplicantUserID, map[string]interface{}{
"table": "group_members",
"data": []map[string]interface{}{
{
"version": requestVersion,
"groupId": request.GroupID,
},
},
}, "")
}()
}
statusText := "拒绝"
if req.Status == 1 {
statusText = "同意"
}
l.Infof("处理群组申请完成，申请ID: %d, 处理结果: %s, 处理者: %s", req.RequestID, statusText, req.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/group/group_rpc/grouprpc.go | app/group/group_rpc/grouprpc.go | package main
import (
"flag"
"fmt"
"beaver/app/group/group_rpc/internal/config"
"beaver/app/group/group_rpc/internal/server"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_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/grouprpc.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) {
group_rpc.RegisterGroupServer(grpcServer, server.NewGroupServer(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/group/group_rpc/group/group.go | app/group/group_rpc/group/group.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.3
// Source: group_rpc.proto
package group
import (
"context"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/zrpc"
"google.golang.org/grpc"
)
type (
GetGroupJoinRequestsListByIdsReq = group_rpc.GetGroupJoinRequestsListByIdsReq
GetGroupJoinRequestsListByIdsRes = group_rpc.GetGroupJoinRequestsListByIdsRes
GetGroupMembersListByIdsReq = group_rpc.GetGroupMembersListByIdsReq
GetGroupMembersListByIdsRes = group_rpc.GetGroupMembersListByIdsRes
GetGroupMembersReq = group_rpc.GetGroupMembersReq
GetGroupMembersRes = group_rpc.GetGroupMembersRes
GetGroupsListByIdsReq = group_rpc.GetGroupsListByIdsReq
GetGroupsListByIdsRes = group_rpc.GetGroupsListByIdsRes
GetUserGroupIDsReq = group_rpc.GetUserGroupIDsReq
GetUserGroupIDsRes = group_rpc.GetUserGroupIDsRes
GetUserGroupMembersReq = group_rpc.GetUserGroupMembersReq
GetUserGroupMembersRes = group_rpc.GetUserGroupMembersRes
GetUserGroupRequestVersionsReq = group_rpc.GetUserGroupRequestVersionsReq
GetUserGroupRequestVersionsRes = group_rpc.GetUserGroupRequestVersionsRes
GroupJoinRequestListById = group_rpc.GroupJoinRequestListById
GroupListById = group_rpc.GroupListById
GroupMemberInfo = group_rpc.GroupMemberInfo
GroupMemberListById = group_rpc.GroupMemberListById
GroupRequestVersionItem = group_rpc.GroupRequestVersionItem
Group interface {
GetGroupMembers(ctx context.Context, in *GetGroupMembersReq, opts ...grpc.CallOption) (*GetGroupMembersRes, error)
GetUserGroupMembers(ctx context.Context, in *GetUserGroupMembersReq, opts ...grpc.CallOption) (*GetUserGroupMembersRes, error)
GetUserGroupIDs(ctx context.Context, in *GetUserGroupIDsReq, opts ...grpc.CallOption) (*GetUserGroupIDsRes, error)
GetGroupsListByIds(ctx context.Context, in *GetGroupsListByIdsReq, opts ...grpc.CallOption) (*GetGroupsListByIdsRes, error)
GetGroupMembersListByIds(ctx context.Context, in *GetGroupMembersListByIdsReq, opts ...grpc.CallOption) (*GetGroupMembersListByIdsRes, error)
GetGroupJoinRequestsListByIds(ctx context.Context, in *GetGroupJoinRequestsListByIdsReq, opts ...grpc.CallOption) (*GetGroupJoinRequestsListByIdsRes, error)
GetUserGroupRequestVersions(ctx context.Context, in *GetUserGroupRequestVersionsReq, opts ...grpc.CallOption) (*GetUserGroupRequestVersionsRes, error)
}
defaultGroup struct {
cli zrpc.Client
}
)
func NewGroup(cli zrpc.Client) Group {
return &defaultGroup{
cli: cli,
}
}
func (m *defaultGroup) GetGroupMembers(ctx context.Context, in *GetGroupMembersReq, opts ...grpc.CallOption) (*GetGroupMembersRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetGroupMembers(ctx, in, opts...)
}
func (m *defaultGroup) GetUserGroupMembers(ctx context.Context, in *GetUserGroupMembersReq, opts ...grpc.CallOption) (*GetUserGroupMembersRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetUserGroupMembers(ctx, in, opts...)
}
func (m *defaultGroup) GetUserGroupIDs(ctx context.Context, in *GetUserGroupIDsReq, opts ...grpc.CallOption) (*GetUserGroupIDsRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetUserGroupIDs(ctx, in, opts...)
}
func (m *defaultGroup) GetGroupsListByIds(ctx context.Context, in *GetGroupsListByIdsReq, opts ...grpc.CallOption) (*GetGroupsListByIdsRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetGroupsListByIds(ctx, in, opts...)
}
func (m *defaultGroup) GetGroupMembersListByIds(ctx context.Context, in *GetGroupMembersListByIdsReq, opts ...grpc.CallOption) (*GetGroupMembersListByIdsRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetGroupMembersListByIds(ctx, in, opts...)
}
func (m *defaultGroup) GetGroupJoinRequestsListByIds(ctx context.Context, in *GetGroupJoinRequestsListByIdsReq, opts ...grpc.CallOption) (*GetGroupJoinRequestsListByIdsRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetGroupJoinRequestsListByIds(ctx, in, opts...)
}
func (m *defaultGroup) GetUserGroupRequestVersions(ctx context.Context, in *GetUserGroupRequestVersionsReq, opts ...grpc.CallOption) (*GetUserGroupRequestVersionsRes, error) {
client := group_rpc.NewGroupClient(m.cli.Conn())
return client.GetUserGroupRequestVersions(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/group/group_rpc/types/group_rpc/group_rpc_grpc.pb.go | app/group/group_rpc/types/group_rpc/group_rpc_grpc.pb.go | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc v3.19.4
// source: group_rpc.proto
package group_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 (
Group_GetGroupMembers_FullMethodName = "/group_rpc.group/GetGroupMembers"
Group_GetUserGroupMembers_FullMethodName = "/group_rpc.group/GetUserGroupMembers"
Group_GetUserGroupIDs_FullMethodName = "/group_rpc.group/GetUserGroupIDs"
Group_GetGroupsListByIds_FullMethodName = "/group_rpc.group/GetGroupsListByIds"
Group_GetGroupMembersListByIds_FullMethodName = "/group_rpc.group/GetGroupMembersListByIds"
Group_GetGroupJoinRequestsListByIds_FullMethodName = "/group_rpc.group/GetGroupJoinRequestsListByIds"
Group_GetUserGroupRequestVersions_FullMethodName = "/group_rpc.group/GetUserGroupRequestVersions"
)
// GroupClient is the client API for Group 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 GroupClient interface {
GetGroupMembers(ctx context.Context, in *GetGroupMembersReq, opts ...grpc.CallOption) (*GetGroupMembersRes, error)
GetUserGroupMembers(ctx context.Context, in *GetUserGroupMembersReq, opts ...grpc.CallOption) (*GetUserGroupMembersRes, error)
GetUserGroupIDs(ctx context.Context, in *GetUserGroupIDsReq, opts ...grpc.CallOption) (*GetUserGroupIDsRes, error)
GetGroupsListByIds(ctx context.Context, in *GetGroupsListByIdsReq, opts ...grpc.CallOption) (*GetGroupsListByIdsRes, error)
GetGroupMembersListByIds(ctx context.Context, in *GetGroupMembersListByIdsReq, opts ...grpc.CallOption) (*GetGroupMembersListByIdsRes, error)
GetGroupJoinRequestsListByIds(ctx context.Context, in *GetGroupJoinRequestsListByIdsReq, opts ...grpc.CallOption) (*GetGroupJoinRequestsListByIdsRes, error)
GetUserGroupRequestVersions(ctx context.Context, in *GetUserGroupRequestVersionsReq, opts ...grpc.CallOption) (*GetUserGroupRequestVersionsRes, error)
}
type groupClient struct {
cc grpc.ClientConnInterface
}
func NewGroupClient(cc grpc.ClientConnInterface) GroupClient {
return &groupClient{cc}
}
func (c *groupClient) GetGroupMembers(ctx context.Context, in *GetGroupMembersReq, opts ...grpc.CallOption) (*GetGroupMembersRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetGroupMembersRes)
err := c.cc.Invoke(ctx, Group_GetGroupMembers_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetUserGroupMembers(ctx context.Context, in *GetUserGroupMembersReq, opts ...grpc.CallOption) (*GetUserGroupMembersRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserGroupMembersRes)
err := c.cc.Invoke(ctx, Group_GetUserGroupMembers_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetUserGroupIDs(ctx context.Context, in *GetUserGroupIDsReq, opts ...grpc.CallOption) (*GetUserGroupIDsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserGroupIDsRes)
err := c.cc.Invoke(ctx, Group_GetUserGroupIDs_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetGroupsListByIds(ctx context.Context, in *GetGroupsListByIdsReq, opts ...grpc.CallOption) (*GetGroupsListByIdsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetGroupsListByIdsRes)
err := c.cc.Invoke(ctx, Group_GetGroupsListByIds_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetGroupMembersListByIds(ctx context.Context, in *GetGroupMembersListByIdsReq, opts ...grpc.CallOption) (*GetGroupMembersListByIdsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetGroupMembersListByIdsRes)
err := c.cc.Invoke(ctx, Group_GetGroupMembersListByIds_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetGroupJoinRequestsListByIds(ctx context.Context, in *GetGroupJoinRequestsListByIdsReq, opts ...grpc.CallOption) (*GetGroupJoinRequestsListByIdsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetGroupJoinRequestsListByIdsRes)
err := c.cc.Invoke(ctx, Group_GetGroupJoinRequestsListByIds_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *groupClient) GetUserGroupRequestVersions(ctx context.Context, in *GetUserGroupRequestVersionsReq, opts ...grpc.CallOption) (*GetUserGroupRequestVersionsRes, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetUserGroupRequestVersionsRes)
err := c.cc.Invoke(ctx, Group_GetUserGroupRequestVersions_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
// GroupServer is the server API for Group service.
// All implementations must embed UnimplementedGroupServer
// for forward compatibility.
type GroupServer interface {
GetGroupMembers(context.Context, *GetGroupMembersReq) (*GetGroupMembersRes, error)
GetUserGroupMembers(context.Context, *GetUserGroupMembersReq) (*GetUserGroupMembersRes, error)
GetUserGroupIDs(context.Context, *GetUserGroupIDsReq) (*GetUserGroupIDsRes, error)
GetGroupsListByIds(context.Context, *GetGroupsListByIdsReq) (*GetGroupsListByIdsRes, error)
GetGroupMembersListByIds(context.Context, *GetGroupMembersListByIdsReq) (*GetGroupMembersListByIdsRes, error)
GetGroupJoinRequestsListByIds(context.Context, *GetGroupJoinRequestsListByIdsReq) (*GetGroupJoinRequestsListByIdsRes, error)
GetUserGroupRequestVersions(context.Context, *GetUserGroupRequestVersionsReq) (*GetUserGroupRequestVersionsRes, error)
mustEmbedUnimplementedGroupServer()
}
// UnimplementedGroupServer 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 UnimplementedGroupServer struct{}
func (UnimplementedGroupServer) GetGroupMembers(context.Context, *GetGroupMembersReq) (*GetGroupMembersRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetGroupMembers not implemented")
}
func (UnimplementedGroupServer) GetUserGroupMembers(context.Context, *GetUserGroupMembersReq) (*GetUserGroupMembersRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserGroupMembers not implemented")
}
func (UnimplementedGroupServer) GetUserGroupIDs(context.Context, *GetUserGroupIDsReq) (*GetUserGroupIDsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserGroupIDs not implemented")
}
func (UnimplementedGroupServer) GetGroupsListByIds(context.Context, *GetGroupsListByIdsReq) (*GetGroupsListByIdsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetGroupsListByIds not implemented")
}
func (UnimplementedGroupServer) GetGroupMembersListByIds(context.Context, *GetGroupMembersListByIdsReq) (*GetGroupMembersListByIdsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetGroupMembersListByIds not implemented")
}
func (UnimplementedGroupServer) GetGroupJoinRequestsListByIds(context.Context, *GetGroupJoinRequestsListByIdsReq) (*GetGroupJoinRequestsListByIdsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetGroupJoinRequestsListByIds not implemented")
}
func (UnimplementedGroupServer) GetUserGroupRequestVersions(context.Context, *GetUserGroupRequestVersionsReq) (*GetUserGroupRequestVersionsRes, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetUserGroupRequestVersions not implemented")
}
func (UnimplementedGroupServer) mustEmbedUnimplementedGroupServer() {}
func (UnimplementedGroupServer) testEmbeddedByValue() {}
// UnsafeGroupServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GroupServer will
// result in compilation errors.
type UnsafeGroupServer interface {
mustEmbedUnimplementedGroupServer()
}
func RegisterGroupServer(s grpc.ServiceRegistrar, srv GroupServer) {
// If the following call pancis, it indicates UnimplementedGroupServer 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(&Group_ServiceDesc, srv)
}
func _Group_GetGroupMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetGroupMembersReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetGroupMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetGroupMembers_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetGroupMembers(ctx, req.(*GetGroupMembersReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetUserGroupMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserGroupMembersReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetUserGroupMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetUserGroupMembers_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetUserGroupMembers(ctx, req.(*GetUserGroupMembersReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetUserGroupIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserGroupIDsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetUserGroupIDs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetUserGroupIDs_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetUserGroupIDs(ctx, req.(*GetUserGroupIDsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetGroupsListByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetGroupsListByIdsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetGroupsListByIds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetGroupsListByIds_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetGroupsListByIds(ctx, req.(*GetGroupsListByIdsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetGroupMembersListByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetGroupMembersListByIdsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetGroupMembersListByIds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetGroupMembersListByIds_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetGroupMembersListByIds(ctx, req.(*GetGroupMembersListByIdsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetGroupJoinRequestsListByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetGroupJoinRequestsListByIdsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetGroupJoinRequestsListByIds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetGroupJoinRequestsListByIds_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetGroupJoinRequestsListByIds(ctx, req.(*GetGroupJoinRequestsListByIdsReq))
}
return interceptor(ctx, in, info, handler)
}
func _Group_GetUserGroupRequestVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserGroupRequestVersionsReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GroupServer).GetUserGroupRequestVersions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Group_GetUserGroupRequestVersions_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GroupServer).GetUserGroupRequestVersions(ctx, req.(*GetUserGroupRequestVersionsReq))
}
return interceptor(ctx, in, info, handler)
}
// Group_ServiceDesc is the grpc.ServiceDesc for Group service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Group_ServiceDesc = grpc.ServiceDesc{
ServiceName: "group_rpc.group",
HandlerType: (*GroupServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetGroupMembers",
Handler: _Group_GetGroupMembers_Handler,
},
{
MethodName: "GetUserGroupMembers",
Handler: _Group_GetUserGroupMembers_Handler,
},
{
MethodName: "GetUserGroupIDs",
Handler: _Group_GetUserGroupIDs_Handler,
},
{
MethodName: "GetGroupsListByIds",
Handler: _Group_GetGroupsListByIds_Handler,
},
{
MethodName: "GetGroupMembersListByIds",
Handler: _Group_GetGroupMembersListByIds_Handler,
},
{
MethodName: "GetGroupJoinRequestsListByIds",
Handler: _Group_GetGroupJoinRequestsListByIds_Handler,
},
{
MethodName: "GetUserGroupRequestVersions",
Handler: _Group_GetUserGroupRequestVersions_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "group_rpc.proto",
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/types/group_rpc/group_rpc.pb.go | app/group/group_rpc/types/group_rpc/group_rpc.pb.go | // Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.36.6
// protoc v3.19.4
// source: group_rpc.proto
package group_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 GetGroupMembersReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` // 群组Id
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupMembersReq) Reset() {
*x = GetGroupMembersReq{}
mi := &file_group_rpc_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupMembersReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupMembersReq) ProtoMessage() {}
func (x *GetGroupMembersReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupMembersReq.ProtoReflect.Descriptor instead.
func (*GetGroupMembersReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{0}
}
func (x *GetGroupMembersReq) GetGroupID() string {
if x != nil {
return x.GroupID
}
return ""
}
type GroupMemberInfo struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` // 用户Id
Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"` // 用户名
Avatar string `protobuf:"bytes,3,opt,name=avatar,proto3" json:"avatar,omitempty"` // 用户头像
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GroupMemberInfo) Reset() {
*x = GroupMemberInfo{}
mi := &file_group_rpc_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GroupMemberInfo) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GroupMemberInfo) ProtoMessage() {}
func (x *GroupMemberInfo) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GroupMemberInfo.ProtoReflect.Descriptor instead.
func (*GroupMemberInfo) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{1}
}
func (x *GroupMemberInfo) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
func (x *GroupMemberInfo) GetUsername() string {
if x != nil {
return x.Username
}
return ""
}
func (x *GroupMemberInfo) GetAvatar() string {
if x != nil {
return x.Avatar
}
return ""
}
type GetGroupMembersRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Members []*GroupMemberInfo `protobuf:"bytes,1,rep,name=members,proto3" json:"members,omitempty"` // 成员信息列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupMembersRes) Reset() {
*x = GetGroupMembersRes{}
mi := &file_group_rpc_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupMembersRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupMembersRes) ProtoMessage() {}
func (x *GetGroupMembersRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupMembersRes.ProtoReflect.Descriptor instead.
func (*GetGroupMembersRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{2}
}
func (x *GetGroupMembersRes) GetMembers() []*GroupMemberInfo {
if x != nil {
return x.Members
}
return nil
}
// 获取用户群组中的其他成员ID列表
type GetUserGroupMembersReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` // 用户ID
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupMembersReq) Reset() {
*x = GetUserGroupMembersReq{}
mi := &file_group_rpc_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupMembersReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupMembersReq) ProtoMessage() {}
func (x *GetUserGroupMembersReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetUserGroupMembersReq.ProtoReflect.Descriptor instead.
func (*GetUserGroupMembersReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{3}
}
func (x *GetUserGroupMembersReq) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
type GetUserGroupMembersRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
MemberIDs []string `protobuf:"bytes,1,rep,name=memberIDs,proto3" json:"memberIDs,omitempty"` // 群成员ID列表（去重后的所有群友）
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupMembersRes) Reset() {
*x = GetUserGroupMembersRes{}
mi := &file_group_rpc_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupMembersRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupMembersRes) ProtoMessage() {}
func (x *GetUserGroupMembersRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetUserGroupMembersRes.ProtoReflect.Descriptor instead.
func (*GetUserGroupMembersRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{4}
}
func (x *GetUserGroupMembersRes) GetMemberIDs() []string {
if x != nil {
return x.MemberIDs
}
return nil
}
// 获取用户加入的群组ID列表
type GetUserGroupIDsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` // 用户ID
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupIDsReq) Reset() {
*x = GetUserGroupIDsReq{}
mi := &file_group_rpc_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupIDsReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupIDsReq) ProtoMessage() {}
func (x *GetUserGroupIDsReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetUserGroupIDsReq.ProtoReflect.Descriptor instead.
func (*GetUserGroupIDsReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{5}
}
func (x *GetUserGroupIDsReq) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
type GetUserGroupIDsRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupIDs []string `protobuf:"bytes,1,rep,name=groupIDs,proto3" json:"groupIDs,omitempty"` // 用户加入的群组ID列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupIDsRes) Reset() {
*x = GetUserGroupIDsRes{}
mi := &file_group_rpc_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupIDsRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupIDsRes) ProtoMessage() {}
func (x *GetUserGroupIDsRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetUserGroupIDsRes.ProtoReflect.Descriptor instead.
func (*GetUserGroupIDsRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{6}
}
func (x *GetUserGroupIDsRes) GetGroupIDs() []string {
if x != nil {
return x.GroupIDs
}
return nil
}
// 通过ID获取群组列表
type GetGroupsListByIdsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupIDs []string `protobuf:"bytes,1,rep,name=groupIDs,proto3" json:"groupIDs,omitempty"` // 群组ID列表
Since int64 `protobuf:"varint,2,opt,name=since,proto3" json:"since,omitempty"` // 时间戳，从此时间戳之后获取变更的记录
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupsListByIdsReq) Reset() {
*x = GetGroupsListByIdsReq{}
mi := &file_group_rpc_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupsListByIdsReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupsListByIdsReq) ProtoMessage() {}
func (x *GetGroupsListByIdsReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupsListByIdsReq.ProtoReflect.Descriptor instead.
func (*GetGroupsListByIdsReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{7}
}
func (x *GetGroupsListByIdsReq) GetGroupIDs() []string {
if x != nil {
return x.GroupIDs
}
return nil
}
func (x *GetGroupsListByIdsReq) GetSince() int64 {
if x != nil {
return x.Since
}
return 0
}
type GroupListById struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` // 群组ID
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` // 群组名称
Avatar string `protobuf:"bytes,3,opt,name=avatar,proto3" json:"avatar,omitempty"` // 群组头像
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` // 群组描述
Version int64 `protobuf:"varint,5,opt,name=version,proto3" json:"version,omitempty"` // 版本号
CreatedAt int64 `protobuf:"varint,6,opt,name=createdAt,proto3" json:"createdAt,omitempty"` // 创建时间
UpdatedAt int64 `protobuf:"varint,7,opt,name=updatedAt,proto3" json:"updatedAt,omitempty"` // 更新时间
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GroupListById) Reset() {
*x = GroupListById{}
mi := &file_group_rpc_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GroupListById) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GroupListById) ProtoMessage() {}
func (x *GroupListById) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GroupListById.ProtoReflect.Descriptor instead.
func (*GroupListById) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{8}
}
func (x *GroupListById) GetGroupID() string {
if x != nil {
return x.GroupID
}
return ""
}
func (x *GroupListById) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *GroupListById) GetAvatar() string {
if x != nil {
return x.Avatar
}
return ""
}
func (x *GroupListById) GetDescription() string {
if x != nil {
return x.Description
}
return ""
}
func (x *GroupListById) GetVersion() int64 {
if x != nil {
return x.Version
}
return 0
}
func (x *GroupListById) GetCreatedAt() int64 {
if x != nil {
return x.CreatedAt
}
return 0
}
func (x *GroupListById) GetUpdatedAt() int64 {
if x != nil {
return x.UpdatedAt
}
return 0
}
type GetGroupsListByIdsRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Groups []*GroupListById `protobuf:"bytes,1,rep,name=groups,proto3" json:"groups,omitempty"` // 群组列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupsListByIdsRes) Reset() {
*x = GetGroupsListByIdsRes{}
mi := &file_group_rpc_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupsListByIdsRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupsListByIdsRes) ProtoMessage() {}
func (x *GetGroupsListByIdsRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupsListByIdsRes.ProtoReflect.Descriptor instead.
func (*GetGroupsListByIdsRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{9}
}
func (x *GetGroupsListByIdsRes) GetGroups() []*GroupListById {
if x != nil {
return x.Groups
}
return nil
}
// 通过ID获取群成员列表
type GetGroupMembersListByIdsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupIDs []string `protobuf:"bytes,1,rep,name=groupIDs,proto3" json:"groupIDs,omitempty"` // 群组ID列表
Since int64 `protobuf:"varint,2,opt,name=since,proto3" json:"since,omitempty"` // 时间戳，从此时间戳之后获取变更的记录
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupMembersListByIdsReq) Reset() {
*x = GetGroupMembersListByIdsReq{}
mi := &file_group_rpc_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupMembersListByIdsReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupMembersListByIdsReq) ProtoMessage() {}
func (x *GetGroupMembersListByIdsReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupMembersListByIdsReq.ProtoReflect.Descriptor instead.
func (*GetGroupMembersListByIdsReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{10}
}
func (x *GetGroupMembersListByIdsReq) GetGroupIDs() []string {
if x != nil {
return x.GroupIDs
}
return nil
}
func (x *GetGroupMembersListByIdsReq) GetSince() int64 {
if x != nil {
return x.Since
}
return 0
}
type GroupMemberListById struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` // 群组ID
UserID string `protobuf:"bytes,2,opt,name=userID,proto3" json:"userID,omitempty"` // 用户ID
Role int32 `protobuf:"varint,3,opt,name=role,proto3" json:"role,omitempty"` // 成员角色 (1: 群主, 2: 管理员, 3: 普通成员)
JoinedAt int64 `protobuf:"varint,4,opt,name=joinedAt,proto3" json:"joinedAt,omitempty"` // 加入时间
Version int64 `protobuf:"varint,5,opt,name=version,proto3" json:"version,omitempty"` // 版本号
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GroupMemberListById) Reset() {
*x = GroupMemberListById{}
mi := &file_group_rpc_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GroupMemberListById) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GroupMemberListById) ProtoMessage() {}
func (x *GroupMemberListById) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GroupMemberListById.ProtoReflect.Descriptor instead.
func (*GroupMemberListById) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{11}
}
func (x *GroupMemberListById) GetGroupID() string {
if x != nil {
return x.GroupID
}
return ""
}
func (x *GroupMemberListById) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
func (x *GroupMemberListById) GetRole() int32 {
if x != nil {
return x.Role
}
return 0
}
func (x *GroupMemberListById) GetJoinedAt() int64 {
if x != nil {
return x.JoinedAt
}
return 0
}
func (x *GroupMemberListById) GetVersion() int64 {
if x != nil {
return x.Version
}
return 0
}
type GetGroupMembersListByIdsRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Members []*GroupMemberListById `protobuf:"bytes,1,rep,name=members,proto3" json:"members,omitempty"` // 群成员列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupMembersListByIdsRes) Reset() {
*x = GetGroupMembersListByIdsRes{}
mi := &file_group_rpc_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupMembersListByIdsRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupMembersListByIdsRes) ProtoMessage() {}
func (x *GetGroupMembersListByIdsRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupMembersListByIdsRes.ProtoReflect.Descriptor instead.
func (*GetGroupMembersListByIdsRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{12}
}
func (x *GetGroupMembersListByIdsRes) GetMembers() []*GroupMemberListById {
if x != nil {
return x.Members
}
return nil
}
// 通过ID获取入群申请列表
type GetGroupJoinRequestsListByIdsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupIDs []string `protobuf:"bytes,1,rep,name=groupIDs,proto3" json:"groupIDs,omitempty"` // 群组ID列表
Since int64 `protobuf:"varint,2,opt,name=since,proto3" json:"since,omitempty"` // 时间戳，从此时间戳之后获取变更的记录
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupJoinRequestsListByIdsReq) Reset() {
*x = GetGroupJoinRequestsListByIdsReq{}
mi := &file_group_rpc_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupJoinRequestsListByIdsReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupJoinRequestsListByIdsReq) ProtoMessage() {}
func (x *GetGroupJoinRequestsListByIdsReq) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupJoinRequestsListByIdsReq.ProtoReflect.Descriptor instead.
func (*GetGroupJoinRequestsListByIdsReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{13}
}
func (x *GetGroupJoinRequestsListByIdsReq) GetGroupIDs() []string {
if x != nil {
return x.GroupIDs
}
return nil
}
func (x *GetGroupJoinRequestsListByIdsReq) GetSince() int64 {
if x != nil {
return x.Since
}
return 0
}
type GroupJoinRequestListById struct {
state protoimpl.MessageState `protogen:"open.v1"`
RequestID string `protobuf:"bytes,1,opt,name=requestID,proto3" json:"requestID,omitempty"` // 申请ID
GroupID string `protobuf:"bytes,2,opt,name=groupID,proto3" json:"groupID,omitempty"` // 群组ID
UserID string `protobuf:"bytes,3,opt,name=userID,proto3" json:"userID,omitempty"` // 申请用户ID
Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` // 申请消息
Status int32 `protobuf:"varint,5,opt,name=status,proto3" json:"status,omitempty"` // 申请状态 (0: 待审核, 1: 已通过, 2: 已拒绝)
AppliedAt int64 `protobuf:"varint,6,opt,name=appliedAt,proto3" json:"appliedAt,omitempty"` // 申请时间
Version int64 `protobuf:"varint,7,opt,name=version,proto3" json:"version,omitempty"` // 版本号
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GroupJoinRequestListById) Reset() {
*x = GroupJoinRequestListById{}
mi := &file_group_rpc_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GroupJoinRequestListById) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GroupJoinRequestListById) ProtoMessage() {}
func (x *GroupJoinRequestListById) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GroupJoinRequestListById.ProtoReflect.Descriptor instead.
func (*GroupJoinRequestListById) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{14}
}
func (x *GroupJoinRequestListById) GetRequestID() string {
if x != nil {
return x.RequestID
}
return ""
}
func (x *GroupJoinRequestListById) GetGroupID() string {
if x != nil {
return x.GroupID
}
return ""
}
func (x *GroupJoinRequestListById) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
func (x *GroupJoinRequestListById) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *GroupJoinRequestListById) GetStatus() int32 {
if x != nil {
return x.Status
}
return 0
}
func (x *GroupJoinRequestListById) GetAppliedAt() int64 {
if x != nil {
return x.AppliedAt
}
return 0
}
func (x *GroupJoinRequestListById) GetVersion() int64 {
if x != nil {
return x.Version
}
return 0
}
type GetGroupJoinRequestsListByIdsRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Requests []*GroupJoinRequestListById `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"` // 入群申请列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetGroupJoinRequestsListByIdsRes) Reset() {
*x = GetGroupJoinRequestsListByIdsRes{}
mi := &file_group_rpc_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetGroupJoinRequestsListByIdsRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetGroupJoinRequestsListByIdsRes) ProtoMessage() {}
func (x *GetGroupJoinRequestsListByIdsRes) ProtoReflect() protoreflect.Message {
mi := &file_group_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 GetGroupJoinRequestsListByIdsRes.ProtoReflect.Descriptor instead.
func (*GetGroupJoinRequestsListByIdsRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{15}
}
func (x *GetGroupJoinRequestsListByIdsRes) GetRequests() []*GroupJoinRequestListById {
if x != nil {
return x.Requests
}
return nil
}
// 获取用户的群组申请（包括发出的申请和管理的申请）
type GetUserGroupRequestVersionsReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` // 用户ID
Since int64 `protobuf:"varint,2,opt,name=since,proto3" json:"since,omitempty"` // 时间戳，从此时间戳之后获取变更的记录
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupRequestVersionsReq) Reset() {
*x = GetUserGroupRequestVersionsReq{}
mi := &file_group_rpc_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupRequestVersionsReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupRequestVersionsReq) ProtoMessage() {}
func (x *GetUserGroupRequestVersionsReq) ProtoReflect() protoreflect.Message {
mi := &file_group_rpc_proto_msgTypes[16]
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 GetUserGroupRequestVersionsReq.ProtoReflect.Descriptor instead.
func (*GetUserGroupRequestVersionsReq) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{16}
}
func (x *GetUserGroupRequestVersionsReq) GetUserID() string {
if x != nil {
return x.UserID
}
return ""
}
func (x *GetUserGroupRequestVersionsReq) GetSince() int64 {
if x != nil {
return x.Since
}
return 0
}
type GetUserGroupRequestVersionsRes struct {
state protoimpl.MessageState `protogen:"open.v1"`
Versions []*GroupRequestVersionItem `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions,omitempty"` // 版本列表
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GetUserGroupRequestVersionsRes) Reset() {
*x = GetUserGroupRequestVersionsRes{}
mi := &file_group_rpc_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GetUserGroupRequestVersionsRes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetUserGroupRequestVersionsRes) ProtoMessage() {}
func (x *GetUserGroupRequestVersionsRes) ProtoReflect() protoreflect.Message {
mi := &file_group_rpc_proto_msgTypes[17]
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 GetUserGroupRequestVersionsRes.ProtoReflect.Descriptor instead.
func (*GetUserGroupRequestVersionsRes) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{17}
}
func (x *GetUserGroupRequestVersionsRes) GetVersions() []*GroupRequestVersionItem {
if x != nil {
return x.Versions
}
return nil
}
type GroupRequestVersionItem struct {
state protoimpl.MessageState `protogen:"open.v1"`
GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` // 群组ID
Version int64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` // 最新版本号
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GroupRequestVersionItem) Reset() {
*x = GroupRequestVersionItem{}
mi := &file_group_rpc_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GroupRequestVersionItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GroupRequestVersionItem) ProtoMessage() {}
func (x *GroupRequestVersionItem) ProtoReflect() protoreflect.Message {
mi := &file_group_rpc_proto_msgTypes[18]
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 GroupRequestVersionItem.ProtoReflect.Descriptor instead.
func (*GroupRequestVersionItem) Descriptor() ([]byte, []int) {
return file_group_rpc_proto_rawDescGZIP(), []int{18}
}
func (x *GroupRequestVersionItem) GetGroupID() string {
if x != nil {
return x.GroupID
}
return ""
}
func (x *GroupRequestVersionItem) GetVersion() int64 {
if x != nil {
return x.Version
}
return 0
}
var File_group_rpc_proto protoreflect.FileDescriptor
const file_group_rpc_proto_rawDesc = "" +
"\n" +
"\x0fgroup_rpc.proto\x12\tgroup_rpc\".\n" +
"\x12GetGroupMembersReq\x12\x18\n" +
"\agroupID\x18\x01 \x01(\tR\agroupID\"]\n" +
"\x0fGroupMemberInfo\x12\x16\n" +
"\x06userID\x18\x01 \x01(\tR\x06userID\x12\x1a\n" +
"\busername\x18\x02 \x01(\tR\busername\x12\x16\n" +
"\x06avatar\x18\x03 \x01(\tR\x06avatar\"J\n" +
"\x12GetGroupMembersRes\x124\n" +
"\amembers\x18\x01 \x03(\v2\x1a.group_rpc.GroupMemberInfoR\amembers\"0\n" +
"\x16GetUserGroupMembersReq\x12\x16\n" +
"\x06userID\x18\x01 \x01(\tR\x06userID\"6\n" +
"\x16GetUserGroupMembersRes\x12\x1c\n" +
"\tmemberIDs\x18\x01 \x03(\tR\tmemberIDs\",\n" +
"\x12GetUserGroupIDsReq\x12\x16\n" +
"\x06userID\x18\x01 \x01(\tR\x06userID\"0\n" +
"\x12GetUserGroupIDsRes\x12\x1a\n" +
"\bgroupIDs\x18\x01 \x03(\tR\bgroupIDs\"I\n" +
"\x15GetGroupsListByIdsReq\x12\x1a\n" +
"\bgroupIDs\x18\x01 \x03(\tR\bgroupIDs\x12\x14\n" +
"\x05since\x18\x02 \x01(\x03R\x05since\"\xcd\x01\n" +
"\rGroupListById\x12\x18\n" +
"\agroupID\x18\x01 \x01(\tR\agroupID\x12\x12\n" +
"\x04name\x18\x02 \x01(\tR\x04name\x12\x16\n" +
"\x06avatar\x18\x03 \x01(\tR\x06avatar\x12 \n" +
"\vdescription\x18\x04 \x01(\tR\vdescription\x12\x18\n" +
"\aversion\x18\x05 \x01(\x03R\aversion\x12\x1c\n" +
"\tcreatedAt\x18\x06 \x01(\x03R\tcreatedAt\x12\x1c\n" +
"\tupdatedAt\x18\a \x01(\x03R\tupdatedAt\"I\n" +
"\x15GetGroupsListByIdsRes\x120\n" +
"\x06groups\x18\x01 \x03(\v2\x18.group_rpc.GroupListByIdR\x06groups\"O\n" +
"\x1bGetGroupMembersListByIdsReq\x12\x1a\n" +
"\bgroupIDs\x18\x01 \x03(\tR\bgroupIDs\x12\x14\n" +
"\x05since\x18\x02 \x01(\x03R\x05since\"\x91\x01\n" +
"\x13GroupMemberListById\x12\x18\n" +
"\agroupID\x18\x01 \x01(\tR\agroupID\x12\x16\n" +
"\x06userID\x18\x02 \x01(\tR\x06userID\x12\x12\n" +
"\x04role\x18\x03 \x01(\x05R\x04role\x12\x1a\n" +
"\bjoinedAt\x18\x04 \x01(\x03R\bjoinedAt\x12\x18\n" +
"\aversion\x18\x05 \x01(\x03R\aversion\"W\n" +
"\x1bGetGroupMembersListByIdsRes\x128\n" +
"\amembers\x18\x01 \x03(\v2\x1e.group_rpc.GroupMemberListByIdR\amembers\"T\n" +
" GetGroupJoinRequestsListByIdsReq\x12\x1a\n" +
"\bgroupIDs\x18\x01 \x03(\tR\bgroupIDs\x12\x14\n" +
"\x05since\x18\x02 \x01(\x03R\x05since\"\xd4\x01\n" +
"\x18GroupJoinRequestListById\x12\x1c\n" +
"\trequestID\x18\x01 \x01(\tR\trequestID\x12\x18\n" +
"\agroupID\x18\x02 \x01(\tR\agroupID\x12\x16\n" +
"\x06userID\x18\x03 \x01(\tR\x06userID\x12\x18\n" +
"\amessage\x18\x04 \x01(\tR\amessage\x12\x16\n" +
"\x06status\x18\x05 \x01(\x05R\x06status\x12\x1c\n" +
"\tappliedAt\x18\x06 \x01(\x03R\tappliedAt\x12\x18\n" +
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | true |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/svc/servicecontext.go | app/group/group_rpc/internal/svc/servicecontext.go | package svc
import (
"beaver/app/group/group_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/group/group_rpc/internal/server/groupserver.go | app/group/group_rpc/internal/server/groupserver.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.3
// Source: group_rpc.proto
package server
import (
"context"
"beaver/app/group/group_rpc/internal/logic"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
)
type GroupServer struct {
svcCtx *svc.ServiceContext
group_rpc.UnimplementedGroupServer
}
func NewGroupServer(svcCtx *svc.ServiceContext) *GroupServer {
return &GroupServer{
svcCtx: svcCtx,
}
}
func (s *GroupServer) GetGroupMembers(ctx context.Context, in *group_rpc.GetGroupMembersReq) (*group_rpc.GetGroupMembersRes, error) {
l := logic.NewGetGroupMembersLogic(ctx, s.svcCtx)
return l.GetGroupMembers(in)
}
func (s *GroupServer) GetUserGroupMembers(ctx context.Context, in *group_rpc.GetUserGroupMembersReq) (*group_rpc.GetUserGroupMembersRes, error) {
l := logic.NewGetUserGroupMembersLogic(ctx, s.svcCtx)
return l.GetUserGroupMembers(in)
}
func (s *GroupServer) GetUserGroupIDs(ctx context.Context, in *group_rpc.GetUserGroupIDsReq) (*group_rpc.GetUserGroupIDsRes, error) {
l := logic.NewGetUserGroupIDsLogic(ctx, s.svcCtx)
return l.GetUserGroupIDs(in)
}
func (s *GroupServer) GetGroupsListByIds(ctx context.Context, in *group_rpc.GetGroupsListByIdsReq) (*group_rpc.GetGroupsListByIdsRes, error) {
l := logic.NewGetGroupsListByIdsLogic(ctx, s.svcCtx)
return l.GetGroupsListByIds(in)
}
func (s *GroupServer) GetGroupMembersListByIds(ctx context.Context, in *group_rpc.GetGroupMembersListByIdsReq) (*group_rpc.GetGroupMembersListByIdsRes, error) {
l := logic.NewGetGroupMembersListByIdsLogic(ctx, s.svcCtx)
return l.GetGroupMembersListByIds(in)
}
func (s *GroupServer) GetGroupJoinRequestsListByIds(ctx context.Context, in *group_rpc.GetGroupJoinRequestsListByIdsReq) (*group_rpc.GetGroupJoinRequestsListByIdsRes, error) {
l := logic.NewGetGroupJoinRequestsListByIdsLogic(ctx, s.svcCtx)
return l.GetGroupJoinRequestsListByIds(in)
}
func (s *GroupServer) GetUserGroupRequestVersions(ctx context.Context, in *group_rpc.GetUserGroupRequestVersionsReq) (*group_rpc.GetUserGroupRequestVersionsRes, error) {
l := logic.NewGetUserGroupRequestVersionsLogic(ctx, s.svcCtx)
return l.GetUserGroupRequestVersions(in)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/config/config.go | app/group/group_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
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getusergroupidslogic.go | app/group/group_rpc/internal/logic/getusergroupidslogic.go | package logic
import (
"context"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserGroupIDsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserGroupIDsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserGroupIDsLogic {
return &GetUserGroupIDsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetUserGroupIDsLogic) GetUserGroupIDs(in *group_rpc.GetUserGroupIDsReq) (*group_rpc.GetUserGroupIDsRes, error) {
// 获取用户加入的所有群组ID
var members []group_models.GroupMemberModel
err := l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("user_id = ? AND status = ?", in.UserID, 1).
Find(&members).Error
if err != nil {
l.Errorf("查询用户群组ID失败: %v", err)
return nil, err
}
// 提取群组ID列表
groupIDs := make([]string, 0, len(members))
for _, member := range members {
groupIDs = append(groupIDs, member.GroupID)
}
l.Infof("获取用户群组ID成功，用户ID: %s, 群组数: %d", in.UserID, len(groupIDs))
return &group_rpc.GetUserGroupIDsRes{
GroupIDs: groupIDs,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getgroupjoinrequestslistbyidslogic.go | app/group/group_rpc/internal/logic/getgroupjoinrequestslistbyidslogic.go | package logic
import (
"context"
"fmt"
"time"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupJoinRequestsListByIdsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetGroupJoinRequestsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupJoinRequestsListByIdsLogic {
return &GetGroupJoinRequestsListByIdsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetGroupJoinRequestsListByIdsLogic) GetGroupJoinRequestsListByIds(in *group_rpc.GetGroupJoinRequestsListByIdsReq) (*group_rpc.GetGroupJoinRequestsListByIdsRes, error) {
if len(in.GroupIDs) == 0 {
l.Errorf("群组ID列表为空")
return &group_rpc.GetGroupJoinRequestsListByIdsRes{Requests: []*group_rpc.GroupJoinRequestListById{}}, nil
}
// 查询指定群组ID列表中的入群申请
var requestsData []group_models.GroupJoinRequestModel
query := l.svcCtx.DB.Where("group_id IN (?)", in.GroupIDs)
// 注意：Since在这里表示客户端已知的最新版本号，用于增量同步
if in.Since > 0 {
query = query.Where("version > ?", in.Since)
}
err := query.Find(&requestsData).Error
if err != nil {
l.Errorf("查询入群申请失败: groupIDs=%v, since=%d, error=%v", in.GroupIDs, in.Since, err)
return nil, err
}
l.Infof("查询到 %d 个入群申请", len(requestsData))
// 转换为响应格式
var requests []*group_rpc.GroupJoinRequestListById
for _, request := range requestsData {
requests = append(requests, &group_rpc.GroupJoinRequestListById{
RequestID: fmt.Sprintf("%d", request.Id), // 使用主键Id作为RequestID
GroupID: request.GroupID,
UserID: request.ApplicantUserID,
Message: request.Message,
Status: int32(request.Status),
AppliedAt: time.Time(request.CreatedAt).UnixMilli(), // 使用CreatedAt作为申请时间
Version: request.Version,
})
}
return &group_rpc.GetGroupJoinRequestsListByIdsRes{Requests: requests}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getusergroupmemberslogic.go | app/group/group_rpc/internal/logic/getusergroupmemberslogic.go | package logic
import (
"context"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserGroupMembersLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserGroupMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserGroupMembersLogic {
return &GetUserGroupMembersLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetUserGroupMembersLogic) GetUserGroupMembers(in *group_rpc.GetUserGroupMembersReq) (*group_rpc.GetUserGroupMembersRes, error) {
// 获取用户加入的所有群组
var userMembers []group_models.GroupMemberModel
err := l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("user_id = ? AND status = ?", in.UserID, 1).
Find(&userMembers).Error
if err != nil {
l.Errorf("查询用户群组失败: %v", err)
return nil, err
}
// 提取用户加入的群组ID
groupIDs := make([]string, 0, len(userMembers))
for _, member := range userMembers {
groupIDs = append(groupIDs, member.GroupID)
}
if len(groupIDs) == 0 {
l.Infof("用户未加入任何群组，用户ID: %s", in.UserID)
return &group_rpc.GetUserGroupMembersRes{
MemberIDs: []string{},
}, nil
}
// 获取所有群组的成员列表
var allMembers []group_models.GroupMemberModel
err = l.svcCtx.DB.Model(&group_models.GroupMemberModel{}).
Where("group_id IN ? AND status = ?", groupIDs, 1).
Find(&allMembers).Error
if err != nil {
l.Errorf("查询群组成员失败: %v", err)
return nil, err
}
// 去重并排除自己
seen := make(map[string]bool)
var allMemberIDs []string
for _, member := range allMembers {
if member.UserID != in.UserID && !seen[member.UserID] {
seen[member.UserID] = true
allMemberIDs = append(allMemberIDs, member.UserID)
}
}
l.Infof("获取用户群成员成功，用户ID: %s, 群成员数: %d", in.UserID, len(allMemberIDs))
return &group_rpc.GetUserGroupMembersRes{
MemberIDs: allMemberIDs,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getusergrouprequestversionslogic.go | app/group/group_rpc/internal/logic/getusergrouprequestversionslogic.go | package logic
import (
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"context"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetUserGroupRequestVersionsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetUserGroupRequestVersionsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserGroupRequestVersionsLogic {
return &GetUserGroupRequestVersionsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
// 获取用户群组申请版本信息
func (l *GetUserGroupRequestVersionsLogic) GetUserGroupRequestVersions(in *group_rpc.GetUserGroupRequestVersionsReq) (*group_rpc.GetUserGroupRequestVersionsRes, error) {
userID := in.UserID
// 获取用户相关的所有群组申请版本
versions, err := l.getUserGroupRequestVersions(userID, in.Since)
if err != nil {
l.Errorf("获取用户群组申请版本失败: %v", err)
return nil, err
}
return &group_rpc.GetUserGroupRequestVersionsRes{
Versions: versions,
}, nil
}
// 获取用户相关的群组申请版本（包括我发出的和我管理的群）
func (l *GetUserGroupRequestVersionsLogic) getUserGroupRequestVersions(userID string, since int64) ([]*group_rpc.GroupRequestVersionItem, error) {
// 1. 获取我申请加入的群的申请版本
sentVersions, err := l.getSentRequestVersions(userID, since)
if err != nil {
return nil, err
}
// 2. 获取我管理的群收到的申请版本
managedVersions, err := l.getManagedRequestVersions(userID, since)
if err != nil {
return nil, err
}
// 3. 合并版本信息（相同群组取最新版本）
versionMap := make(map[string]int64)
// 添加我发出的申请版本
for _, version := range sentVersions {
if currentVersion, exists := versionMap[version.GroupID]; !exists || version.Version > currentVersion {
versionMap[version.GroupID] = version.Version
}
}
// 添加我管理的申请版本
for _, version := range managedVersions {
if currentVersion, exists := versionMap[version.GroupID]; !exists || version.Version > currentVersion {
versionMap[version.GroupID] = version.Version
}
}
// 转换为响应格式
var result []*group_rpc.GroupRequestVersionItem
for groupID, version := range versionMap {
result = append(result, &group_rpc.GroupRequestVersionItem{
GroupID: groupID,
Version: version,
})
}
return result, nil
}
// 获取用户作为申请者发出的申请版本 - 优化查询性能
func (l *GetUserGroupRequestVersionsLogic) getSentRequestVersions(userID string, since int64) ([]*group_rpc.GroupRequestVersionItem, error) {
var results []struct {
GroupID string
Version int64
}
query := l.svcCtx.DB.Model(&group_models.GroupJoinRequestModel{}).
Select("group_id, MAX(version) as version").
Where("applicant_user_id = ? AND status = 0", userID)
if since > 0 {
sinceTime := time.UnixMilli(since)
query = query.Where("created_at > ?", sinceTime)
}
query = query.Group("group_id")
err := query.Scan(&results).Error
if err != nil {
return nil, err
}
// 转换为响应格式
var response []*group_rpc.GroupRequestVersionItem
for _, item := range results {
response = append(response, &group_rpc.GroupRequestVersionItem{
GroupID: item.GroupID,
Version: item.Version,
})
}
return response, nil
}
// 获取用户作为管理者收到的申请版本 - 优化查询性能
func (l *GetUserGroupRequestVersionsLogic) getManagedRequestVersions(userID string, since int64) ([]*group_rpc.GroupRequestVersionItem, error) {
var results []struct {
GroupID string
Version int64
}
// 使用JOIN查询避免IN子查询，提高性能
query := l.svcCtx.DB.Table("group_join_request_models gjr").
Select("gjr.group_id, MAX(gjr.version) as version").
Joins("JOIN group_member_models gm ON gjr.group_id = gm.group_id").
Where("gm.user_id = ? AND gm.role IN (1, 2)", userID)
if since > 0 {
sinceTime := time.UnixMilli(since)
query = query.Where("gjr.created_at > ?", sinceTime)
}
query = query.Group("gjr.group_id")
err := query.Scan(&results).Error
if err != nil {
return nil, err
}
// 转换为响应格式
var response []*group_rpc.GroupRequestVersionItem
for _, item := range results {
response = append(response, &group_rpc.GroupRequestVersionItem{
GroupID: item.GroupID,
Version: item.Version,
})
}
return response, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getgroupmemberslogic.go | app/group/group_rpc/internal/logic/getgroupmemberslogic.go | package logic
import (
"context"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupMembersLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetGroupMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupMembersLogic {
return &GetGroupMembersLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetGroupMembersLogic) GetGroupMembers(in *group_rpc.GetGroupMembersReq) (*group_rpc.GetGroupMembersRes, error) {
// 1. 查询群组成员
var groupMembers []group_models.GroupMemberModel
err := l.svcCtx.DB.Where("group_id = ?", in.GroupID).Find(&groupMembers).Error
if err != nil {
logx.Error("查询群组成员失败:", err)
return nil, err
}
// 如果没有成员，返回空列表
if len(groupMembers) == 0 {
return &group_rpc.GetGroupMembersRes{
Members: []*group_rpc.GroupMemberInfo{},
}, nil
}
// 2. 收集所有成员的用户ID
var userIDs []string
for _, member := range groupMembers {
userIDs = append(userIDs, member.UserID)
}
// 3. 批量查询用户信息
var users []user_models.UserModel
err = l.svcCtx.DB.Where("user_id IN (?)", userIDs).Find(&users).Error
if err != nil {
logx.Error("查询用户信息失败:", err)
return nil, err
}
// 4. 构建用户信息映射
userMap := make(map[string]user_models.UserModel)
for _, user := range users {
userMap[user.UserID] = user
}
// 5. 构建返回结果
var members []*group_rpc.GroupMemberInfo
for _, member := range groupMembers {
if user, ok := userMap[member.UserID]; ok {
memberInfo := &group_rpc.GroupMemberInfo{
UserID: user.UserID,
Username: user.NickName,
Avatar: user.Avatar,
}
members = append(members, memberInfo)
}
}
return &group_rpc.GetGroupMembersRes{
Members: members,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getgroupslistbyidslogic.go | app/group/group_rpc/internal/logic/getgroupslistbyidslogic.go | package logic
import (
"context"
"time"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupsListByIdsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetGroupsListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupsListByIdsLogic {
return &GetGroupsListByIdsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetGroupsListByIdsLogic) GetGroupsListByIds(in *group_rpc.GetGroupsListByIdsReq) (*group_rpc.GetGroupsListByIdsRes, error) {
if len(in.GroupIDs) == 0 {
l.Errorf("群组ID列表为空")
return &group_rpc.GetGroupsListByIdsRes{Groups: []*group_rpc.GroupListById{}}, nil
}
// 查询指定群组ID列表中的群组资料 - 只查询需要的字段
var groupsData []group_models.GroupModel
query := l.svcCtx.DB.Select("group_id, title, avatar, notice, version, created_at, updated_at").
Where("group_id IN (?)", in.GroupIDs)
// 注意：Since在这里表示客户端已知的最新更新时间（时间戳），用于增量同步
// 如果Since > 0，只返回更新时间大于Since的群组（有变更的群组）
if in.Since > 0 {
// Since是毫秒时间戳，需要转换为time.Time进行比较
sinceTime := time.UnixMilli(in.Since)
query = query.Where("updated_at > ?", sinceTime)
}
err := query.Find(&groupsData).Error
if err != nil {
l.Errorf("查询群组资料失败: groupIDs=%v, since=%d, error=%v", in.GroupIDs, in.Since, err)
return nil, err
}
l.Infof("查询到 %d 个群组资料", len(groupsData))
// 转换为响应格式
var groups []*group_rpc.GroupListById
for _, group := range groupsData {
groups = append(groups, &group_rpc.GroupListById{
GroupID: group.GroupID,
Name: group.Title,
Avatar: group.Avatar,
Description: group.Notice,
Version: group.Version,
CreatedAt: time.Time(group.CreatedAt).UnixMilli(),
UpdatedAt: time.Time(group.UpdatedAt).UnixMilli(),
})
}
return &group_rpc.GetGroupsListByIdsRes{Groups: groups}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_rpc/internal/logic/getgroupmemberslistbyidslogic.go | app/group/group_rpc/internal/logic/getgroupmemberslistbyidslogic.go | package logic
import (
"context"
"beaver/app/group/group_models"
"beaver/app/group/group_rpc/internal/svc"
"beaver/app/group/group_rpc/types/group_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupMembersListByIdsLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewGetGroupMembersListByIdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupMembersListByIdsLogic {
return &GetGroupMembersListByIdsLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *GetGroupMembersListByIdsLogic) GetGroupMembersListByIds(in *group_rpc.GetGroupMembersListByIdsReq) (*group_rpc.GetGroupMembersListByIdsRes, error) {
if len(in.GroupIDs) == 0 {
l.Errorf("群组ID列表为空")
return &group_rpc.GetGroupMembersListByIdsRes{Members: []*group_rpc.GroupMemberListById{}}, nil
}
// 查询指定群组ID列表中的群成员
var membersData []group_models.GroupMemberModel
query := l.svcCtx.DB.Where("group_id IN (?)", in.GroupIDs)
// 注意：Since在这里表示客户端已知的最新版本号，用于增量同步
if in.Since > 0 {
query = query.Where("version > ?", in.Since)
}
err := query.Find(&membersData).Error
if err != nil {
l.Errorf("查询群成员失败: groupIDs=%v, since=%d, error=%v", in.GroupIDs, in.Since, err)
return nil, err
}
l.Infof("查询到 %d 个群成员", len(membersData))
// 转换为响应格式
var members []*group_rpc.GroupMemberListById
for _, member := range membersData {
members = append(members, &group_rpc.GroupMemberListById{
GroupID: member.GroupID,
UserID: member.UserID,
Role: int32(member.Role),
JoinedAt: member.JoinTime.UnixMilli(),
Version: member.Version,
})
}
return &group_rpc.GetGroupMembersListByIdsRes{Members: members}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_models/group_model.go | app/group/group_models/group_model.go | package group_models
import (
"beaver/common/models"
)
// 群组独立递增版本
type GroupModel struct {
models.Model
GroupID string `gorm:"size:64;unique;index" json:"groupId"`
Type int8 `gorm:"default:1" json:"type"` // 群类型：1正常群 2讨论组 ...
Title string `gorm:"size:32;index" json:"title"` // 群名
Avatar string `gorm:"size:256;default:a8ba5d19ea54a91aec17dec0ad5000e6.png" json:"avatar"` // 群头像文件名
CreatorID string `gorm:"size:64;index" json:"creatorId"` // 创建者ID
Notice string `gorm:"type:text" json:"notice"` // 当前公告内容
JoinType int8 `gorm:"not null;default:0" json:"joinType"` // 0自由加入 1需审批 2不可加入
Status int8 `gorm:"default:1" json:"status"` // 群状态：1正常 2冻结 3解散
Version int64 `gorm:"not null;default:0;index" json:"version"` // 群组版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_models/group_member_change_log_model.go | app/group/group_models/group_member_change_log_model.go | package group_models
import (
"beaver/common/models"
"time"
)
// 全局递增版本
// 群成员变更日志
type GroupMemberChangeLogModel struct {
models.Model
GroupID string `gorm:"size:64;index" json:"groupId"` // 群ID
UserID string `gorm:"size:64;index" json:"userId"` // 用户ID
ChangeType string `gorm:"size:32" json:"changeType"` // join/leave/kick/promote/demote
OperatedBy string `gorm:"size:64" json:"operatedBy"` // 操作者（群主/管理员）
ChangeTime time.Time `json:"changeTime"` // 变更时间
Version int64 `gorm:"not null;index" json:"version"` // 版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_models/group_join_request_model.go | app/group/group_models/group_join_request_model.go | package group_models
import (
"beaver/common/models"
"time"
)
// 按照群组独立递增版本
// GroupJoinRequestModel 入群申请表
type GroupJoinRequestModel struct {
models.Model
GroupID string `gorm:"size:64;index" json:"groupId"`
ApplicantUserID string `gorm:"size:64;index" json:"applicantUserId"`
Message string `gorm:"type:text" json:"message"`
Status int8 `gorm:"not null;default:0" json:"status"` // 0待审 1同意 2拒绝
HandledBy string `gorm:"size:64" json:"handledBy"`
HandledAt *time.Time `json:"handledAt"` // 处理时间
Version int64 `gorm:"not null;default:0;index" json:"version"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/group/group_models/group_member_model.go | app/group/group_models/group_member_model.go | package group_models
import (
"beaver/common/models"
"time"
)
// 群成员（版本号按群组独立递增）
type GroupMemberModel struct {
models.Model
GroupID string `gorm:"size:64;index" json:"groupId"`
UserID string `gorm:"size:64;index" json:"userId"`
Role int8 `json:"role"` // 1群主 2管理员 3普通成员
Status int8 `gorm:"default:1" json:"status"` // 1正常 2退出 3被踢
JoinTime time.Time `json:"joinTime"` // 加入时间
Version int64 `gorm:"not null;default:0;index" json:"version"` // 群组成员列表版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_models/admin_system_menu.go | app/backend/backend_models/admin_system_menu.go | package backend_models
import "beaver/common/models"
/**
* @description: 存储系统中的菜单信息
* 注意：菜单与角色的关联关系通过 AdminSystemAuthorityMenu 表维护
*/
type AdminSystemMenu struct {
models.Model
ParentID *uint `json:"parentId" gorm:"index;comment:父菜单ID"` // 父菜单ID（NULL表示顶级菜单）
Path string `json:"path" gorm:"size:128;index;comment:路由path"` // 路由path
Name string `json:"name" gorm:"size:64;unique;index;comment:路由name"` // 路由name（唯一，用于路由匹配）
Component string `json:"component" gorm:"size:256;comment:组件路径"` // 前端组件路径（如：views/user/index.vue）
Hidden bool `json:"hidden" gorm:"default:false;comment:是否在列表隐藏"` // 是否在列表隐藏
Sort int `json:"sort" gorm:"default:0;index;comment:排序标记"` // 排序标记
Title string `json:"title" gorm:"size:32;comment:菜单名"` // 菜单名
Icon string `json:"icon" gorm:"size:64;comment:菜单图标"` // 菜单图标
Permission string `json:"permission" gorm:"size:64;index;comment:权限标识"` // 权限标识（用于按钮级权限控制，如：user:create）
Status int8 `json:"status" gorm:"default:1;index;comment:状态"` // 1:启用 2:禁用
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_models/admin_system_authority.go | app/backend/backend_models/admin_system_authority.go | package backend_models
import (
"beaver/common/models"
)
/**
* @description: 存储系统中的角色信息
* 注意：微服务架构中不使用数据库外键约束，关联关系通过关联表维护
*/
type AdminSystemAuthority struct {
models.Model
Name string `json:"authorityName" gorm:"size:32;unique;index;comment:角色名"` // 角色名（唯一）
Description string `json:"description" gorm:"size:256;comment:角色描述"` // 角色描述
Status int8 `json:"status" gorm:"default:1;index;comment:状态"` // 1:启用 2:禁用
Sort int `json:"sort" gorm:"default:0;comment:排序"` // 排序
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_models/admin_system_authority_menu.go | app/backend/backend_models/admin_system_authority_menu.go | package backend_models
import "beaver/common/models"
/**
* @description: 表示角色-菜单关联关系数据模型
*/
type AdminSystemAuthorityMenu struct {
models.Model
AuthorityID uint `json:"authorityId" gorm:"comment:角色ID;index:idx_authority_menu,unique"`
MenuID uint `json:"menuId" gorm:"comment:菜单ID;index:idx_authority_menu,unique"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_models/admin_system_authority_user.go | app/backend/backend_models/admin_system_authority_user.go | package backend_models
import "beaver/common/models"
/**
* @description: 表示用户-角色关联关系数据模型
* 注意：微服务架构中不使用数据库外键约束，数据一致性由应用层保证
*/
type AdminSystemAuthorityUser struct {
models.Model
UserID string `json:"userId" gorm:"size:64;comment:用户ID;index:idx_user_authority,unique"`
AuthorityID uint `json:"authorityId" gorm:"comment:角色ID;index:idx_user_authority,unique"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_models/admin_user.go | app/backend/backend_models/admin_user.go | package backend_models
import (
"beaver/common/models"
)
/**
* @description: 管理员用户表
* 注意：使用软删除，Status 只保留 1:正常 2:禁用，删除使用 DeletedAt
*/
type AdminUser struct {
models.Model
UserID string `gorm:"column:user_id;size:64;uniqueIndex;comment:管理员ID"` // 管理员ID（唯一标识）
NickName string `gorm:"size:32;index;comment:昵称"` // 昵称
Password string `gorm:"size:128;comment:加密后的密码"` // 存储加密后的密码
Avatar string `gorm:"size:256;default:a9de5548bef8c10b92428fff61275c72.png;comment:头像"` // 头像文件ID
Abstract string `gorm:"size:128;comment:个性签名"` // 个性签名
Phone string `gorm:"size:11;unique;index;comment:手机号"` // 手机号（唯一）
Status int8 `gorm:"default:1;index;comment:状态"` // 1:正常 2:禁用（删除使用软删除）
LastLoginAt int64 `gorm:"index;comment:最后登录时间"` // 最后登录时间戳
CreatedBy string `gorm:"size:64;index;comment:创建者管理员ID"` // 创建者管理员ID
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/backend.go | app/backend/backend_admin/backend.go | package main
import (
"beaver/app/backend/backend_admin/internal/config"
"beaver/app/backend/backend_admin/internal/handler"
"beaver/app/backend/backend_admin/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/backend.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+"_admin", 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/backend/backend_admin/internal/svc/servicecontext.go | app/backend/backend_admin/internal/svc/servicecontext.go | package svc
import (
"beaver/app/backend/backend_admin/internal/config"
"beaver/app/dictionary/dictionary_rpc/dictionary"
"beaver/app/dictionary/dictionary_rpc/types/dictionary_rpc"
"beaver/app/file/file_rpc/file"
"beaver/app/file/file_rpc/types/file_rpc"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/app/user/user_rpc/user"
"beaver/common/zrpc_interceptor"
"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_rpc.UserClient
FileRpc file_rpc.FileClient
DictionaryRpc dictionary_rpc.DictionaryClient
}
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,
VersionGen: versionGen,
FileRpc: file.NewFile(zrpc.MustNewClient(c.FileRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
DictionaryRpc: dictionary.NewDictionary(zrpc.MustNewClient(c.DictionaryRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
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/backend/backend_admin/internal/types/types.go | app/backend/backend_admin/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type AddAppReq struct {
Name string `json:"name"` // 应用名称
Description string `json:"description,optional"` // 应用描述
}
type AddAppRes struct {
Id uint `json:"id"` // 创建的应用ID
AppID string `json:"appId"` // 系统生成的应用唯一标识
}
type AddArchitectureReq struct {
AppID string `json:"appId"` // 应用ID
PlatformID uint `json:"platformId"` // 平台ID：1=Windows, 2=MacOS, 3=Android
ArchID uint `json:"archId"` // 架构ID：1=WinX64, 2=WinArm64, 3=MacIntel, 4=MacApple, 5=Android
Description string `json:"description,optional"` // 描述
}
type AddArchitectureRes struct {
Id uint `json:"id"` // 创建的记录ID
}
type AddEmojiInfo struct {
Width int `json:"width"`
Height int `json:"height"`
}
type AddEmojiToPackageReq struct {
PackageId string `json:"packageId"`
FileKey string `json:"fileKey"`
Title string `json:"title"`
EmojiInfo AddEmojiInfo `json:"emojiInfo"`
AuthorID string `header:"Beaver-User-Id"`
}
type AddEmojiToPackageRes struct {
RelationId string `json:"relationId"`
}
type AddVersionReq struct {
ArchitectureID uint `json:"architectureId"` // 架构ID
Version string `json:"version"` // 版本号
FileKey string `json:"fileKey"` // 文件ID
Description string `json:"description,optional"` // 版本描述
ReleaseNotes string `json:"releaseNotes,optional"` // 更新日志
}
type AddVersionRes struct {
VersionID uint `json:"versionId"` // 创建的版本ID
}
type AuthenticationReq struct {
Token string `header:"Token,optional"`
ValidPath string `header:"ValidPath,optional"`
}
type AuthenticationRes struct {
UserID string `json:"userId"`
}
type BatchDeleteChatMessagesReq struct {
Ids []string `json:"ids"`
}
type BatchDeleteChatMessagesRes struct {
}
type BatchDeleteFileReq struct {
Ids []uint `json:"ids"`
}
type BatchDeleteFileRes struct {
}
type BatchDeleteFriendVerifyReq struct {
Ids []string `json:"ids"`
}
type BatchDeleteFriendVerifyRes struct {
}
type BatchDeleteFriendsReq struct {
Ids []string `json:"ids"`
}
type BatchDeleteFriendsRes struct {
}
type BatchDeleteUsersReq struct {
Ids []string `json:"ids"`
}
type BatchDeleteUsersRes struct {
}
type BatchRestoreChatMessagesReq struct {
Ids []string `json:"ids"`
}
type BatchRestoreChatMessagesRes struct {
}
type BatchUpdateUserStatusReq struct {
Ids []string `json:"ids"`
Status int `json:"status"`
}
type BatchUpdateUserStatusRes struct {
}
type ClearConversationReq struct {
ConversationID string `json:"conversationId"`
}
type ClearConversationRes struct {
}
type CreateAuthorityReq struct {
Name string `json:"name"`
Description string `json:"description"`
}
type CreateAuthorityRes struct {
}
type CreateBucketReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
Name string `json:"name"` // Bucket名称
Description string `json:"description"` // Bucket描述
}
type CreateBucketRes struct {
BucketId string `json:"bucketId"` // 创建的Bucket ID
}
type CreateEmojiPackageReq struct {
Title string `json:"title"`
CoverFile *string `json:"coverFile,optional"`
UserID string `header:"Beaver-User-Id"`
Description string `json:"description"`
Type string `json:"type"`
}
type CreateEmojiPackageRes struct {
PackageId string `json:"packageId"`
}
type CreateEmojiReq struct {
FileKey string `json:"fileKey"`
Title string `json:"title"`
EmojiInfo EmojiInfo `json:"emojiInfo"`
AuthorID string `header:"Beaver-User-Id"`
}
type CreateEmojiRes struct {
EmojiId string `json:"emojiId"`
}
type CreateMenuReq struct {
ParentId uint `json:"parentId"`
Path string `json:"path"`
Name string `json:"name"`
Hidden bool `json:"hidden"`
Sort int `json:"sort"`
Title string `json:"title"`
Icon string `json:"icon"`
UserID string `header:"Beaver-User-Id"`
}
type CreateMenuRes struct {
}
type CreateUserReq struct {
NickName string `json:"nickName"`
Password string `json:"password"`
Email string `json:"email"`
Abstract string `json:"abstract,optional"`
UserID string `header:"Beaver-User-Id"`
}
type CreateUserRes struct {
Id string `json:"id"`
}
type DeleteBucketReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
BucketId string `json:"bucketId"` // Bucket ID
}
type DeleteBucketRes struct {
}
type DeleteChatMessageReq struct {
MessageID string `path:"id"`
}
type DeleteChatMessageRes struct {
}
type DeleteEmojiPackageReq struct {
PackageId string `json:"packageId"`
}
type DeleteEmojiPackageRes struct {
}
type DeleteEmojiReq struct {
EmojiId string `path:"emojiId"`
}
type DeleteEmojiRes struct {
}
type DeleteFeedbackReq struct {
Id uint `path:"id"`
}
type DeleteFeedbackRes struct {
}
type DeleteFileReq struct {
Id uint `path:"id"`
}
type DeleteFileRes struct {
}
type DeleteFriendReq struct {
FriendID string `path:"id"`
}
type DeleteFriendRes struct {
}
type DeleteFriendVerifyReq struct {
VerifyID string `json:"verifyId"`
}
type DeleteFriendVerifyRes struct {
}
type DeleteGroupReq struct {
Id uint `path:"id"`
}
type DeleteGroupRes struct {
}
type DeleteMenuReq struct {
Id uint `json:"id"`
UserID string `header:"Beaver-User-Id"`
}
type DeleteMenuRes struct {
}
type DeleteMessagesByTypeReq struct {
ConversationID string `json:"conversationId,optional"`
MsgType int `json:"msgType"`
StartTime string `json:"startTime,optional"`
EndTime string `json:"endTime,optional"`
}
type DeleteMessagesByTypeRes struct {
DeletedCount int64 `json:"deletedCount"`
}
type DeleteMomentCommentReq struct {
CommentId string `path:"commentId"`
}
type DeleteMomentCommentRes struct {
}
type DeleteMomentReq struct {
MomentId string `path:"momentId"`
}
type DeleteMomentRes struct {
}
type DeleteUserReq struct {
UserID string `path:"id"`
}
type DeleteUserRes struct {
}
type EmojiInfo struct {
Width int `json:"width"`
Height int `json:"height"`
}
type FileUploadLocalReq struct {
UserID string `header:"Beaver-User-Id"`
Source string `form:"source"` // 文件来源：qiniu 或 local
}
type FileUploadLocalRes struct {
FileKey string `json:"fileKey"`
OriginalName string `json:"originalName"`
}
type FileUploadQiniuReq struct {
UserID string `header:"Beaver-User-Id"`
Source string `form:"source,optional"` // 文件来源：qiniu 或 local
}
type FileUploadQiniuRes struct {
FileKey string `json:"fileKey"`
OriginalName string `json:"originalName"`
}
type GetAppVersionsItem struct {
ArchitectureID uint `json:"architectureId"` // 架构ID
ArchID uint `json:"archId"` // 架构类型
Description string `json:"description"` // 架构描述
Versions []GetAppVersionsVersionItem `json:"versions"` // 该架构下的版本列表
}
type GetAppVersionsReq struct {
AppID string `form:"appId"` // 应用ID
Page int `form:"page,optional"` // 页码
PageSize int `form:"pageSize,optional"` // 每页数量
}
type GetAppVersionsRes struct {
Total int64 `json:"total"` // 总架构数
Architectures []GetAppVersionsItem `json:"architectures"` // 按架构分组的版本信息
}
type GetAppVersionsVersionItem struct {
VersionID uint `json:"versionId"` // 版本ID
Version string `json:"version"` // 版本号
}
type GetAppsItem struct {
Id uint `json:"id"` // 应用ID
AppID string `json:"appId"` // 应用唯一标识
Name string `json:"name"` // 应用名称
Description string `json:"description"` // 应用描述
IsActive bool `json:"isActive"` // 是否活跃
CreatedAt string `json:"createdAt"` // 创建时间
UpdatedAt string `json:"updatedAt"` // 更新时间
}
type GetAppsReq struct {
Page int `form:"page,optional"` // 页码
PageSize int `form:"pageSize,optional"` // 每页数量
IsActive bool `form:"isActive,optional"` // 是否仅显示活跃应用
}
type GetAppsRes struct {
Total int64 `json:"total"` // 总数
Apps []GetAppsItem `json:"apps"` // 应用列表
}
type GetArchitecturesItem struct {
Id uint `json:"id"` // 记录ID
AppID string `json:"appId"` // 应用ID
AppName string `json:"appName"` // 应用名称
PlatformID uint `json:"platformId"` // 平台ID：1=Windows, 2=MacOS, 3=Android
ArchID uint `json:"archId"` // 架构ID：1=WinX64, 2=WinArm64, 3=MacIntel, 4=MacApple, 5=Android
Description string `json:"description"` // 描述
IsActive bool `json:"isActive"` // 是否启用
CreatedAt string `json:"createdAt"` // 创建时间
UpdatedAt string `json:"updatedAt"` // 更新时间
}
type GetArchitecturesReq struct {
AppID string `form:"appId,optional"` // 应用ID
Page int `form:"page,optional"` // 页码
PageSize int `form:"pageSize,optional"` // 每页数量
IsActive bool `form:"isActive,optional"` // 是否仅显示活跃架构
}
type GetArchitecturesRes struct {
Total int64 `json:"total"` // 总数
Architectures []GetArchitecturesItem `json:"architectures"` // 架构列表
}
type GetBucketListItem struct {
BucketId string `json:"bucketId"` // Bucket ID
Name string `json:"name"` // Bucket名称
Description string `json:"description"` // Bucket描述
CreateUser string `json:"createUser"` // 创建者
IsActive bool `json:"isActive"` // 是否激活
CreatedAt string `json:"createdAt"` // 创建时间
UpdatedAt string `json:"updatedAt"` // 更新时间
}
type GetBucketListReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
Page int `form:"page,default=1"` // 页码
PageSize int `form:"pageSize,default=10"` // 每页大小
Keyword string `form:"keyword,optional"` // 关键词搜索(名称或描述)
IsActive *bool `form:"isActive,optional"` // 是否激活
}
type GetBucketListRes struct {
List []GetBucketListItem `json:"list"` // Bucket列表
Total int64 `json:"total"` // 总数
}
type GetChatMessageDetailReq struct {
MessageID string `path:"id"`
}
type GetChatMessageDetailRes struct {
Id string `json:"id"`
MessageID string `json:"messageId"`
ConversationID string `json:"conversationId"`
SendUserID string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
SendUserFileName string `json:"sendUserFileName"`
MsgType int `json:"msgType"`
MsgPreview string `json:"msgPreview"`
MsgContent string `json:"msgContent"`
IsDeleted bool `json:"isDeleted"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetChatMessageListItem struct {
Id string `json:"id"`
MessageID string `json:"messageId"`
ConversationID string `json:"conversationId"`
SendUserID string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
MsgType int `json:"msgType"`
MsgPreview string `json:"msgPreview"`
IsDeleted bool `json:"isDeleted"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetChatMessageListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
ConversationID string `form:"conversationId,optional"` // 按会话ID筛选
SendUserID string `form:"sendUserId,optional"` // 按发送者ID筛选
MsgType int `form:"msgType,optional"` // 按消息类型筛选
IsDeleted bool `form:"isDeleted,optional"` // 按删除状态筛选
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetChatMessageListRes struct {
List []GetChatMessageListItem `json:"list"`
Total int64 `json:"total"`
}
type GetCityStrategiesItem struct {
Id uint `json:"id"` // 策略ID
AppID string `json:"appId"` // 应用ID
CityID string `json:"cityId"` // 城市代码
Strategy []GetCityStrategiesStrategyItem `json:"strategy"` // 城市策略配置
IsActive bool `json:"isActive"` // 是否启用
CreatedAt string `json:"createdAt"` // 创建时间
UpdatedAt string `json:"updatedAt"` // 更新时间
}
type GetCityStrategiesReq struct {
AppID string `form:"appId,optional"` // 应用ID
IsActive bool `form:"isActive,optional"` // 是否仅查询活跃策略
Page int `form:"page,optional"` // 页码
PageSize int `form:"pageSize,optional"` // 每页数量
}
type GetCityStrategiesRes struct {
Total int64 `json:"total"` // 总数
Strategies []GetCityStrategiesItem `json:"strategies"` // 策略列表
}
type GetCityStrategiesStrategyItem struct {
ArchitectureID uint `json:"architectureId"` // 架构ID
VersionID uint `json:"versionId"` // 版本ID
Version string `json:"version"` // 版本号
ForceUpdate bool `json:"forceUpdate"` // 是否强制更新
IsActive bool `json:"isActive"` // 是否启用
}
type GetEmojiCollectListItem struct {
CollectId string `json:"collectId"`
UserID string `json:"userId"`
EmojiId string `json:"emojiId"`
EmojiTitle string `json:"emojiTitle"`
EmojiFileKey string `json:"emojiFileKey"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetEmojiCollectListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
UserID string `form:"userId,optional"` // 按用户ID筛选
EmojiID string `form:"emojiId,optional"` // 按表情图片ID筛选
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetEmojiCollectListRes struct {
List []GetEmojiCollectListItem `json:"list"`
Total int64 `json:"total"`
}
type GetEmojiListItem struct {
EmojiId string `json:"emojiId"`
FileKey string `json:"fileKey"`
Title string `json:"title"`
AuthorID string `json:"authorId"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetEmojiListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
AuthorID string `form:"authorId,optional"` // 按创建者ID筛选
Title string `form:"title,optional"` // 按表情图片名称搜索
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetEmojiListRes struct {
List []GetEmojiListItem `json:"list"`
Total int64 `json:"total"`
}
type GetEmojiPackageEmojisItem struct {
EmojiId string `json:"emojiId"`
FileKey string `json:"fileKey"`
Title string `json:"title"`
AuthorID string `json:"authorId"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetEmojiPackageEmojisReq struct {
PackageId string `form:"packageId"`
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=50"`
}
type GetEmojiPackageEmojisRes struct {
List []GetEmojiPackageEmojisItem `json:"list"`
Total int64 `json:"total"`
}
type GetEmojiPackageListItem struct {
PackageId string `json:"packageId"`
Title string `json:"title"`
CoverFile string `json:"coverFile"`
UserID string `json:"userId"`
Description string `json:"description"`
Type string `json:"type"`
Status int `json:"status"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetEmojiPackageListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
UserID string `form:"userId,optional"` // 按创建者ID筛选
Type string `form:"type,optional"` // 按类型筛选
Status int `form:"status,optional"` // 按状态筛选
Title string `form:"title,optional"` // 按表情包集合名称搜索
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetEmojiPackageListRes struct {
List []GetEmojiPackageListItem `json:"list"`
Total int64 `json:"total"`
}
type GetEventListItem struct {
Id uint `json:"id"` // 事件ID
EventName string `json:"eventName"` // 事件名称
Action string `json:"action"` // 操作
UserID string `json:"userId"` // 用户ID
BucketID string `json:"bucketId"` // Bucket Id
BucketName string `json:"bucketName"` // Bucket名称
Platform string `json:"platform"` // 平台
DeviceID string `json:"deviceId"` // 设备ID
Data string `json:"data"` // 事件数据(JSON格式)
Timestamp int64 `json:"timestamp"` // 事件时间戳(毫秒)
CreatedAt string `json:"createdAt"` // 创建时间
}
type GetEventListReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
Page int `form:"page,default=1"` // 页码
PageSize int `form:"pageSize,default=20"` // 每页大小
BucketID string `form:"bucketId,optional"` // Bucket ID筛选
EventName string `form:"eventName,optional"` // 事件名称筛选
Action string `form:"action,optional"` // 操作筛选
UserFilter string `form:"userFilter,optional"` // 用户ID筛选
StartTime int64 `form:"startTime,optional"` // 开始时间戳(毫秒)
EndTime int64 `form:"endTime,optional"` // 结束时间戳(毫秒)
Platform string `form:"platform,optional"` // 平台筛选
}
type GetEventListRes struct {
List []GetEventListItem `json:"list"` // 事件列表
Total int64 `json:"total"` // 总数
}
type GetFeedbackDetailReq struct {
Id uint `path:"id"`
}
type GetFeedbackDetailRes struct {
Id uint `json:"id"`
UserId string `json:"userId"`
Content string `json:"content"`
Type int `json:"type"`
Status int `json:"status"`
FileNames []string `json:"fileNames"`
HandlerId int64 `json:"handlerId"`
HandleTime string `json:"handleTime"`
HandleResult string `json:"handleResult"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetFeedbackListItem struct {
Id uint `json:"id"`
UserId string `json:"userId"`
Content string `json:"content"`
Type int `json:"type"`
Status int `json:"status"`
FileNames []string `json:"fileNames"`
HandlerId int64 `json:"handlerId"`
HandleTime string `json:"handleTime"`
HandleResult string `json:"handleResult"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetFeedbackListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
Status int `form:"status,optional"` // 反馈状态筛选
Type int `form:"type,optional"` // 反馈类型筛选
UserID string `form:"userId,optional"` // 用户ID筛选
Keywords string `form:"keywords,optional"` // 关键词搜索
}
type GetFeedbackListRes struct {
List []GetFeedbackListItem `json:"list"`
Total int64 `json:"total"`
}
type GetFileDetailReq struct {
Id uint `path:"id"`
}
type GetFileDetailRes struct {
Id uint `json:"id"`
FileName string `json:"fileName"`
OriginalName string `json:"originalName"`
Size int64 `json:"size"`
Path string `json:"path"`
Md5 string `json:"md5"`
Type string `json:"type"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetFileListItem struct {
Id uint `json:"id"`
FileName string `json:"fileName"`
OriginalName string `json:"originalName"`
Size int64 `json:"size"`
Path string `json:"path"`
Md5 string `json:"md5"`
Type string `json:"type"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetFileListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
Type string `form:"type,optional"` // 文件类型筛选
Keywords string `form:"keywords,optional"` // 文件名关键词搜索
}
type GetFileListRes struct {
List []GetFileListItem `json:"list"`
Total int64 `json:"total"`
}
type GetFriendDetailReq struct {
FriendID string `path:"id"`
}
type GetFriendDetailRes struct {
Id string `json:"id"`
SendUserId string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
SendUserFileName string `json:"sendUserFileName"`
RevUserId string `json:"revUserId"`
RevUserName string `json:"revUserName"`
RevUserFileName string `json:"revUserFileName"`
SendUserNotice string `json:"sendUserNotice"`
RevUserNotice string `json:"revUserNotice"`
IsDeleted bool `json:"isDeleted"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetFriendListItem struct {
Id string `json:"id"`
SendUserId string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
RevUserId string `json:"revUserId"`
RevUserName string `json:"revUserName"`
SendUserNotice string `json:"sendUserNotice"`
RevUserNotice string `json:"revUserNotice"`
IsDeleted bool `json:"isDeleted"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetFriendListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
UserID string `form:"userId,optional"` // 按用户ID筛选
FriendID string `form:"friendId,optional"` // 按好友ID筛选
IsDeleted bool `form:"isDeleted,optional"` // 按删除状态筛选
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetFriendListRes struct {
List []GetFriendListItem `json:"list"`
Total int64 `json:"total"`
}
type GetFriendVerifyDetailReq struct {
VerifyID string `form:"verifyId"`
}
type GetFriendVerifyDetailRes struct {
Id string `json:"id"`
SendUserId string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
SendUserFileName string `json:"sendUserFileName"`
RevUserId string `json:"revUserId"`
RevUserName string `json:"revUserName"`
RevUserFileName string `json:"revUserFileName"`
SendStatus int `json:"sendStatus"`
RevStatus int `json:"revStatus"`
Message string `json:"message"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetFriendVerifyListItem struct {
Id string `json:"id"`
SendUserId string `json:"sendUserId"`
SendUserName string `json:"sendUserName"`
RevUserId string `json:"revUserId"`
RevUserName string `json:"revUserName"`
SendStatus int `json:"sendStatus"`
RevStatus int `json:"revStatus"`
Message string `json:"message"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetFriendVerifyListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
SendUserId string `form:"sendUserId,optional"`
RevUserId string `form:"revUserId,optional"`
SendStatus int `form:"sendStatus,optional"` // 0:未处理 1:已通过 2:已拒绝 3:忽略 4:删除
RevStatus int `form:"revStatus,optional"`
StartTime string `form:"startTime,optional"`
EndTime string `form:"endTime,optional"`
}
type GetFriendVerifyListRes struct {
List []GetFriendVerifyListItem `json:"list"`
Total int64 `json:"total"`
}
type GetGroupDetailReq struct {
Id uint `path:"id"`
}
type GetGroupDetailRes struct {
Id uint `json:"id"`
GroupId string `json:"groupId"`
Type int `json:"type"`
Title string `json:"title"`
FileName string `json:"fileName"`
CreatorId string `json:"creatorId"`
Notice string `json:"notice"`
Status int `json:"status"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetGroupListItem struct {
Id uint `json:"id"`
GroupId string `json:"groupId"`
Type int `json:"type"`
Title string `json:"title"`
FileName string `json:"fileName"`
CreatorId string `json:"creatorId"`
Notice string `json:"notice"`
Status int `json:"status"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetGroupListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
Status int `form:"status,optional"` // 群状态筛选
Type int `form:"type,optional"` // 群类型筛选
Keywords string `form:"keywords,optional"` // 群名关键词搜索
}
type GetGroupListRes struct {
List []GetGroupListItem `json:"list"`
Total int64 `json:"total"`
}
type GetGroupMemberListItem struct {
Id uint `json:"id"`
GroupId string `json:"groupId"`
UserId string `json:"userId"`
MemberNickname string `json:"memberNickname"`
Role int `json:"role"`
ProhibitionTime int `json:"prohibitionTime"`
InviterId string `json:"inviterId"`
Status int `json:"status"`
NotifyLevel int `json:"notifyLevel"`
DisplayName string `json:"displayName"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetGroupMemberListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
GroupId string `form:"groupId"`
Role int `form:"role,optional"` // 成员角色筛选
Status int `form:"status,optional"` // 成员状态筛选
}
type GetGroupMemberListRes struct {
List []GetGroupMemberListItem `json:"list"`
Total int64 `json:"total"`
}
type GetMenuListItem struct {
Id uint `json:"id"`
ParentId uint `json:"parentId"`
Path string `json:"path"`
Name string `json:"name"`
Hidden bool `json:"hidden"`
Sort int `json:"sort"`
Title string `json:"title"`
Icon string `json:"icon"`
}
type GetMenuListReq struct {
UserID string `header:"Beaver-User-Id"`
}
type GetMenuListRes struct {
List []GetMenuListItem `json:"list"`
}
type GetMomentCommentListItem struct {
CommentId string `json:"commentId"`
MomentId string `json:"momentId"`
UserId string `json:"userId"`
Content string `json:"content"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetMomentCommentListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
MomentId string `form:"momentId"`
}
type GetMomentCommentListRes struct {
List []GetMomentCommentListItem `json:"list"`
Total int64 `json:"total"`
}
type GetMomentDetailFileInfo struct {
FileName string `json:"fileName"`
}
type GetMomentDetailReq struct {
MomentId string `path:"momentId"`
}
type GetMomentDetailRes struct {
MomentId string `json:"momentId"`
UserId string `json:"userId"`
Content string `json:"content"`
Files []GetMomentDetailFileInfo `json:"files"`
IsDeleted bool `json:"isDeleted"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetMomentListFileInfo struct {
FileName string `json:"fileName"`
}
type GetMomentListItem struct {
MomentId string `json:"momentId"`
UserId string `json:"userId"`
Content string `json:"content"`
Files []GetMomentListFileInfo `json:"files"`
IsDeleted bool `json:"isDeleted"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type GetMomentListReq struct {
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
UserId string `form:"userId,optional"` // 用户ID筛选
Keywords string `form:"keywords,optional"` // 内容关键词搜索
}
type GetMomentListRes struct {
List []GetMomentListItem `json:"list"`
Total int64 `json:"total"`
}
type GetQiniuUploadTokenReq struct {
}
type GetQiniuUploadTokenRes struct {
UploadToken string `json:"uploadToken"` // 上传token
ExpiresIn int64 `json:"expiresIn"` // token过期时间 (秒)
}
type GetUserDetailReq struct {
UserID string `path:"id"`
}
type GetUserDetailRes struct {
Id string `json:"id"`
NickName string `json:"nickName"`
FileName string `json:"fileName"`
Email string `json:"email"`
Abstract string `json:"abstract"`
Status int `json:"status"`
Source int `json:"source"`
LastLoginIP string `json:"lastLoginIp"`
CreateTime string `json:"createTime"`
UpdateTime string `json:"updateTime"`
}
type GetUserListReq struct {
Page int `form:"page,default=1"`
PageSize int `form:"pageSize,default=10"`
Email string `form:"email, optional"`
Status int `form:"status,optional"`
Source int `form:"source,optional"`
}
type GetUserListRes struct {
List []UserInfo `json:"list"`
Total int64 `json:"total"`
}
type GetVersionListItem struct {
VersionID uint `json:"versionId"` // 版本ID
ArchitectureID uint `json:"architectureId"` // 架构ID
Version string `json:"version"` // 版本号
FileKey string `json:"fileKey"` // 文件ID
Description string `json:"description"` // 版本描述
ReleaseNotes string `json:"releaseNotes"` // 更新日志
ReleaseDate string `json:"releaseDate"` // 发布时间
CreatedAt string `json:"createdAt"` // 创建时间
UpdatedAt string `json:"updatedAt"` // 更新时间
}
type GetVersionListReq struct {
ArchitectureID uint `form:"architectureId"` // 架构ID
AppID string `form:"appId,optional"` // 应用ID
Page int `form:"page,optional"` // 页码
PageSize int `form:"pageSize,optional"` // 每页数量
}
type GetVersionListRes struct {
Total int64 `json:"total"` // 总数
Versions []GetVersionListItem `json:"versions"` // 版本列表
}
type HandleFeedbackReq struct {
Id uint `path:"id"`
Status int `json:"status"` // 处理状态
HandleResult string `json:"handleResult"` // 处理结果
UserID string `header:"Beaver-User-Id"`
}
type HandleFeedbackRes struct {
}
type LoginReq struct {
Phone string `json:"phone"`
Password string `json:"password"`
}
type LoginRes struct {
Token string `json:"token"`
UserID string `json:"userId"`
}
type MuteGroupMemberReq struct {
Id uint `path:"id"`
ProhibitionTime int `json:"prohibitionTime"` // 禁言时长(分钟)，0表示解除禁言
}
type MuteGroupMemberRes struct {
}
type PreviewReq struct {
FileName string `path:"fileName"`
}
type PreviewRes struct {
}
type QueryLogsItem struct {
Id uint `json:"id"` // 日志ID
Level string `json:"level"` // 日志级别
Data string `json:"data"` // 日志数据
UserID string `json:"userId"` // 用户ID
BucketID string `json:"bucketId"` // Bucket Id
BucketName string `json:"bucketName"` // Bucket名称
Timestamp int64 `json:"timestamp"` // 时间戳(毫秒)
CreatedAt string `json:"createdAt"` // 创建时间
}
type QueryLogsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
BucketID string `form:"bucketId"` // Bucket Id
Level string `form:"level,optional"` // 日志级别(可选)
StartTime int64 `form:"startTime"` // 开始时间戳(毫秒)
EndTime int64 `form:"endTime"` // 结束时间戳(毫秒)
Keyword string `form:"keyword,optional"` // 关键词(可选)
UserFilter string `form:"userFilter,optional"` // 用户ID筛选(可选)
Page int `form:"page,default=1"` // 页码
PageSize int `form:"pageSize,default=20"` // 每页大小
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | true |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/config/config.go | app/backend/backend_admin/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
}
WhiteList []string //白名单
BlackList []string //黑名单
File struct {
WhiteList []string
BlackList []string
MaxSize map[string]float64 // 文件大小限制
}
UserRpc zrpc.RpcClientConf
Auth struct {
AccessSecret string
AccessExpire int
}
Local struct {
UploadDir string // 本地文件上传目录
}
Qiniu struct {
AK string
SK string
Bucket string
Domain string
ExpireTime int64 // 签名URL有效期, 单位：秒
}
FileRpc zrpc.RpcClientConf
DictionaryRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/handler/routes.go | app/backend/backend_admin/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
auth "beaver/app/backend/backend_admin/internal/handler/auth"
chat "beaver/app/backend/backend_admin/internal/handler/chat"
emoji "beaver/app/backend/backend_admin/internal/handler/emoji"
feedback "beaver/app/backend/backend_admin/internal/handler/feedback"
file "beaver/app/backend/backend_admin/internal/handler/file"
friend "beaver/app/backend/backend_admin/internal/handler/friend"
group "beaver/app/backend/backend_admin/internal/handler/group"
moment "beaver/app/backend/backend_admin/internal/handler/moment"
system "beaver/app/backend/backend_admin/internal/handler/system"
track "beaver/app/backend/backend_admin/internal/handler/track"
update "beaver/app/backend/backend_admin/internal/handler/update"
user "beaver/app/backend/backend_admin/internal/handler/user"
"beaver/app/backend/backend_admin/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 用户认证
Method: http.MethodGet,
Path: "/admin/auth/authentication",
Handler: auth.AuthenticationHandler(serverCtx),
},
{
// 用户登录
Method: http.MethodPost,
Path: "/admin/auth/login",
Handler: auth.LoginHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取聊天消息详情
Method: http.MethodGet,
Path: "/admin/chat/:id",
Handler: chat.GetChatMessageDetailHandler(serverCtx),
},
{
// 删除聊天消息
Method: http.MethodDelete,
Path: "/admin/chat/:id",
Handler: chat.DeleteChatMessageHandler(serverCtx),
},
{
// 批量删除聊天消息
Method: http.MethodDelete,
Path: "/admin/chat/batch",
Handler: chat.BatchDeleteChatMessagesHandler(serverCtx),
},
{
// 按消息类型删除
Method: http.MethodDelete,
Path: "/admin/chat/bytype",
Handler: chat.DeleteMessagesByTypeHandler(serverCtx),
},
{
// 清空会话消息
Method: http.MethodDelete,
Path: "/admin/chat/clearconv",
Handler: chat.ClearConversationHandler(serverCtx),
},
{
// 获取聊天消息列表
Method: http.MethodGet,
Path: "/admin/chat/list",
Handler: chat.GetChatMessageListHandler(serverCtx),
},
{
// 恢复已删除的消息
Method: http.MethodPut,
Path: "/admin/chat/restore",
Handler: chat.RestoreChatMessageHandler(serverCtx),
},
{
// 批量恢复消息
Method: http.MethodPut,
Path: "/admin/chat/restorebatch",
Handler: chat.BatchRestoreChatMessagesHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 更新表情图片
Method: http.MethodPut,
Path: "/admin/emoji/:emojiId",
Handler: emoji.UpdateEmojiHandler(serverCtx),
},
{
// 删除表情图片
Method: http.MethodDelete,
Path: "/admin/emoji/:emojiId",
Handler: emoji.DeleteEmojiHandler(serverCtx),
},
{
// 获取用户收藏的表情图片列表
Method: http.MethodGet,
Path: "/admin/emoji/collects",
Handler: emoji.GetEmojiCollectListHandler(serverCtx),
},
{
// 创建表情图片
Method: http.MethodPost,
Path: "/admin/emoji/create",
Handler: emoji.CreateEmojiHandler(serverCtx),
},
{
// 获取表情图片列表
Method: http.MethodGet,
Path: "/admin/emoji/list",
Handler: emoji.GetEmojiListHandler(serverCtx),
},
{
// 向表情包集合中添加表情图片
Method: http.MethodPost,
Path: "/admin/emoji/packageaddemoji",
Handler: emoji.AddEmojiToPackageHandler(serverCtx),
},
{
// 创建表情包集合
Method: http.MethodPost,
Path: "/admin/emoji/packagecreate",
Handler: emoji.CreateEmojiPackageHandler(serverCtx),
},
{
// 删除表情包集合
Method: http.MethodDelete,
Path: "/admin/emoji/packagedelete",
Handler: emoji.DeleteEmojiPackageHandler(serverCtx),
},
{
// 获取表情包内的表情图片列表
Method: http.MethodGet,
Path: "/admin/emoji/packageemojis",
Handler: emoji.GetEmojiPackageEmojisHandler(serverCtx),
},
{
// 从表情包集合中移除表情图片
Method: http.MethodDelete,
Path: "/admin/emoji/packageremoveemoji",
Handler: emoji.RemoveEmojiFromPackageHandler(serverCtx),
},
{
// 获取表情包集合列表
Method: http.MethodGet,
Path: "/admin/emoji/packages",
Handler: emoji.GetEmojiPackageListHandler(serverCtx),
},
{
// 更新表情包集合
Method: http.MethodPut,
Path: "/admin/emoji/packageupdate",
Handler: emoji.UpdateEmojiPackageHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取反馈详情
Method: http.MethodGet,
Path: "/admin/feedback/:id",
Handler: feedback.GetFeedbackDetailHandler(serverCtx),
},
{
// 处理反馈
Method: http.MethodPut,
Path: "/admin/feedback/:id",
Handler: feedback.HandleFeedbackHandler(serverCtx),
},
{
// 删除反馈
Method: http.MethodDelete,
Path: "/admin/feedback/:id",
Handler: feedback.DeleteFeedbackHandler(serverCtx),
},
{
// 获取反馈列表
Method: http.MethodGet,
Path: "/admin/feedback/list",
Handler: feedback.GetFeedbackListHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取文件详情
Method: http.MethodGet,
Path: "/admin/file/:id",
Handler: file.GetFileDetailHandler(serverCtx),
},
{
// 删除文件
Method: http.MethodDelete,
Path: "/admin/file/:id",
Handler: file.DeleteFileHandler(serverCtx),
},
{
// 批量删除文件
Method: http.MethodPost,
Path: "/admin/file/batch-delete",
Handler: file.BatchDeleteFileHandler(serverCtx),
},
{
// 获取文件列表
Method: http.MethodGet,
Path: "/admin/file/list",
Handler: file.GetFileListHandler(serverCtx),
},
{
// 文件预览
Method: http.MethodGet,
Path: "/admin/file/preview/:fileName",
Handler: file.PreviewHandler(serverCtx),
},
{
// 获取七牛云上传token
Method: http.MethodPost,
Path: "/admin/file/qiniuToken",
Handler: file.GetQiniuUploadTokenHandler(serverCtx),
},
{
// 保存文件信息到数据库
Method: http.MethodPost,
Path: "/admin/file/save",
Handler: file.SaveFileHandler(serverCtx),
},
{
// 文件上传本地
Method: http.MethodPost,
Path: "/admin/file/uploadLocal",
Handler: file.FileUploadLocalHandler(serverCtx),
},
{
// 文件上传七牛云
Method: http.MethodPost,
Path: "/admin/file/uploadQiniu",
Handler: file.FileUploadQiniuHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取好友关系详情
Method: http.MethodGet,
Path: "/admin/friend/:id",
Handler: friend.GetFriendDetailHandler(serverCtx),
},
{
// 强制删除好友关系
Method: http.MethodDelete,
Path: "/admin/friend/:id",
Handler: friend.DeleteFriendHandler(serverCtx),
},
{
// 批量删除好友关系
Method: http.MethodDelete,
Path: "/admin/friend/batch",
Handler: friend.BatchDeleteFriendsHandler(serverCtx),
},
{
// 获取好友关系列表
Method: http.MethodGet,
Path: "/admin/friend/list",
Handler: friend.GetFriendListHandler(serverCtx),
},
{
// 恢复好友关系
Method: http.MethodPut,
Path: "/admin/friend/restore",
Handler: friend.RestoreFriendHandler(serverCtx),
},
{
// 获取好友验证详情
Method: http.MethodGet,
Path: "/admin/friend/verify",
Handler: friend.GetFriendVerifyDetailHandler(serverCtx),
},
{
// 删除好友验证记录
Method: http.MethodDelete,
Path: "/admin/friend/verify",
Handler: friend.DeleteFriendVerifyHandler(serverCtx),
},
{
// 批量删除好友验证记录
Method: http.MethodDelete,
Path: "/admin/friend/verifybatch",
Handler: friend.BatchDeleteFriendVerifyHandler(serverCtx),
},
{
// 获取好友验证列表
Method: http.MethodGet,
Path: "/admin/friend/verifylist",
Handler: friend.GetFriendVerifyListHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取群组详情
Method: http.MethodGet,
Path: "/admin/group/:id",
Handler: group.GetGroupDetailHandler(serverCtx),
},
{
// 更新群组信息
Method: http.MethodPut,
Path: "/admin/group/:id",
Handler: group.UpdateGroupHandler(serverCtx),
},
{
// 删除群组
Method: http.MethodDelete,
Path: "/admin/group/:id",
Handler: group.DeleteGroupHandler(serverCtx),
},
{
// 获取群组列表
Method: http.MethodGet,
Path: "/admin/group/list",
Handler: group.GetGroupListHandler(serverCtx),
},
{
// 更新群成员角色
Method: http.MethodPut,
Path: "/admin/group/member/:id",
Handler: group.UpdateMemberRoleHandler(serverCtx),
},
{
// 获取群成员列表
Method: http.MethodGet,
Path: "/admin/group/members",
Handler: group.GetGroupMemberListHandler(serverCtx),
},
{
// 禁言群成员
Method: http.MethodPut,
Path: "/admin/group/mute/:id",
Handler: group.MuteGroupMemberHandler(serverCtx),
},
{
// 移除群成员
Method: http.MethodPost,
Path: "/admin/group/remove-member",
Handler: group.RemoveGroupMemberHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取动态详情
Method: http.MethodGet,
Path: "/admin/moment/:momentId",
Handler: moment.GetMomentDetailHandler(serverCtx),
},
{
// 删除动态
Method: http.MethodDelete,
Path: "/admin/moment/:momentId",
Handler: moment.DeleteMomentHandler(serverCtx),
},
{
// 删除动态评论
Method: http.MethodDelete,
Path: "/admin/moment/comment/:commentId",
Handler: moment.DeleteMomentCommentHandler(serverCtx),
},
{
// 获取动态评论列表
Method: http.MethodGet,
Path: "/admin/moment/comments",
Handler: moment.GetMomentCommentListHandler(serverCtx),
},
{
// 获取动态列表
Method: http.MethodGet,
Path: "/admin/moment/list",
Handler: moment.GetMomentListHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 创建权限
Method: http.MethodPost,
Path: "/admin/system/createAuthority",
Handler: system.CreateAuthorityHandler(serverCtx),
},
{
// 创建菜单
Method: http.MethodPost,
Path: "/admin/system/createMenu",
Handler: system.CreateMenuHandler(serverCtx),
},
{
// 删除菜单
Method: http.MethodDelete,
Path: "/admin/system/delete",
Handler: system.DeleteMenuHandler(serverCtx),
},
{
// 获取菜单列表
Method: http.MethodGet,
Path: "/admin/system/getMenuList",
Handler: system.GetMenusHandler(serverCtx),
},
{
// 更新权限菜单
Method: http.MethodPut,
Path: "/admin/system/updateAuthorityMenu",
Handler: system.UpdateAuthorityMenuHandler(serverCtx),
},
{
// 更新菜单
Method: http.MethodPut,
Path: "/admin/system/updateMenu",
Handler: system.UpdateMenuHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 创建Bucket
Method: http.MethodPost,
Path: "/admin/track/bucket",
Handler: track.CreateBucketHandler(serverCtx),
},
{
// 更新Bucket
Method: http.MethodPut,
Path: "/admin/track/bucket",
Handler: track.UpdateBucketHandler(serverCtx),
},
{
// 删除Bucket
Method: http.MethodDelete,
Path: "/admin/track/bucket",
Handler: track.DeleteBucketHandler(serverCtx),
},
{
// 获取Bucket列表
Method: http.MethodGet,
Path: "/admin/track/buckets",
Handler: track.GetBucketListHandler(serverCtx),
},
{
// 获取事件列表
Method: http.MethodGet,
Path: "/admin/track/events",
Handler: track.GetEventListHandler(serverCtx),
},
{
// 查询日志
Method: http.MethodGet,
Path: "/admin/track/logs",
Handler: track.QueryLogsHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 添加新应用
Method: http.MethodPost,
Path: "/admin/update/appAdd",
Handler: update.AddAppHandler(serverCtx),
},
{
// 获取应用列表
Method: http.MethodGet,
Path: "/admin/update/appsUpdate",
Handler: update.GetAppsHandler(serverCtx),
},
{
// 添加新架构
Method: http.MethodPost,
Path: "/admin/update/architectureAdd",
Handler: update.AddArchitectureHandler(serverCtx),
},
{
// 更新架构信息
Method: http.MethodPost,
Path: "/admin/update/architectureUpdate",
Handler: update.UpdateArchitectureHandler(serverCtx),
},
{
// 获取架构列表
Method: http.MethodGet,
Path: "/admin/update/architectures",
Handler: update.GetArchitecturesHandler(serverCtx),
},
{
// 获取城市策略列表
Method: http.MethodGet,
Path: "/admin/update/cityStrategies",
Handler: update.GetCityStrategiesHandler(serverCtx),
},
{
// 更新城市策略
Method: http.MethodPost,
Path: "/admin/update/cityStrategyUpdate",
Handler: update.UpdateCityStrategyHandler(serverCtx),
},
{
// 添加新版本
Method: http.MethodPost,
Path: "/admin/update/versionAdd",
Handler: update.AddVersionHandler(serverCtx),
},
{
// 获取版本列表
Method: http.MethodGet,
Path: "/admin/update/versionList",
Handler: update.GetVersionListHandler(serverCtx),
},
{
// 获取应用下所有版本
Method: http.MethodGet,
Path: "/admin/update/versions",
Handler: update.GetAppVersionsHandler(serverCtx),
},
},
)
server.AddRoutes(
[]rest.Route{
{
// 获取用户详情
Method: http.MethodGet,
Path: "/admin/user/:id",
Handler: user.GetUserDetailHandler(serverCtx),
},
{
// 更新用户
Method: http.MethodPut,
Path: "/admin/user/:id",
Handler: user.UpdateUserHandler(serverCtx),
},
{
// 删除用户
Method: http.MethodDelete,
Path: "/admin/user/:id",
Handler: user.DeleteUserHandler(serverCtx),
},
{
// 批量删除用户
Method: http.MethodDelete,
Path: "/admin/user/batch",
Handler: user.BatchDeleteUsersHandler(serverCtx),
},
{
// 创建用户
Method: http.MethodPost,
Path: "/admin/user/create",
Handler: user.CreateUserHandler(serverCtx),
},
{
// 获取用户列表
Method: http.MethodGet,
Path: "/admin/user/list",
Handler: user.GetUserListHandler(serverCtx),
},
{
// 重置用户密码
Method: http.MethodPut,
Path: "/admin/user/password",
Handler: user.ResetUserPasswordHandler(serverCtx),
},
{
// 批量更新用户状态
Method: http.MethodPut,
Path: "/admin/user/status",
Handler: user.BatchUpdateUserStatusHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/handler/chat/deletemessagesbytypehandler.go | app/backend/backend_admin/internal/handler/chat/deletemessagesbytypehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteMessagesByTypeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteMessagesByTypeReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteMessagesByTypeLogic(r.Context(), svcCtx)
resp, err := l.DeleteMessagesByType(&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/backend/backend_admin/internal/handler/chat/deletechatmessagehandler.go | app/backend/backend_admin/internal/handler/chat/deletechatmessagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteChatMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteChatMessageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteChatMessageLogic(r.Context(), svcCtx)
resp, err := l.DeleteChatMessage(&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/backend/backend_admin/internal/handler/chat/clearconversationhandler.go | app/backend/backend_admin/internal/handler/chat/clearconversationhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func ClearConversationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ClearConversationReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewClearConversationLogic(r.Context(), svcCtx)
resp, err := l.ClearConversation(&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/backend/backend_admin/internal/handler/chat/batchdeletechatmessageshandler.go | app/backend/backend_admin/internal/handler/chat/batchdeletechatmessageshandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BatchDeleteChatMessagesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BatchDeleteChatMessagesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if len(req.Ids) == 0 {
response.Response(r, w, nil, errors.New("消息ID列表不能为空"))
return
}
l := logic.NewBatchDeleteChatMessagesLogic(r.Context(), svcCtx)
resp, err := l.BatchDeleteChatMessages(&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/backend/backend_admin/internal/handler/chat/restorechatmessagehandler.go | app/backend/backend_admin/internal/handler/chat/restorechatmessagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func RestoreChatMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.RestoreChatMessageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewRestoreChatMessageLogic(r.Context(), svcCtx)
resp, err := l.RestoreChatMessage(&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/backend/backend_admin/internal/handler/chat/getchatmessagelisthandler.go | app/backend/backend_admin/internal/handler/chat/getchatmessagelisthandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetChatMessageListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetChatMessageListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetChatMessageListLogic(r.Context(), svcCtx)
resp, err := l.GetChatMessageList(&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/backend/backend_admin/internal/handler/chat/batchrestorechatmessageshandler.go | app/backend/backend_admin/internal/handler/chat/batchrestorechatmessageshandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BatchRestoreChatMessagesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BatchRestoreChatMessagesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewBatchRestoreChatMessagesLogic(r.Context(), svcCtx)
resp, err := l.BatchRestoreChatMessages(&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/backend/backend_admin/internal/handler/chat/getchatmessagedetailhandler.go | app/backend/backend_admin/internal/handler/chat/getchatmessagedetailhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/chat"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetChatMessageDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetChatMessageDetailReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetChatMessageDetailLogic(r.Context(), svcCtx)
resp, err := l.GetChatMessageDetail(&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/backend/backend_admin/internal/handler/system/updatemenuhandler.go | app/backend/backend_admin/internal/handler/system/updatemenuhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateMenuReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateMenuLogic(r.Context(), svcCtx)
resp, err := l.UpdateMenu(&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/backend/backend_admin/internal/handler/system/updateauthoritymenuhandler.go | app/backend/backend_admin/internal/handler/system/updateauthoritymenuhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateAuthorityMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateAuthorityMenuReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateAuthorityMenuLogic(r.Context(), svcCtx)
resp, err := l.UpdateAuthorityMenu(&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/backend/backend_admin/internal/handler/system/getmenushandler.go | app/backend/backend_admin/internal/handler/system/getmenushandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetMenusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetMenuListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetMenusLogic(r.Context(), svcCtx)
resp, err := l.GetMenus(&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/backend/backend_admin/internal/handler/system/deletemenuhandler.go | app/backend/backend_admin/internal/handler/system/deletemenuhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteMenuReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteMenuLogic(r.Context(), svcCtx)
resp, err := l.DeleteMenu(&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/backend/backend_admin/internal/handler/system/createmenuhandler.go | app/backend/backend_admin/internal/handler/system/createmenuhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateMenuReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewCreateMenuLogic(r.Context(), svcCtx)
resp, err := l.CreateMenu(&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/backend/backend_admin/internal/handler/system/createauthorityhandler.go | app/backend/backend_admin/internal/handler/system/createauthorityhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/system"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateAuthorityHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateAuthorityReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewCreateAuthorityLogic(r.Context(), svcCtx)
resp, err := l.CreateAuthority(&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/backend/backend_admin/internal/handler/auth/loginhandler.go | app/backend/backend_admin/internal/handler/auth/loginhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/auth"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func LoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.LoginReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewLoginLogic(r.Context(), svcCtx)
resp, err := l.Login(&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/backend/backend_admin/internal/handler/auth/authenticationhandler.go | app/backend/backend_admin/internal/handler/auth/authenticationhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/auth"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"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 {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.Token == "" {
response.Response(r, w, nil, errors.New("token不能为空"))
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/backend/backend_admin/internal/handler/file/deletefilehandler.go | app/backend/backend_admin/internal/handler/file/deletefilehandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteFileHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteFileReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteFileLogic(r.Context(), svcCtx)
resp, err := l.DeleteFile(&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/backend/backend_admin/internal/handler/file/getqiniuuploadtokenhandler.go | app/backend/backend_admin/internal/handler/file/getqiniuuploadtokenhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetQiniuUploadTokenHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetQiniuUploadTokenReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetQiniuUploadTokenLogic(r.Context(), svcCtx)
resp, err := l.GetQiniuUploadToken(&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/backend/backend_admin/internal/handler/file/previewhandler.go | app/backend/backend_admin/internal/handler/file/previewhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/file/file_models"
"beaver/common/response"
"errors"
"fmt"
"net/http"
"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)
response.Response(r, w, nil, err)
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_name = ?", req.FileName).Error
if err != nil {
response.Response(r, w, nil, errors.New("图片不存在"))
return
}
// 构建七牛云文件URL
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("privateAccessURL:", privateAccessURL)
// 返回重定向到签名URL
http.Redirect(w, r, privateAccessURL, http.StatusFound)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/handler/file/fileuploadlocalhandler.go | app/backend/backend_admin/internal/handler/file/fileuploadlocalhandler.go | package handler
import (
"fmt"
"os"
"path/filepath"
filecommon "beaver/app/backend/backend_admin/internal/handler/file/common"
logic "beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/file/file_models"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
)
func FileUploadLocalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.FileUploadLocalReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 从表单获取文件
file, fileHeader, err := r.FormFile("file")
if err != nil {
logx.Error(err)
response.Response(r, w, nil, err)
return
}
defer file.Close()
// 获取fileInfo
fileInfoStr := r.FormValue("fileInfo")
// 使用公共工具函数验证和处理文件
fileReq, err := filecommon.ValidateAndProcessFile(file, fileHeader, svcCtx)
if err != nil {
response.Response(r, w, nil, err)
return
}
// 确定文件来源
source := file_models.LocalSource
if req.Source != "" && req.Source == "qiniu" {
source = file_models.QiniuSource
}
l := logic.NewFileUploadLocalLogic(r.Context(), svcCtx)
resp, err := l.FileUploadLocal(&req)
if err != nil {
response.Response(r, w, nil, err)
return
}
// 检查文件是否已经存在于数据库中
existingFile, err := checkFileExists(fileReq.FileMd5, svcCtx)
if err == nil {
// 文件已存在，直接返回
resp.FileKey = existingFile.FileKey
resp.OriginalName = existingFile.OriginalName
response.Response(r, w, resp, nil)
return
}
// 创建本地存储目录
uploadDir := svcCtx.Config.Local.UploadDir
if uploadDir == "" {
uploadDir = "./uploads" // 默认目录
}
// 生成本地文件路径
localFilePath := generateFilePath(uploadDir, fileReq.FileType, fileReq.FileMd5, fileReq.Suffix)
// 保存文件到本地
if err := saveFileToLocal(localFilePath, fileReq.ByteData); err != nil {
response.Response(r, w, nil, err)
return
}
// 生成相对路径用于数据库存储（不包含uploadDir）
relativePath := generateRelativePath(fileReq.FileType, fileReq.FileMd5, fileReq.Suffix)
// 保存文件信息到数据库
saveReq := &types.SaveFileReq{
OriginalName: fileReq.OriginalName,
Size: fileReq.Size,
Path: relativePath,
Md5: fileReq.FileMd5,
Type: fileReq.FileType,
Source: string(source),
FileInfo: fileInfoStr,
}
saveLogic := logic.NewSaveFileLogic(r.Context(), svcCtx)
saveResp, err := saveLogic.SaveFile(saveReq)
if err != nil {
response.Response(r, w, nil, err)
return
}
resp.FileKey = saveResp.FileKey
resp.OriginalName = fileReq.OriginalName
logx.Infof("本地文件上传成功: %s", saveResp.FileKey)
response.Response(r, w, resp, 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
}
// 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
path := filepath.Join(fileType, fileMd5Name)
return filepath.ToSlash(path)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/handler/file/getfiledetailhandler.go | app/backend/backend_admin/internal/handler/file/getfiledetailhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetFileDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetFileDetailReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetFileDetailLogic(r.Context(), svcCtx)
resp, err := l.GetFileDetail(&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/backend/backend_admin/internal/handler/file/batchdeletefilehandler.go | app/backend/backend_admin/internal/handler/file/batchdeletefilehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BatchDeleteFileHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BatchDeleteFileReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if len(req.Ids) == 0 {
response.Response(r, w, nil, errors.New("删除的文件ID列表不能为空"))
return
}
l := logic.NewBatchDeleteFileLogic(r.Context(), svcCtx)
resp, err := l.BatchDeleteFile(&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/backend/backend_admin/internal/handler/file/fileuploadqiniuhandler.go | app/backend/backend_admin/internal/handler/file/fileuploadqiniuhandler.go | package handler
import (
filecommon "beaver/app/backend/backend_admin/internal/handler/file/common"
logic "beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/file/file_models"
"beaver/common/response"
"beaver/utils"
"beaver/utils/md5"
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strings"
"github.com/google/uuid"
"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"
)
func FileUploadQiniuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
logx.Info("开始处理文件上传请求")
var req types.FileUploadQiniuReq
if err := httpx.Parse(r, &req); err != nil {
logx.Error("解析请求参数失败:", err)
response.Response(r, w, nil, errors.New("解析请求参数失败"))
return
}
file, fileHead, err := r.FormFile("file")
if err != nil {
logx.Error("获取上传文件失败:", err)
response.Response(r, w, nil, errors.New("获取上传文件失败"))
return
}
logx.Info("成功获取上传文件:", fileHead.Filename, "大小:", fileHead.Size)
// 获取fileInfo
fileInfoStr := r.FormValue("fileInfo")
// 确定文件来源
source := file_models.QiniuSource
if req.Source != "" && req.Source == "local" {
source = file_models.LocalSource
}
// 文件后缀白名单
originalName := fileHead.Filename
nameList := strings.Split(originalName, ".")
if len(nameList) < 2 {
logx.Error("文件名格式不正确:", originalName)
response.Response(r, w, nil, errors.New("文件格式不正确"))
return
}
suffix := strings.ToLower(nameList[len(nameList)-1])
if !utils.InList(svcCtx.Config.WhiteList, suffix) {
logx.Error("文件类型不在白名单中:", suffix)
response.Response(r, w, nil, errors.New("文件类型不支持"))
return
}
logx.Info("文件类型检查通过:", suffix)
// 确定文件类型
fileType := filecommon.GetFileType(suffix)
if fileType == "unknown" {
logx.Error("未知的文件类型:", suffix)
response.Response(r, w, nil, errors.New("不支持的文件类型"))
return
}
logx.Info("文件类型:", fileType)
// 检查文件大小
maxSize, ok := svcCtx.Config.File.MaxSize[fileType]
if !ok {
logx.Error("配置中未找到文件类型的大小限制:", fileType)
response.Response(r, w, nil, errors.New("系统配置错误"))
return
}
fileSizeMB := float64(fileHead.Size) / (1024 * 1024)
if fileSizeMB > maxSize {
logx.Error("文件大小超过限制:", fileSizeMB, "MB, 最大限制:", maxSize, "MB")
response.Response(r, w, nil, fmt.Errorf("文件大小不能超过 %.2fMB", maxSize))
return
}
logx.Info("文件大小检查通过:", fileSizeMB, "MB")
// 读取文件内容
logx.Info("开始读取文件内容")
byteData, err := io.ReadAll(file)
if err != nil {
logx.Error("读取文件内容失败:", err)
response.Response(r, w, nil, errors.New("读取文件失败"))
return
}
logx.Info("文件内容读取成功, 大小:", len(byteData), "字节")
fileMd5 := md5.MD5(byteData)
fileMd5Name := fileMd5 + "." + suffix
logx.Info("文件MD5:", fileMd5)
l := logic.NewFileUploadQiniuLogic(r.Context(), svcCtx)
resp, _ := l.FileUploadQiniu(&req)
// 检查文件是否已经存在于数据库中
logx.Info("检查文件是否已存在")
var fileModel file_models.FileModel
err = svcCtx.DB.Take(&fileModel, "md5 = ?", fileMd5).Error
if err == nil {
logx.Info("文件已存在，直接返回:", fileModel.FileKey, fileModel.OriginalName)
resp.FileKey = fileModel.FileKey
resp.OriginalName = fileModel.OriginalName
response.Response(r, w, resp, nil)
return
}
logx.Info("文件不存在，继续上传流程")
// 根据文件类型创建目录结构，并生成七牛云文件路径
qiniuFilePath := fmt.Sprintf("%s/%s", fileType, fileMd5Name)
logx.Info("七牛云文件路径:", qiniuFilePath)
// 上传文件到七牛云
logx.Info("开始上传文件到七牛云")
qiniuURL, err := uploadToQiniu(qiniuFilePath, byteData, svcCtx)
if err != nil {
logx.Error("上传到七牛云失败:", err)
response.Response(r, w, nil, errors.New("上传文件失败"))
return
}
logx.Info("文件成功上传到七牛云")
// 创建新的文件记录
logx.Info("开始创建数据库记录")
// 生成带后缀的FileKey
fileUUID := uuid.New().String()
fileKeyWithSuffix := fileUUID + "." + suffix
newFileModel := &file_models.FileModel{
OriginalName: strings.TrimSuffix(originalName, "."+suffix),
Size: fileHead.Size,
Path: qiniuURL,
Md5: fileMd5,
FileKey: fileKeyWithSuffix,
Type: fileType,
Source: source,
}
// 解析fileInfo（必传字段）
if fileInfoStr == "" {
logx.Error("fileInfo不能为空")
response.Response(r, w, nil, errors.New("fileInfo不能为空"))
return
}
fileInfo := &file_models.FileInfo{}
if err := json.Unmarshal([]byte(fileInfoStr), fileInfo); err != nil {
logx.Errorf("解析fileInfo失败: %v, 原始数据: %s", err, fileInfoStr)
response.Response(r, w, nil, errors.New("fileInfo格式不正确"))
return
}
newFileModel.FileInfo = fileInfo
err = svcCtx.DB.Create(newFileModel).Error
if err != nil {
logx.Error("创建数据库记录失败:", err)
response.Response(r, w, nil, errors.New("保存文件信息失败"))
return
}
logx.Info("数据库记录创建成功:", newFileModel.FileKey)
resp.FileKey = newFileModel.FileKey
resp.OriginalName = newFileModel.OriginalName
logx.Info("文件上传完成:", resp.FileKey)
response.Response(r, w, resp, nil)
}
}
func uploadToQiniu(filePath string, fileData []byte, config *svc.ServiceContext) (string, error) {
logx.Info("准备上传到七牛云, 文件路径:", filePath)
// 设置认证信息
mac := credentials.NewCredentials(config.Config.Qiniu.AK, config.Config.Qiniu.SK)
logx.Info("七牛云认证信息设置完成")
uploadManager := uploader.NewUploadManager(&uploader.UploadManagerOptions{
Options: http_client.Options{
Credentials: mac,
},
})
logx.Info("七牛云上传管理器创建完成")
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 {
logx.Error("七牛云上传失败:", err)
return "", fmt.Errorf("failed to upload file to Qiniu: %v", err)
}
logx.Info("七牛云上传成功")
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/backend/backend_admin/internal/handler/file/savefilehandler.go | app/backend/backend_admin/internal/handler/file/savefilehandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func SaveFileHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.SaveFileReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewSaveFileLogic(r.Context(), svcCtx)
resp, err := l.SaveFile(&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/backend/backend_admin/internal/handler/file/getfilelisthandler.go | app/backend/backend_admin/internal/handler/file/getfilelisthandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/file"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetFileListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetFileListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetFileListLogic(r.Context(), svcCtx)
resp, err := l.GetFileList(&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/backend/backend_admin/internal/handler/file/common/file_utils.go | app/backend/backend_admin/internal/handler/file/common/file_utils.go | package file
import (
"errors"
"fmt"
"io"
"mime/multipart"
"strings"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/utils/md5"
)
// 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",
"apk": "apk",
"exe": "exe",
}
// FileUploadRequest 文件上传请求结构
type FileUploadRequest struct {
File multipart.File
FileHeader *multipart.FileHeader
OriginalName string
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 !inList(svcCtx.Config.File.WhiteList, suffix) {
return nil, errors.New("文件类型不在白名单中")
}
// 确定文件类型
fileType := GetFileType(suffix)
if fileType == "unknown" {
return nil, errors.New("未知文件类型")
}
// 检查文件大小
maxSize, ok := svcCtx.Config.File.MaxSize[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,
OriginalName: originalName,
ByteData: byteData,
FileMd5: fileMd5,
FileType: fileType,
Suffix: suffix,
Size: fileHeader.Size,
}, nil
}
// GetFileType 根据文件后缀获取文件类型
func GetFileType(suffix string) string {
if fileType, ok := FileTypeMapper[suffix]; ok {
return fileType
}
return "unknown"
}
// inList 检查元素是否在列表中
func inList(list []string, item string) bool {
for _, v := range list {
if v == item {
return true
}
}
return false
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/handler/user/deleteuserhandler.go | app/backend/backend_admin/internal/handler/user/deleteuserhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteUserReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteUserLogic(r.Context(), svcCtx)
resp, err := l.DeleteUser(&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/backend/backend_admin/internal/handler/user/batchdeleteusershandler.go | app/backend/backend_admin/internal/handler/user/batchdeleteusershandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BatchDeleteUsersHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BatchDeleteUsersReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if len(req.Ids) == 0 {
response.Response(r, w, nil, errors.New("请选择要删除的用户"))
return
}
l := logic.NewBatchDeleteUsersLogic(r.Context(), svcCtx)
resp, err := l.BatchDeleteUsers(&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/backend/backend_admin/internal/handler/user/getuserlisthandler.go | app/backend/backend_admin/internal/handler/user/getuserlisthandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetUserListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetUserListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetUserListLogic(r.Context(), svcCtx)
resp, err := l.GetUserList(&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/backend/backend_admin/internal/handler/user/getuserdetailhandler.go | app/backend/backend_admin/internal/handler/user/getuserdetailhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetUserDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetUserDetailReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.UserID == "" {
response.Response(r, w, nil, errors.New("用户ID不能为空"))
return
}
l := logic.NewGetUserDetailLogic(r.Context(), svcCtx)
resp, err := l.GetUserDetail(&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/backend/backend_admin/internal/handler/user/updateuserhandler.go | app/backend/backend_admin/internal/handler/user/updateuserhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateUserReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.UserID == "" {
response.Response(r, w, nil, errors.New("用户ID不能为空"))
return
}
l := logic.NewUpdateUserLogic(r.Context(), svcCtx)
resp, err := l.UpdateUser(&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/backend/backend_admin/internal/handler/user/createuserhandler.go | app/backend/backend_admin/internal/handler/user/createuserhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateUserReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.NickName == "" || req.Password == "" || req.Email == "" {
response.Response(r, w, nil, errors.New("昵称、密码和邮箱不能为空"))
return
}
l := logic.NewCreateUserLogic(r.Context(), svcCtx)
resp, err := l.CreateUser(&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/backend/backend_admin/internal/handler/user/resetuserpasswordhandler.go | app/backend/backend_admin/internal/handler/user/resetuserpasswordhandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func ResetUserPasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ResetUserPasswordReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewResetUserPasswordLogic(r.Context(), svcCtx)
resp, err := l.ResetUserPassword(&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/backend/backend_admin/internal/handler/user/batchupdateuserstatushandler.go | app/backend/backend_admin/internal/handler/user/batchupdateuserstatushandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/user"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BatchUpdateUserStatusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BatchUpdateUserStatusReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewBatchUpdateUserStatusLogic(r.Context(), svcCtx)
resp, err := l.BatchUpdateUserStatus(&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/backend/backend_admin/internal/handler/track/updatebuckethandler.go | app/backend/backend_admin/internal/handler/track/updatebuckethandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateBucketHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateBucketReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateBucketLogic(r.Context(), svcCtx)
resp, err := l.UpdateBucket(&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/backend/backend_admin/internal/handler/track/createbuckethandler.go | app/backend/backend_admin/internal/handler/track/createbuckethandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateBucketHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateBucketReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewCreateBucketLogic(r.Context(), svcCtx)
resp, err := l.CreateBucket(&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/backend/backend_admin/internal/handler/track/querylogshandler.go | app/backend/backend_admin/internal/handler/track/querylogshandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryLogsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryLogsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewQueryLogsLogic(r.Context(), svcCtx)
resp, err := l.QueryLogs(&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/backend/backend_admin/internal/handler/track/deletebuckethandler.go | app/backend/backend_admin/internal/handler/track/deletebuckethandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteBucketHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteBucketReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteBucketLogic(r.Context(), svcCtx)
resp, err := l.DeleteBucket(&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/backend/backend_admin/internal/handler/track/getbucketlisthandler.go | app/backend/backend_admin/internal/handler/track/getbucketlisthandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetBucketListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetBucketListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetBucketListLogic(r.Context(), svcCtx)
resp, err := l.GetBucketList(&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/backend/backend_admin/internal/handler/track/geteventlisthandler.go | app/backend/backend_admin/internal/handler/track/geteventlisthandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/track"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetEventListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEventListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetEventListLogic(r.Context(), svcCtx)
resp, err := l.GetEventList(&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/backend/backend_admin/internal/handler/emoji/getemojilisthandler.go | app/backend/backend_admin/internal/handler/emoji/getemojilisthandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetEmojiListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEmojiListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetEmojiListLogic(r.Context(), svcCtx)
resp, err := l.GetEmojiList(&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/backend/backend_admin/internal/handler/emoji/addemojitopackagehandler.go | app/backend/backend_admin/internal/handler/emoji/addemojitopackagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AddEmojiToPackageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AddEmojiToPackageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewAddEmojiToPackageLogic(r.Context(), svcCtx)
resp, err := l.AddEmojiToPackage(&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/backend/backend_admin/internal/handler/emoji/deleteemojipackagehandler.go | app/backend/backend_admin/internal/handler/emoji/deleteemojipackagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteEmojiPackageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteEmojiPackageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteEmojiPackageLogic(r.Context(), svcCtx)
resp, err := l.DeleteEmojiPackage(&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/backend/backend_admin/internal/handler/emoji/getemojipackagelisthandler.go | app/backend/backend_admin/internal/handler/emoji/getemojipackagelisthandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetEmojiPackageListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEmojiPackageListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetEmojiPackageListLogic(r.Context(), svcCtx)
resp, err := l.GetEmojiPackageList(&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/backend/backend_admin/internal/handler/emoji/deleteemojihandler.go | app/backend/backend_admin/internal/handler/emoji/deleteemojihandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteEmojiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteEmojiReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.EmojiId == "" {
response.Response(r, w, nil, errors.New("表情ID不能为空"))
return
}
l := logic.NewDeleteEmojiLogic(r.Context(), svcCtx)
resp, err := l.DeleteEmoji(&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/backend/backend_admin/internal/handler/emoji/updateemojihandler.go | app/backend/backend_admin/internal/handler/emoji/updateemojihandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateEmojiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateEmojiReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateEmojiLogic(r.Context(), svcCtx)
resp, err := l.UpdateEmoji(&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/backend/backend_admin/internal/handler/emoji/createemojihandler.go | app/backend/backend_admin/internal/handler/emoji/createemojihandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateEmojiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateEmojiReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.FileKey == "" {
response.Response(r, w, nil, errors.New("文件ID不能为空"))
return
}
if req.Title == "" {
response.Response(r, w, nil, errors.New("表情名称不能为空"))
return
}
if req.AuthorID == "" {
response.Response(r, w, nil, errors.New("创建者ID不能为空"))
return
}
l := logic.NewCreateEmojiLogic(r.Context(), svcCtx)
resp, err := l.CreateEmoji(&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/backend/backend_admin/internal/handler/emoji/removeemojifrompackagehandler.go | app/backend/backend_admin/internal/handler/emoji/removeemojifrompackagehandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func RemoveEmojiFromPackageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.RemoveEmojiFromPackageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewRemoveEmojiFromPackageLogic(r.Context(), svcCtx)
resp, err := l.RemoveEmojiFromPackage(&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/backend/backend_admin/internal/handler/emoji/getemojicollectlisthandler.go | app/backend/backend_admin/internal/handler/emoji/getemojicollectlisthandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetEmojiCollectListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEmojiCollectListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetEmojiCollectListLogic(r.Context(), svcCtx)
resp, err := l.GetEmojiCollectList(&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/backend/backend_admin/internal/handler/emoji/getemojipackageemojishandler.go | app/backend/backend_admin/internal/handler/emoji/getemojipackageemojishandler.go | package handler
import (
"beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetEmojiPackageEmojisHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetEmojiPackageEmojisReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetEmojiPackageEmojisLogic(r.Context(), svcCtx)
resp, err := l.GetEmojiPackageEmojis(&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/backend/backend_admin/internal/handler/emoji/updateemojipackagehandler.go | app/backend/backend_admin/internal/handler/emoji/updateemojipackagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateEmojiPackageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateEmojiPackageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateEmojiPackageLogic(r.Context(), svcCtx)
resp, err := l.UpdateEmojiPackage(&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/backend/backend_admin/internal/handler/emoji/createemojipackagehandler.go | app/backend/backend_admin/internal/handler/emoji/createemojipackagehandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/emoji"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"errors"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateEmojiPackageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateEmojiPackageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 参数校验
if req.Title == "" {
response.Response(r, w, nil, errors.New("表情包名称不能为空"))
return
}
if req.UserID == "" {
response.Response(r, w, nil, errors.New("创建者ID不能为空"))
return
}
if req.Type == "" {
response.Response(r, w, nil, errors.New("表情包类型不能为空"))
return
}
l := logic.NewCreateEmojiPackageLogic(r.Context(), svcCtx)
resp, err := l.CreateEmojiPackage(&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/backend/backend_admin/internal/handler/feedback/deletefeedbackhandler.go | app/backend/backend_admin/internal/handler/feedback/deletefeedbackhandler.go | package handler
import (
logic "beaver/app/backend/backend_admin/internal/logic/feedback"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteFeedbackHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteFeedbackReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteFeedbackLogic(r.Context(), svcCtx)
resp, err := l.DeleteFeedback(&req)
response.Response(r, w, resp, err)
}
}
| 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.