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/backend/backend_admin/internal/logic/group/getgroupmemberlistlogic.go | app/backend/backend_admin/internal/logic/group/getgroupmemberlistlogic.go | package logic
import (
"context"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/group/group_models"
"beaver/common/list_query"
"beaver/common/models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetGroupMemberListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取群成员列表
func NewGetGroupMemberListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupMemberListLogic {
return &GetGroupMemberListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetGroupMemberListLogic) GetGroupMemberList(req *types.GetGroupMemberListReq) (resp *types.GetGroupMemberListRes, err error) {
// 分页参数校验
page := req.Page
limit := req.Limit
if page <= 0 {
page = 1
}
if limit <= 0 {
limit = 20
}
if limit > 100 {
limit = 100
}
// 构建查询条件
whereClause := l.svcCtx.DB.Where("group_id = ?", req.GroupId)
// 角色筛选
if req.Role != 0 {
whereClause = whereClause.Where("role = ?", req.Role)
}
// 状态筛选
if req.Status != 0 {
whereClause = whereClause.Where("status = ?", req.Status)
}
// 分页查询
members, count, err := list_query.ListQuery(l.svcCtx.DB, group_models.GroupMemberModel{}, list_query.Option{
PageInfo: models.PageInfo{
Page: page,
Limit: limit,
Sort: "created_at desc",
},
Where: whereClause,
})
if err != nil {
logx.Errorf("查询群组成员列表失败: %v", err)
return nil, err
}
// 转换为响应格式（已精简模型字段，以下为兼容管理端返回结构的占位）
var list []types.GetGroupMemberListItem
for _, member := range members {
list = append(list, types.GetGroupMemberListItem{
Id: member.Id,
GroupId: member.GroupID,
UserId: member.UserID,
MemberNickname: "",
Role: int(member.Role),
ProhibitionTime: 0,
InviterId: "",
Status: int(member.Status),
NotifyLevel: 0,
DisplayName: "",
CreatedAt: member.CreatedAt.String(),
UpdatedAt: member.UpdatedAt.String(),
})
}
return &types.GetGroupMemberListRes{
List: list,
Total: count,
}, 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/logic/group/getgroupdetaillogic.go | app/backend/backend_admin/internal/logic/group/getgroupdetaillogic.go | package logic
import (
"context"
"errors"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type GetGroupDetailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取群组详情
func NewGetGroupDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetGroupDetailLogic {
return &GetGroupDetailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetGroupDetailLogic) GetGroupDetail(req *types.GetGroupDetailReq) (resp *types.GetGroupDetailRes, err error) {
var group group_models.GroupModel
err = l.svcCtx.DB.Where("id = ?", req.Id).First(&group).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
logx.Errorf("群组不存在: %d", req.Id)
return nil, errors.New("群组不存在")
}
logx.Errorf("查询群组详情失败: %v", err)
return nil, errors.New("查询群组详情失败")
}
return &types.GetGroupDetailRes{
Id: group.Id,
GroupId: group.GroupID,
Type: int(group.Type),
Title: group.Title,
FileName: group.Avatar,
CreatorId: group.CreatorID,
Notice: group.Notice,
Status: int(group.Status),
CreatedAt: group.CreatedAt.String(),
UpdatedAt: group.UpdatedAt.String(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/backend/backend_admin/internal/logic/group/mutegroupmemberlogic.go | app/backend/backend_admin/internal/logic/group/mutegroupmemberlogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/group/group_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type MuteGroupMemberLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 禁言群成员
func NewMuteGroupMemberLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MuteGroupMemberLogic {
return &MuteGroupMemberLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *MuteGroupMemberLogic) MuteGroupMember(req *types.MuteGroupMemberReq) (resp *types.MuteGroupMemberRes, err error) {
// 检查群组成员是否存在
var member group_models.GroupMemberModel
err = l.svcCtx.DB.Where("id = ?", req.Id).First(&member).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
logx.Errorf("群组成员不存在: %d", req.Id)
return nil, errors.New("群组成员不存在")
}
logx.Errorf("查询群组成员失败: %v", err)
return nil, errors.New("查询群组成员失败")
}
// 计算禁言到期时间
var endTime *time.Time
if req.ProhibitionTime > 0 {
expireTime := time.Now().Add(time.Duration(req.ProhibitionTime) * time.Minute)
endTime = &expireTime
}
// 更新禁言状态
err = l.svcCtx.DB.Model(&member).Updates(map[string]interface{}{
"prohibition_time": &req.ProhibitionTime,
"prohibition_end": endTime,
}).Error
if err != nil {
logx.Errorf("更新成员禁言状态失败: %v", err)
return nil, errors.New("更新成员禁言状态失败")
}
return &types.MuteGroupMemberRes{}, 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/logic/update/getcitystrategieslogic.go | app/backend/backend_admin/internal/logic/update/getcitystrategieslogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetCityStrategiesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取城市策略列表
func NewGetCityStrategiesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetCityStrategiesLogic {
return &GetCityStrategiesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetCityStrategiesLogic) GetCityStrategies(req *types.GetCityStrategiesReq) (resp *types.GetCityStrategiesRes, err error) {
// 构建查询条件
query := l.svcCtx.DB.Model(&update_models.UpdateStrategy{})
// 应用ID过滤
if req.AppID != "" {
query = query.Where("app_id = ?", req.AppID)
}
// 活跃状态过滤
if req.IsActive {
query = query.Where("is_active = ?", true)
}
// 获取总数
var total int64
if err := query.Count(&total).Error; err != nil {
logx.Errorf("Failed to count city strategies: %v", err)
return nil, fmt.Errorf("获取城市策略总数失败")
}
// 分页
if req.Page <= 0 {
req.Page = 1
}
if req.PageSize <= 0 {
req.PageSize = 10
}
offset := (req.Page - 1) * req.PageSize
// 查询策略列表
var strategies []update_models.UpdateStrategy
if err := query.Offset(offset).Limit(req.PageSize).Order("created_at DESC").Find(&strategies).Error; err != nil {
logx.Errorf("Failed to get city strategies: %v", err)
return nil, fmt.Errorf("获取城市策略列表失败")
}
// 转换为响应格式
var strategyInfos []types.GetCityStrategiesItem
for _, strategy := range strategies {
// 转换策略信息
var strategyInfosList []types.GetCityStrategiesStrategyItem
if strategy.Strategy != nil {
for _, s := range *strategy.Strategy {
// 查询版本信息
var version update_models.UpdateVersion
versionStr := "未知版本"
if err := l.svcCtx.DB.Where("id = ?", s.VersionID).First(&version).Error; err == nil {
versionStr = version.Version
}
strategyInfosList = append(strategyInfosList, types.GetCityStrategiesStrategyItem{
ArchitectureID: s.ArchitectureID,
VersionID: s.VersionID,
Version: versionStr,
ForceUpdate: s.ForceUpdate,
IsActive: s.IsActive,
})
}
}
strategyInfo := types.GetCityStrategiesItem{
Id: uint(strategy.Id),
AppID: strategy.AppID,
CityID: strategy.CityID,
Strategy: strategyInfosList,
IsActive: strategy.IsActive,
CreatedAt: strategy.CreatedAt.String(),
UpdatedAt: strategy.UpdatedAt.String(),
}
strategyInfos = append(strategyInfos, strategyInfo)
}
return &types.GetCityStrategiesRes{
Total: total,
Strategies: strategyInfos,
}, 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/logic/update/getappslogic.go | app/backend/backend_admin/internal/logic/update/getappslogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetAppsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取应用列表
func NewGetAppsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAppsLogic {
return &GetAppsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetAppsLogic) GetApps(req *types.GetAppsReq) (resp *types.GetAppsRes, err error) {
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
pageSize := req.PageSize
if pageSize <= 0 {
pageSize = 10
}
// 构建查询
query := l.svcCtx.DB.Model(&update_models.UpdateApp{})
if req.IsActive {
query = query.Where("is_active = ?", true)
}
// 获取总数
var total int64
if err := query.Count(&total).Error; err != nil {
logx.Errorf("Failed to count apps: %v", err)
return nil, err
}
// 获取分页数据
var apps []update_models.UpdateApp
if err := query.Offset(int((page - 1) * pageSize)).
Limit(int(pageSize)).
Order("created_at DESC").
Find(&apps).Error; err != nil {
logx.Errorf("Failed to get apps: %v", err)
return nil, err
}
// 构建响应
appList := make([]types.GetAppsItem, 0, len(apps))
for _, app := range apps {
appList = append(appList, types.GetAppsItem{
Id: app.Id,
AppID: app.AppID,
Name: app.Name,
Description: app.Description,
IsActive: app.IsActive,
CreatedAt: app.CreatedAt.String(),
UpdatedAt: app.UpdatedAt.String(),
})
}
return &types.GetAppsRes{
Total: total,
Apps: appList,
}, 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/logic/update/getarchitectureslogic.go | app/backend/backend_admin/internal/logic/update/getarchitectureslogic.go | package logic
import (
"beaver/app/update/update_models"
"beaver/common/list_query"
"beaver/common/models"
"context"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetArchitecturesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取架构列表
func NewGetArchitecturesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetArchitecturesLogic {
return &GetArchitecturesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetArchitecturesLogic) GetArchitectures(req *types.GetArchitecturesReq) (resp *types.GetArchitecturesRes, err error) {
// 构建查询条件
query := l.svcCtx.DB.Preload("App") // 预加载 App 信息
// 添加查询条件
if req.AppID != "" {
query = query.Where("app_id = ?", req.AppID)
}
if req.IsActive {
query = query.Where("is_active = ?", true)
}
// 使用 list_query 进行查询
list, total, err := list_query.ListQuery(l.svcCtx.DB.Preload("App"), update_models.UpdateArchitecture{}, list_query.Option{
PageInfo: models.PageInfo{
Page: req.Page,
Limit: req.PageSize,
},
Where: query,
})
if err != nil {
logx.Errorf("Failed to get architectures: %v", err)
return nil, err
}
// 构建响应
architectureList := make([]types.GetArchitecturesItem, 0, len(list))
for _, arch := range list {
architectureList = append(architectureList, types.GetArchitecturesItem{
Id: uint(arch.Id),
AppID: arch.AppID,
AppName: arch.App.Name, // 添加应用名称
PlatformID: arch.PlatformID,
ArchID: arch.ArchID,
Description: arch.Description,
IsActive: arch.IsActive,
CreatedAt: arch.CreatedAt.String(),
UpdatedAt: arch.UpdatedAt.String(),
})
}
return &types.GetArchitecturesRes{
Total: total,
Architectures: architectureList,
}, 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/logic/update/updatearchitecturelogic.go | app/backend/backend_admin/internal/logic/update/updatearchitecturelogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UpdateArchitectureLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 更新架构信息
func NewUpdateArchitectureLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateArchitectureLogic {
return &UpdateArchitectureLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateArchitectureLogic) UpdateArchitecture(req *types.UpdateArchitectureReq) (resp *types.UpdateArchitectureRes, err error) {
// 检查架构是否存在
var arch update_models.UpdateArchitecture
if err := l.svcCtx.DB.First(&arch, req.Id).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("architecture not found")
}
return nil, err
}
// 构建更新数据
updates := make(map[string]interface{})
if req.Description != "" {
updates["description"] = req.Description
}
updates["is_active"] = req.IsActive
// 执行更新
if err := l.svcCtx.DB.Model(&arch).Updates(updates).Error; err != nil {
logx.Errorf("Failed to update architecture: %v", err)
return nil, err
}
return &types.UpdateArchitectureRes{}, 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/logic/update/getappversionslogic.go | app/backend/backend_admin/internal/logic/update/getappversionslogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetAppVersionsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取应用下所有版本
func NewGetAppVersionsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAppVersionsLogic {
return &GetAppVersionsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetAppVersionsLogic) GetAppVersions(req *types.GetAppVersionsReq) (resp *types.GetAppVersionsRes, err error) {
// 构建查询条件
query := l.svcCtx.DB.Model(&update_models.UpdateArchitecture{})
// 应用ID过滤
if req.AppID != "" {
query = query.Where("app_id = ?", req.AppID)
}
// 只查询活跃的架构
query = query.Where("is_active = ?", true)
// 获取总数
var total int64
if err := query.Count(&total).Error; err != nil {
logx.Errorf("Failed to count architectures: %v", err)
return nil, fmt.Errorf("获取架构总数失败")
}
// 分页
if req.Page <= 0 {
req.Page = 1
}
if req.PageSize <= 0 {
req.PageSize = 10
}
offset := (req.Page - 1) * req.PageSize
// 查询架构列表
var architectures []update_models.UpdateArchitecture
if err := query.Offset(offset).Limit(req.PageSize).Order("created_at DESC").Find(&architectures).Error; err != nil {
logx.Errorf("Failed to get architectures: %v", err)
return nil, fmt.Errorf("获取架构列表失败")
}
// 转换为响应格式
var architectureInfos []types.GetAppVersionsItem
for _, arch := range architectures {
// 查询该架构下的版本
var versions []update_models.UpdateVersion
if err := l.svcCtx.DB.Where("architecture_id = ?", arch.Id).Order("created_at DESC").Find(&versions).Error; err != nil {
logx.Errorf("Failed to get versions for architecture %d: %v", arch.Id, err)
continue
}
// 转换为简化版本信息
var simpleVersions []types.GetAppVersionsVersionItem
for _, version := range versions {
simpleVersions = append(simpleVersions, types.GetAppVersionsVersionItem{
VersionID: uint(version.Id),
Version: version.Version,
})
}
architectureInfo := types.GetAppVersionsItem{
ArchitectureID: uint(arch.Id),
ArchID: arch.ArchID,
Description: arch.Description,
Versions: simpleVersions,
}
architectureInfos = append(architectureInfos, architectureInfo)
}
return &types.GetAppVersionsRes{
Total: total,
Architectures: architectureInfos,
}, 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/logic/update/getversionlistlogic.go | app/backend/backend_admin/internal/logic/update/getversionlistlogic.go | package logic
import (
"beaver/app/update/update_models"
"beaver/common/list_query"
"beaver/common/models"
"context"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetVersionListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取版本列表
func NewGetVersionListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVersionListLogic {
return &GetVersionListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetVersionListLogic) GetVersionList(req *types.GetVersionListReq) (resp *types.GetVersionListRes, err error) {
// 构建查询条件
query := l.svcCtx.DB
// 添加查询条件
if req.ArchitectureID > 0 {
query = query.Where("architecture_id = ?", req.ArchitectureID)
}
// 使用 list_query 进行查询
list, total, err := list_query.ListQuery(l.svcCtx.DB.Preload("Architecture"), update_models.UpdateVersion{}, list_query.Option{
PageInfo: models.PageInfo{
Page: req.Page,
Limit: req.PageSize,
},
Where: query,
})
if err != nil {
logx.Errorf("Failed to get versions: %v", err)
return nil, err
}
// 构建响应
versionList := make([]types.GetVersionListItem, 0, len(list))
for _, ver := range list {
versionList = append(versionList, types.GetVersionListItem{
VersionID: uint(ver.Id),
ArchitectureID: ver.ArchitectureID,
Version: ver.Version,
FileKey: ver.FileKey,
Description: ver.Description,
ReleaseNotes: ver.ReleaseNotes,
CreatedAt: ver.CreatedAt.String(),
UpdatedAt: ver.UpdatedAt.String(),
})
}
return &types.GetVersionListRes{
Total: total,
Versions: versionList,
}, 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/logic/update/addarchitecturelogic.go | app/backend/backend_admin/internal/logic/update/addarchitecturelogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type AddArchitectureLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 添加新架构
func NewAddArchitectureLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddArchitectureLogic {
return &AddArchitectureLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AddArchitectureLogic) AddArchitecture(req *types.AddArchitectureReq) (resp *types.AddArchitectureRes, err error) {
// 检查应用是否存在
var app update_models.UpdateApp
if err := l.svcCtx.DB.Where("app_id = ?", req.AppID).First(&app).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("app not found")
}
return nil, err
}
fmt.Println("1111111111111111111111111111111")
// 检查是否已存在相同的架构
var existingArch update_models.UpdateArchitecture
if err := l.svcCtx.DB.Where("app_id = ? AND platform_id = ? AND arch_id = ?",
req.AppID, req.PlatformID, req.ArchID).First(&existingArch).Error; err == nil {
return nil, fmt.Errorf("architecture already exists")
} else if err != gorm.ErrRecordNotFound {
return nil, err
}
fmt.Println("22222222222222222222222222222222222")
// 创建新架构
arch := update_models.UpdateArchitecture{
AppID: req.AppID,
PlatformID: req.PlatformID,
ArchID: req.ArchID,
Description: req.Description,
IsActive: true, // 默认为活跃状态
}
fmt.Println("333333333333333333333333333333333333333")
if err := l.svcCtx.DB.Create(&arch).Error; err != nil {
logx.Errorf("Failed to create architecture: %v", err)
return nil, err
}
fmt.Println("44444444444444444444444444444444444")
return &types.AddArchitectureRes{
Id: uint(arch.Id),
}, 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/logic/update/updatecitystrategylogic.go | app/backend/backend_admin/internal/logic/update/updatecitystrategylogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UpdateCityStrategyLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 更新城市策略
func NewUpdateCityStrategyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateCityStrategyLogic {
return &UpdateCityStrategyLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateCityStrategyLogic) UpdateCityStrategy(req *types.UpdateCityStrategyReq) (resp *types.UpdateCityStrategyRes, err error) {
// 验证请求参数
if req.AppID == "" {
return nil, fmt.Errorf("应用ID不能为空")
}
if len(req.CityIDs) == 0 {
return nil, fmt.Errorf("城市ID列表不能为空")
}
if len(req.Strategy) == 0 {
return nil, fmt.Errorf("策略配置不能为空")
}
// 批量更新每个城市的策略
for _, cityID := range req.CityIDs {
if err := l.updateSingleCityStrategy(req.AppID, cityID, req.Strategy, req.UpdateType); err != nil {
logx.Errorf("Failed to update city strategy for city %s: %v", cityID, err)
return nil, fmt.Errorf("更新城市 %s 策略失败: %v", cityID, err)
}
}
logx.Infof("Successfully updated city strategies for app %s, cities: %v", req.AppID, req.CityIDs)
return &types.UpdateCityStrategyRes{}, nil
}
// updateSingleCityStrategy 更新单个城市的策略
func (l *UpdateCityStrategyLogic) updateSingleCityStrategy(appID, cityID string, newStrategy []types.UpdateCityStrategyItem, updateType string) error {
// 查找或创建城市策略记录
var strategy update_models.UpdateStrategy
err := l.svcCtx.DB.Where("app_id = ? AND city_id = ?", appID, cityID).First(&strategy).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
// 创建新的城市策略记录
strategy = update_models.UpdateStrategy{
AppID: appID,
CityID: cityID,
Strategy: &update_models.Strategy{},
IsActive: true,
}
} else {
return fmt.Errorf("查询城市策略失败: %v", err)
}
}
// 转换新的策略数据
var newStrategyInfos []update_models.StrategyInfo
for _, s := range newStrategy {
newStrategyInfos = append(newStrategyInfos, update_models.StrategyInfo{
ArchitectureID: s.ArchitectureID,
VersionID: s.VersionID,
ForceUpdate: s.ForceUpdate,
IsActive: s.IsActive,
})
}
var updatedStrategy update_models.Strategy
if updateType == "global" {
// 全局更新：直接替换所有策略
updatedStrategy = update_models.Strategy(newStrategyInfos)
} else {
// 单个架构更新：合并现有策略和新策略
existingStrategy := strategy.Strategy
if existingStrategy == nil {
existingStrategy = &update_models.Strategy{}
}
// 创建架构ID到策略的映射
strategyMap := make(map[uint]update_models.StrategyInfo)
for _, s := range *existingStrategy {
strategyMap[s.ArchitectureID] = s
}
// 更新或添加新策略
for _, newS := range newStrategyInfos {
strategyMap[newS.ArchitectureID] = newS
}
// 转换回数组
var mergedStrategy []update_models.StrategyInfo
for _, s := range strategyMap {
mergedStrategy = append(mergedStrategy, s)
}
updatedStrategy = update_models.Strategy(mergedStrategy)
}
// 更新数据库
if strategy.Id == 0 {
// 创建新记录
strategy.Strategy = &updatedStrategy
if err := l.svcCtx.DB.Create(&strategy).Error; err != nil {
return fmt.Errorf("创建城市策略失败: %v", err)
}
} else {
// 更新现有记录
updateData := map[string]interface{}{
"strategy": &updatedStrategy,
}
if err := l.svcCtx.DB.Model(&strategy).Updates(updateData).Error; err != nil {
return fmt.Errorf("更新城市策略失败: %v", err)
}
}
logx.Infof("Successfully updated city strategy for app %s, city %s, updateType: %s", appID, cityID, updateType)
return 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/logic/update/addversionlogic.go | app/backend/backend_admin/internal/logic/update/addversionlogic.go | package logic
import (
"beaver/app/update/update_models"
"context"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type AddVersionLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 添加新版本
func NewAddVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddVersionLogic {
return &AddVersionLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AddVersionLogic) AddVersion(req *types.AddVersionReq) (resp *types.AddVersionRes, err error) {
// 检查架构是否存在
var arch update_models.UpdateArchitecture
if err := l.svcCtx.DB.First(&arch, req.ArchitectureID).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("architecture not found")
}
return nil, err
}
// 解析发布时间
if err != nil {
return nil, fmt.Errorf("invalid release date format")
}
// 创建新版本
version := update_models.UpdateVersion{
ArchitectureID: req.ArchitectureID,
Version: req.Version,
FileKey: req.FileKey,
Description: req.Description,
ReleaseNotes: req.ReleaseNotes,
}
if err := l.svcCtx.DB.Create(&version).Error; err != nil {
logx.Errorf("Failed to create version: %v", err)
return nil, err
}
return &types.AddVersionRes{
VersionID: uint(version.Id),
}, 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/logic/update/addapplogic.go | app/backend/backend_admin/internal/logic/update/addapplogic.go | package logic
import (
"beaver/app/dictionary/dictionary_rpc/types/dictionary_rpc"
"beaver/app/update/update_models"
"context"
"errors"
"fmt"
"strings"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"github.com/google/uuid"
"github.com/zeromicro/go-zero/core/logx"
)
type AddAppLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 添加新应用
func NewAddAppLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddAppLogic {
return &AddAppLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AddAppLogic) AddApp(req *types.AddAppReq) (resp *types.AddAppRes, err error) {
// 检查应用名称是否已存在
var existingApp update_models.UpdateApp
if err := l.svcCtx.DB.Where("name = ?", req.Name).First(&existingApp).Error; err == nil {
return nil, fmt.Errorf("应用名称已存在")
}
// 创建新应用
app := update_models.UpdateApp{
Name: req.Name,
AppID: strings.Replace(uuid.New().String(), "-", "", -1),
Description: req.Description,
IsActive: true, // 默认为活跃状态
Icon: "",
}
if err := l.svcCtx.DB.Create(&app).Error; err != nil {
logx.Errorf("Failed to create app: %v", err)
return nil, errors.New("创建应用失败")
}
// 为新应用自动初始化所有城市的策略
if err := l.initCityStrategiesForApp(app.AppID); err != nil {
logx.Errorf("Failed to init city strategies for app %s: %v", app.AppID, err)
// 不返回错误，因为应用创建成功了，只是策略初始化失败
}
return &types.AddAppRes{
Id: uint(app.Id),
AppID: app.AppID,
}, nil
}
// 为新应用初始化所有城市的策略
func (l *AddAppLogic) initCityStrategiesForApp(appID string) error {
// 通过 RPC 调用获取城市列表
citiesRes, err := l.svcCtx.DictionaryRpc.GetCities(l.ctx, &dictionary_rpc.GetCitiesReq{})
if err != nil {
return fmt.Errorf("获取城市列表失败: %v", err)
}
for _, city := range citiesRes.Cities {
// 检查城市策略是否已存在
var count int64
l.svcCtx.DB.Model(&update_models.UpdateStrategy{}).
Where("app_id = ? AND city_id = ?", appID, city.CityId).
Count(&count)
if count == 0 {
// 城市策略不存在，创建默认策略
defaultStrategy := &update_models.Strategy{}
newStrategy := update_models.UpdateStrategy{
AppID: appID,
CityID: city.CityId,
Strategy: defaultStrategy,
IsActive: true,
}
if err := l.svcCtx.DB.Create(&newStrategy).Error; err != nil {
return fmt.Errorf("创建城市策略失败 (App: %s, City: %s): %v", appID, city.CityId, err)
}
logx.Infof("已为应用 %s 创建城市策略: %s (%s)", appID, city.CityName, city.CityId)
}
}
logx.Infof("成功为应用 %s 初始化了 %d 个城市的策略", appID, len(citiesRes.Cities))
return 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/logic/friend/deletefriendlogic.go | app/backend/backend_admin/internal/logic/friend/deletefriendlogic.go | package logic
import (
"context"
"errors"
"strconv"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type DeleteFriendLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 强制删除好友关系
func NewDeleteFriendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteFriendLogic {
return &DeleteFriendLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteFriendLogic) DeleteFriend(req *types.DeleteFriendReq) (resp *types.DeleteFriendRes, err error) {
// 转换ID
friendID, err := strconv.ParseUint(req.FriendID, 10, 32)
if err != nil {
logx.Errorf("无效的好友关系ID: %s", req.FriendID)
return nil, errors.New("无效的好友关系ID")
}
// 先查询好友关系是否存在
var friend friend_models.FriendModel
err = l.svcCtx.DB.Where("id = ?", uint(friendID)).First(&friend).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logx.Errorf("好友关系不存在, Id: %s", req.FriendID)
return nil, errors.New("好友关系不存在")
}
logx.Errorf("查询好友关系失败: %v", err)
return nil, err
}
// 强制删除好友关系（物理删除）
err = l.svcCtx.DB.Unscoped().Delete(&friend).Error
if err != nil {
logx.Errorf("删除好友关系失败: %v", err)
return nil, err
}
logx.Infof("好友关系删除成功, Id: %s, SendUserID: %s, RevUserID: %s",
req.FriendID, friend.SendUserID, friend.RevUserID)
return &types.DeleteFriendRes{}, 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/logic/friend/batchdeletefriendslogic.go | app/backend/backend_admin/internal/logic/friend/batchdeletefriendslogic.go | package logic
import (
"context"
"errors"
"fmt"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"github.com/zeromicro/go-zero/core/logx"
)
type BatchDeleteFriendsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 批量删除好友关系
func NewBatchDeleteFriendsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteFriendsLogic {
return &BatchDeleteFriendsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *BatchDeleteFriendsLogic) BatchDeleteFriends(req *types.BatchDeleteFriendsReq) (resp *types.BatchDeleteFriendsRes, err error) {
// 转换好友ID列表
friendIDs := make([]string, 0, len(req.Ids))
for _, id := range req.Ids {
if len(id) == 0 {
logx.Errorf("无效的好友关系ID: %s", id)
return nil, fmt.Errorf("无效的好友关系ID: %s", id)
}
friendIDs = append(friendIDs, id)
}
// 先查询要删除的好友关系
var friends []friend_models.FriendModel
err = l.svcCtx.DB.Where("friend_id IN ?", friendIDs).Find(&friends).Error
if err != nil {
logx.Errorf("查询要删除的好友关系失败: %v", err)
return nil, err
}
if len(friends) == 0 {
return nil, errors.New("没有找到要删除的好友关系")
}
// 批量删除好友关系（物理删除）
err = l.svcCtx.DB.Unscoped().Where("friend_id IN ?", friendIDs).Delete(&friend_models.FriendModel{}).Error
if err != nil {
logx.Errorf("批量删除好友关系失败: %v", err)
return nil, err
}
logx.Infof("批量删除好友关系完成, 删除数量: %d", len(friends))
for _, friend := range friends {
logx.Infof("删除好友关系 - friendId: %s, SendUserID: %s, RevUserID: %s",
friend.FriendID, friend.SendUserID, friend.RevUserID)
}
return &types.BatchDeleteFriendsRes{}, 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/logic/friend/getfrienddetaillogic.go | app/backend/backend_admin/internal/logic/friend/getfrienddetaillogic.go | package logic
import (
"context"
"errors"
"fmt"
"strconv"
"time"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type GetFriendDetailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取好友关系详情
func NewGetFriendDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetFriendDetailLogic {
return &GetFriendDetailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetFriendDetailLogic) GetFriendDetail(req *types.GetFriendDetailReq) (resp *types.GetFriendDetailRes, err error) {
// 转换ID
friendID, err := strconv.ParseUint(req.FriendID, 10, 32)
if err != nil {
logx.Errorf("无效的好友关系ID: %s", req.FriendID)
return nil, errors.New("无效的好友关系ID")
}
var friend friend_models.FriendModel
err = l.svcCtx.DB.Where("id = ?", uint(friendID)).
First(&friend).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logx.Errorf("好友关系不存在, Id: %s", req.FriendID)
return nil, errors.New("好友关系不存在")
}
logx.Errorf("查询好友关系详情失败: %v", err)
return nil, err
}
var sendUserName, sendUserFileName, revUserName, revUserFileName string
// 查询发送者信息
if friend.SendUserID != "" {
var sendUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", friend.SendUserID).First(&sendUser).Error; err == nil {
sendUserName = sendUser.NickName
sendUserFileName = sendUser.Avatar
}
}
// 查询接收者信息
if friend.RevUserID != "" {
var revUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", friend.RevUserID).First(&revUser).Error; err == nil {
revUserName = revUser.NickName
revUserFileName = revUser.Avatar
}
}
return &types.GetFriendDetailRes{
Id: fmt.Sprintf("%d", friend.Id),
SendUserId: friend.SendUserID,
SendUserName: sendUserName,
SendUserFileName: sendUserFileName,
RevUserId: friend.RevUserID,
RevUserName: revUserName,
RevUserFileName: revUserFileName,
SendUserNotice: friend.SendUserNotice,
RevUserNotice: friend.RevUserNotice,
IsDeleted: friend.IsDeleted,
CreateTime: time.Time(friend.CreatedAt).Format(time.RFC3339),
UpdateTime: time.Time(friend.UpdatedAt).Format(time.RFC3339),
}, 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/logic/friend/getfriendverifylistlogic.go | app/backend/backend_admin/internal/logic/friend/getfriendverifylistlogic.go | package logic
import (
"context"
"fmt"
"time"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetFriendVerifyListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取好友验证列表
func NewGetFriendVerifyListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetFriendVerifyListLogic {
return &GetFriendVerifyListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetFriendVerifyListLogic) GetFriendVerifyList(req *types.GetFriendVerifyListReq) (resp *types.GetFriendVerifyListRes, err error) {
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
pageSize := req.PageSize
if pageSize <= 0 {
pageSize = 10
}
if pageSize > 100 {
pageSize = 100
}
// 构建查询条件
query := l.svcCtx.DB.Model(&friend_models.FriendVerifyModel{})
// 按发送用户ID筛选
if req.SendUserId != "" {
query = query.Where("send_user_id = ?", req.SendUserId)
}
// 按接收用户ID筛选
if req.RevUserId != "" {
query = query.Where("rev_user_id = ?", req.RevUserId)
}
// 按发送方状态筛选
if req.SendStatus > 0 {
query = query.Where("send_status = ?", req.SendStatus)
}
// 按接收方状态筛选
if req.RevStatus > 0 {
query = query.Where("rev_status = ?", req.RevStatus)
}
// 时间范围筛选
if req.StartTime != "" {
query = query.Where("created_at >= ?", req.StartTime)
}
if req.EndTime != "" {
query = query.Where("created_at <= ?", req.EndTime)
}
// 查询总数
var total int64
err = query.Count(&total).Error
if err != nil {
logx.Errorf("查询好友验证总数失败: %v", err)
return nil, err
}
// 查询列表
var verifies []friend_models.FriendVerifyModel
err = query.Order("created_at DESC").
Offset((page - 1) * pageSize).
Limit(pageSize).
Find(&verifies).Error
if err != nil {
logx.Errorf("查询好友验证列表失败: %v", err)
return nil, err
}
// 转换为响应格式
list := make([]types.GetFriendVerifyListItem, len(verifies))
for i, verify := range verifies {
var sendUserName, revUserName string
// 查询发送者信息
if verify.SendUserID != "" {
var sendUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", verify.SendUserID).First(&sendUser).Error; err == nil {
sendUserName = sendUser.NickName
}
}
// 查询接收者信息
if verify.RevUserID != "" {
var revUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", verify.RevUserID).First(&revUser).Error; err == nil {
revUserName = revUser.NickName
}
}
list[i] = types.GetFriendVerifyListItem{
Id: fmt.Sprintf("%d", verify.Id),
SendUserId: verify.SendUserID,
SendUserName: sendUserName,
RevUserId: verify.RevUserID,
RevUserName: revUserName,
SendStatus: int(verify.SendStatus),
RevStatus: int(verify.RevStatus),
Message: verify.Message,
CreateTime: time.Time(verify.CreatedAt).Format(time.RFC3339),
UpdateTime: time.Time(verify.UpdatedAt).Format(time.RFC3339),
}
}
return &types.GetFriendVerifyListRes{
List: list,
Total: total,
}, 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/logic/friend/deletefriendverifylogic.go | app/backend/backend_admin/internal/logic/friend/deletefriendverifylogic.go | package logic
import (
"context"
"errors"
"strconv"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type DeleteFriendVerifyLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 删除好友验证记录
func NewDeleteFriendVerifyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteFriendVerifyLogic {
return &DeleteFriendVerifyLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteFriendVerifyLogic) DeleteFriendVerify(req *types.DeleteFriendVerifyReq) (resp *types.DeleteFriendVerifyRes, err error) {
// 转换ID
verifyID, err := strconv.ParseUint(req.VerifyID, 10, 32)
if err != nil {
logx.Errorf("无效的好友验证ID: %s", req.VerifyID)
return nil, errors.New("无效的好友验证ID")
}
// 先查询好友验证记录是否存在
var verify friend_models.FriendVerifyModel
err = l.svcCtx.DB.Where("id = ?", uint(verifyID)).First(&verify).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logx.Errorf("好友验证记录不存在, Id: %s", req.VerifyID)
return nil, errors.New("好友验证记录不存在")
}
logx.Errorf("查询好友验证记录失败: %v", err)
return nil, err
}
// 删除好友验证记录
err = l.svcCtx.DB.Delete(&verify).Error
if err != nil {
logx.Errorf("删除好友验证记录失败: %v", err)
return nil, err
}
logx.Infof("好友验证记录删除成功, Id: %s, SendUserID: %s, RevUserID: %s",
req.VerifyID, verify.SendUserID, verify.RevUserID)
return &types.DeleteFriendVerifyRes{}, 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/logic/friend/getfriendverifydetaillogic.go | app/backend/backend_admin/internal/logic/friend/getfriendverifydetaillogic.go | package logic
import (
"context"
"errors"
"fmt"
"strconv"
"time"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type GetFriendVerifyDetailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取好友验证详情
func NewGetFriendVerifyDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetFriendVerifyDetailLogic {
return &GetFriendVerifyDetailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetFriendVerifyDetailLogic) GetFriendVerifyDetail(req *types.GetFriendVerifyDetailReq) (resp *types.GetFriendVerifyDetailRes, err error) {
// 转换ID
verifyID, err := strconv.ParseUint(req.VerifyID, 10, 32)
if err != nil {
logx.Errorf("无效的好友验证ID: %s", req.VerifyID)
return nil, errors.New("无效的好友验证ID")
}
var verify friend_models.FriendVerifyModel
err = l.svcCtx.DB.Where("id = ?", uint(verifyID)).
First(&verify).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logx.Errorf("好友验证不存在, Id: %s", req.VerifyID)
return nil, errors.New("好友验证不存在")
}
logx.Errorf("查询好友验证详情失败: %v", err)
return nil, err
}
var sendUserName, sendUserFileName, revUserName, revUserFileName string
// 查询发送者信息
if verify.SendUserID != "" {
var sendUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", verify.SendUserID).First(&sendUser).Error; err == nil {
sendUserName = sendUser.NickName
sendUserFileName = sendUser.Avatar
}
}
// 查询接收者信息
if verify.RevUserID != "" {
var revUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", verify.RevUserID).First(&revUser).Error; err == nil {
revUserName = revUser.NickName
revUserFileName = revUser.Avatar
}
}
return &types.GetFriendVerifyDetailRes{
Id: fmt.Sprintf("%d", verify.Id),
SendUserId: verify.SendUserID,
SendUserName: sendUserName,
SendUserFileName: sendUserFileName,
RevUserId: verify.RevUserID,
RevUserName: revUserName,
RevUserFileName: revUserFileName,
SendStatus: int(verify.SendStatus),
RevStatus: int(verify.RevStatus),
Message: verify.Message,
CreateTime: time.Time(verify.CreatedAt).Format(time.RFC3339),
UpdateTime: time.Time(verify.UpdatedAt).Format(time.RFC3339),
}, 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/logic/friend/restorefriendlogic.go | app/backend/backend_admin/internal/logic/friend/restorefriendlogic.go | package logic
import (
"context"
"errors"
"strconv"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type RestoreFriendLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 恢复好友关系
func NewRestoreFriendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RestoreFriendLogic {
return &RestoreFriendLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *RestoreFriendLogic) RestoreFriend(req *types.RestoreFriendReq) (resp *types.RestoreFriendRes, err error) {
// 转换ID
friendID, err := strconv.ParseUint(req.FriendID, 10, 32)
if err != nil {
logx.Errorf("无效的好友关系ID: %s", req.FriendID)
return nil, errors.New("无效的好友关系ID")
}
// 先查询好友关系是否存在
var friend friend_models.FriendModel
err = l.svcCtx.DB.Where("id = ?", uint(friendID)).First(&friend).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logx.Errorf("好友关系不存在, Id: %s", req.FriendID)
return nil, errors.New("好友关系不存在")
}
logx.Errorf("查询好友关系失败: %v", err)
return nil, err
}
// 检查是否已经是未删除状态
if !friend.IsDeleted {
logx.Infof("好友关系已经是未删除状态, Id: %s", req.FriendID)
return &types.RestoreFriendRes{}, nil
}
// 恢复好友关系（设置IsDeleted为false）
err = l.svcCtx.DB.Model(&friend).Update("is_deleted", false).Error
if err != nil {
logx.Errorf("恢复好友关系失败: %v", err)
return nil, err
}
logx.Infof("好友关系恢复成功, Id: %s, SendUserID: %s, RevUserID: %s",
req.FriendID, friend.SendUserID, friend.RevUserID)
return &types.RestoreFriendRes{}, 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/logic/friend/getfriendlistlogic.go | app/backend/backend_admin/internal/logic/friend/getfriendlistlogic.go | package logic
import (
"context"
"time"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"beaver/app/user/user_models"
"github.com/zeromicro/go-zero/core/logx"
)
type GetFriendListLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取好友关系列表
func NewGetFriendListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetFriendListLogic {
return &GetFriendListLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetFriendListLogic) GetFriendList(req *types.GetFriendListReq) (resp *types.GetFriendListRes, err error) {
// 设置默认分页参数
page := req.Page
if page <= 0 {
page = 1
}
pageSize := req.PageSize
if pageSize <= 0 {
pageSize = 10
}
if pageSize > 100 {
pageSize = 100
}
// 构建查询条件
query := l.svcCtx.DB.Model(&friend_models.FriendModel{})
// 按用户ID筛选
if req.UserID != "" {
query = query.Where("send_user_id = ? OR rev_user_id = ?", req.UserID, req.UserID)
}
// 按好友ID筛选
if req.FriendID != "" {
query = query.Where("send_user_id = ? OR rev_user_id = ?", req.FriendID, req.FriendID)
}
// 按删除状态筛选
if req.IsDeleted {
query = query.Where("is_deleted = ?", req.IsDeleted)
} else {
query = query.Where("is_deleted = false")
}
// 时间范围筛选
if req.StartTime != "" {
query = query.Where("created_at >= ?", req.StartTime)
}
if req.EndTime != "" {
query = query.Where("created_at <= ?", req.EndTime)
}
// 查询总数
var total int64
err = query.Count(&total).Error
if err != nil {
logx.Errorf("查询好友关系总数失败: %v", err)
return nil, err
}
// 查询列表
var friends []friend_models.FriendModel
err = query.Order("created_at DESC").
Offset((page - 1) * pageSize).
Limit(pageSize).
Find(&friends).Error
if err != nil {
logx.Errorf("查询好友关系列表失败: %v", err)
return nil, err
}
// 转换为响应格式
list := make([]types.GetFriendListItem, len(friends))
for i, friend := range friends {
var sendUserName, revUserName string
// 查询发送者信息
if friend.SendUserID != "" {
var sendUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", friend.SendUserID).First(&sendUser).Error; err == nil {
sendUserName = sendUser.NickName
}
}
// 查询接收者信息
if friend.RevUserID != "" {
var revUser user_models.UserModel
if err := l.svcCtx.DB.Where("user_id = ?", friend.RevUserID).First(&revUser).Error; err == nil {
revUserName = revUser.NickName
}
}
list[i] = types.GetFriendListItem{
Id: friend.FriendID, // 使用友链ID
SendUserId: friend.SendUserID,
SendUserName: sendUserName,
RevUserId: friend.RevUserID,
RevUserName: revUserName,
SendUserNotice: friend.SendUserNotice,
RevUserNotice: friend.RevUserNotice,
IsDeleted: friend.IsDeleted,
CreateTime: time.Time(friend.CreatedAt).Format(time.RFC3339),
UpdateTime: time.Time(friend.UpdatedAt).Format(time.RFC3339),
}
}
return &types.GetFriendListRes{
List: list,
Total: total,
}, 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/logic/friend/batchdeletefriendverifylogic.go | app/backend/backend_admin/internal/logic/friend/batchdeletefriendverifylogic.go | package logic
import (
"context"
"errors"
"fmt"
"strconv"
"beaver/app/backend/backend_admin/internal/svc"
"beaver/app/backend/backend_admin/internal/types"
"beaver/app/friend/friend_models"
"github.com/zeromicro/go-zero/core/logx"
)
type BatchDeleteFriendVerifyLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 批量删除好友验证记录
func NewBatchDeleteFriendVerifyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteFriendVerifyLogic {
return &BatchDeleteFriendVerifyLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *BatchDeleteFriendVerifyLogic) BatchDeleteFriendVerify(req *types.BatchDeleteFriendVerifyReq) (resp *types.BatchDeleteFriendVerifyRes, err error) {
if len(req.Ids) == 0 {
return nil, errors.New("删除的好友验证ID列表不能为空")
}
// 转换字符串ID为uint切片
var verifyIDs []uint
for _, idStr := range req.Ids {
verifyID, err := strconv.ParseUint(idStr, 10, 32)
if err != nil {
logx.Errorf("无效的好友验证ID: %s", idStr)
return nil, fmt.Errorf("无效的好友验证ID: %s", idStr)
}
verifyIDs = append(verifyIDs, uint(verifyID))
}
// 先查询要删除的好友验证记录
var verifies []friend_models.FriendVerifyModel
err = l.svcCtx.DB.Where("id IN ?", verifyIDs).Find(&verifies).Error
if err != nil {
logx.Errorf("查询要删除的好友验证记录失败: %v", err)
return nil, err
}
if len(verifies) == 0 {
return nil, errors.New("没有找到要删除的好友验证记录")
}
// 批量删除好友验证记录
err = l.svcCtx.DB.Where("id IN ?", verifyIDs).Delete(&friend_models.FriendVerifyModel{}).Error
if err != nil {
logx.Errorf("批量删除好友验证记录失败: %v", err)
return nil, err
}
logx.Infof("批量删除好友验证记录完成, 删除数量: %d", len(verifies))
for _, verify := range verifies {
logx.Infof("删除好友验证记录 - Id: %d, SendUserID: %s, RevUserID: %s",
verify.Id, verify.SendUserID, verify.RevUserID)
}
return &types.BatchDeleteFriendVerifyRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/ws.go | app/ws/ws_api/ws.go | package main
import (
"flag"
"fmt"
"beaver/app/ws/ws_api/internal/config"
"beaver/app/ws/ws_api/internal/handler"
"beaver/app/ws/ws_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/ws.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)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
server.Use(middleware.LogMiddleware)
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/ws/ws_api/types/msg.go | app/ws/ws_api/types/msg.go | package type_struct
import "encoding/json"
type BodySendMsg struct {
ConversationID string `json:"conversationId"`
MessageID string `json:"messageId"` // 客户端消息ID
Msg json.RawMessage `json:"msg"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/types/proxy.go | app/ws/ws_api/types/proxy.go | package type_struct
import "encoding/json"
type BodyProxyMsg struct {
ConversationID string `json:"conversationId"`
Content json.RawMessage `json:"content"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/types/ws.go | app/ws/ws_api/types/ws.go | package type_struct
import (
"beaver/common/wsEnum/wsTypeConst"
"encoding/json"
)
type WsContent struct {
Timestamp int64 `json:"timestamp"` //消息发送时间
MessageID string `json:"messageId"` //客户端消息ID
Data WsData `json:"data"` //消息内容
}
type WsData struct {
Type wsTypeConst.Type `json:"type"` // 消息类型
ConversationID string `json:"conversationId"` // 会话ID
Body json.RawMessage `json:"body"` // 消息内容
}
type WsMessage struct {
Command string `json:"command"` //命令
Content WsContent `json:"content"` //消息内容
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/redis_ws/utils.go | app/ws/ws_api/internal/redis_ws/utils.go | package redis_ws
import (
"fmt"
"os"
"github.com/go-redis/redis"
)
// GetWSManager 获取WebSocket管理器实例
func GetWSManager(client *redis.Client) *WSManager {
serverID := fmt.Sprintf("%s_%d", getHostname(), os.Getpid())
return NewWSManager(client, serverID)
}
// getHostname 获取主机名
func getHostname() string {
hostname, err := os.Hostname()
if err != nil {
return "unknown"
}
return hostname
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/redis_ws/manager.go | app/ws/ws_api/internal/redis_ws/manager.go | package redis_ws
import (
"encoding/json"
"fmt"
"time"
"github.com/go-redis/redis"
)
// WSConnectionInfo WebSocket连接信息
type WSConnectionInfo struct {
/**
* userId: 用户ID
*/
UserID string `json:"userId"`
/**
* deviceType: 设备类型
*/
DeviceType string `json:"deviceType"`
/**
* serverId: 服务器ID
*/
ServerID string `json:"serverId"`
/**
* connId: 连接ID
*/
ConnID string `json:"connId"`
/**
* loginTime: 登录时间
*/
LoginTime int64 `json:"loginTime"`
}
// WSManager Redis WebSocket管理器
type WSManager struct {
client *redis.Client
serverID string
}
// NewWSManager 创建Redis WebSocket管理器
func NewWSManager(client *redis.Client, serverID string) *WSManager {
return &WSManager{
client: client,
serverID: serverID,
}
}
// AddConnection 添加连接
func (m *WSManager) AddConnection(userID, deviceType, connID string) error {
key := fmt.Sprintf("ws:conn:%s:%s", userID, deviceType)
info := WSConnectionInfo{
UserID: userID,
DeviceType: deviceType,
ServerID: m.serverID,
ConnID: connID,
LoginTime: time.Now().Unix(),
}
data, _ := json.Marshal(info)
return m.client.HSet(key, connID, data).Err()
}
// RemoveConnection 移除连接
func (m *WSManager) RemoveConnection(userID, deviceType, connID string) error {
key := fmt.Sprintf("ws:conn:%s:%s", userID, deviceType)
return m.client.HDel(key, connID).Err()
}
// GetUserConnections 获取用户连接
func (m *WSManager) GetUserConnections(userID string) ([]WSConnectionInfo, error) {
pattern := fmt.Sprintf("ws:conn:%s:*", userID)
keys, err := m.client.Keys(pattern).Result()
if err != nil {
return nil, err
}
var connections []WSConnectionInfo
for _, key := range keys {
conns, err := m.client.HGetAll(key).Result()
if err != nil {
continue
}
for _, data := range conns {
var info WSConnectionInfo
if json.Unmarshal([]byte(data), &info) == nil {
connections = append(connections, info)
}
}
}
return connections, nil
}
// SendToUser 发送消息给用户（跨服务器）
func (m *WSManager) SendToUser(userID string, message []byte) error {
connections, err := m.GetUserConnections(userID)
if err != nil {
return err
}
for _, conn := range connections {
if conn.ServerID != m.serverID {
// 发送到其他服务器的消息队列
streamKey := fmt.Sprintf("ws:stream:%s", conn.ServerID)
m.client.XAdd(&redis.XAddArgs{
Stream: streamKey,
Values: map[string]interface{}{
"connID": conn.ConnID,
"message": string(message),
},
})
}
}
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/svc/servicecontext.go | app/ws/ws_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/chat/chat_rpc/chat"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/group/group_rpc/group"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/ws/ws_api/internal/config"
"beaver/common/zrpc_interceptor"
"beaver/core"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
Redis *redis.Client
DB *gorm.DB
GroupRpc group_rpc.GroupClient
ChatRpc chat_rpc.ChatClient
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
return &ServiceContext{
DB: mysqlDb,
Redis: client,
Config: c,
GroupRpc: group.NewGroup(zrpc.MustNewClient(c.GroupRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
ChatRpc: chat.NewChat(zrpc.MustNewClient(c.ChatRpc, 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/ws/ws_api/internal/types/types.go | app/ws/ws_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
package types
type IBodySendMsg struct {
ConversationID string `json:"conversationId"`
MessageID string `json:"messageId"` // 客户端消息ID
Msg string `json:"msg"`
}
type MomentNotification struct {
Type uint `json:"type"` // 通知类型：1点赞 2评论
MomentID uint `json:"momentId"` // 朋友圈ID
UserID string `json:"userId"` // 触发者ID
Content string `json:"content"` // 通知内容
Timestamp int64 `json:"timestamp"` // 通知时间
}
type Msg struct {
Type uint `json:"type"` //消息类型 1:文本 2:图片 3:视频 4:文件 5、语音 6：语音通话 7：视频通话 8撤回消息 9：回复消息 10：引用消息
TextMsg string `json:"textMsg,optional"` //文本消息
ImgMsg string `json:"imgMsg,optional"` //图片消息
}
type ProxySendMsgReq struct {
UserID string `header:"Beaver-User-Id"` // 发送者ID
Command string `json:"command"` // 命令类型：send（发送）、recall（撤回）
TargetID string `json:"targetId"` // 目标ID（用户ID或群ID）
Type string `json:"type"` // 消息类型
ConversationId string `json:"conversationId,optional"` // 会话ID
Body map[string]interface{} `json:"body"` // 消息内容，需要包含 messageId
}
type ProxySendMsgRes struct {
}
type SendMsgReq struct {
UserID string `header:"Beaver-User-Id"` // 发送者ID
ConversationID string `json:"conversationId"` // 会话ID
MessageID string `json:"messageId"` // 客户端消息ID
Msg string `json:"msg"` // 消息内容
}
type SystemNotification struct {
Type uint `json:"type"` // 通知类型：1好友请求 2系统通知
Content string `json:"content"` // 通知内容
Timestamp int64 `json:"timestamp"` // 通知时间
}
type WsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，用于身份识别
Token string `header:"token"` // 用户token，用于验证
}
type WsRes struct {
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/config/config.go | app/ws/ws_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
Etcd string
GroupRpc zrpc.RpcClientConf
ChatRpc zrpc.RpcClientConf
WebSocket struct {
PongWait int
WriteWait int
PingPeriod int
MaxMessageSize int
AppHeartbeatInterval int
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/handler/proxysendmsghandler.go | app/ws/ws_api/internal/handler/proxysendmsghandler.go | package handler
import (
"net/http"
"beaver/app/ws/ws_api/internal/logic"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
"github.com/zeromicro/go-zero/rest/httpx"
)
func proxySendMsgHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ProxySendMsgReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := logic.NewProxySendMsgLogic(r.Context(), svcCtx)
resp, err := l.ProxySendMsg(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/handler/chatwebsockethandler.go | app/ws/ws_api/internal/handler/chatwebsockethandler.go | package handler
import (
"net/http"
"beaver/app/ws/ws_api/internal/logic"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
"github.com/zeromicro/go-zero/rest/httpx"
)
func chatWebsocketHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.WsReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := logic.NewChatWebsocketLogic(r.Context(), svcCtx)
resp, err := l.ChatWebsocket(&req, w, r)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/handler/routes.go | app/ws/ws_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
// goctl 1.8.5
package handler
import (
"net/http"
"beaver/app/ws/ws_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// HTTP API发送消息
Method: http.MethodPost,
Path: "/api/ws/proxySendMsg",
Handler: proxySendMsgHandler(serverCtx),
},
{
// WebSocket连接入口
Method: http.MethodGet,
Path: "/api/ws/ws",
Handler: chatWebsocketHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/chatwebsocketlogic.go | app/ws/ws_api/internal/logic/chatwebsocketlogic.go | // Package logic 实现WebSocket聊天服务的业务逻辑
package logic
import (
"context"
"fmt"
"net/http"
"time"
ws "beaver/app/ws/ws_api/internal/logic/websocket"
"beaver/app/ws/ws_api/internal/logic/websocket/heartbeat"
websocket_utils "beaver/app/ws/ws_api/internal/logic/websocket/utils"
"beaver/app/ws/ws_api/internal/redis_ws"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
"beaver/utils/device"
"github.com/gorilla/websocket"
"github.com/zeromicro/go-zero/core/logx"
)
// ChatWebsocketLogic WebSocket聊天逻辑的结构体
// 实现WebSocket连接的建立、消息处理与管理
type ChatWebsocketLogic struct {
logx.Logger // 内嵌日志组件
ctx context.Context // 上下文，用于控制请求的生命周期
svcCtx *svc.ServiceContext // 服务上下文，包含配置和依赖
}
// NewChatWebsocketLogic 创建一个新的ChatWebsocketLogic实例
// ctx: 请求上下文
// svcCtx: 服务上下文
// 返回: *ChatWebsocketLogic 聊天WebSocket逻辑实例
func NewChatWebsocketLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ChatWebsocketLogic {
return &ChatWebsocketLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// ChatWebsocket 处理WebSocket连接请求的主函数
// req: WebSocket请求参数，包含用户ID等信息
// w: HTTP响应写入器
// r: HTTP请求
// 返回:
// - resp: WebSocket响应
// - err: 错误信息
func (l *ChatWebsocketLogic) ChatWebsocket(req *types.WsReq, w http.ResponseWriter, r *http.Request) (resp *types.WsRes, err error) {
// 将HTTP连接升级到WebSocket连接
conn, err := UpgradeToWebSocket(w, r)
if err != nil {
logx.Errorf("WebSocket升级失败, 用户: %s, 错误: %v", req.UserID, err)
return
}
// 配置WebSocket连接参数
configureWebSocketConn(conn, l.svcCtx)
// 创建心跳管理器
heartbeatManager := heartbeat.NewManager(conn, req.UserID, l.svcCtx)
defer heartbeatManager.Stop()
// 从User-Agent获取设备类型
userAgent := r.Header.Get("User-Agent")
logx.Infof("User-Agent: %s", userAgent)
deviceType := device.GetDeviceType(userAgent)
userKey := websocket_utils.GetUserKey(req.UserID, deviceType)
logx.Infof("用户上线: %s, 设备类型: %s, User-Agent: %s, 远程地址: %s", req.UserID, deviceType, userAgent, conn.RemoteAddr().String())
// 生成连接ID
connID := fmt.Sprintf("%s_%d", req.UserID, time.Now().UnixNano())
// 使用Redis管理器存储连接信息
wsManager := redis_ws.GetWSManager(l.svcCtx.Redis)
err = wsManager.AddConnection(req.UserID, deviceType, connID)
if err != nil {
logx.Errorf("Redis存储连接失败: %v", err)
}
// 当函数返回时关闭连接并清理资源
defer func() {
cleanupConnection(req.UserID, conn)
// 清理Redis中的连接信息
wsManager.RemoveConnection(req.UserID, deviceType, connID)
}()
// 管理连接映射
manageUserConnection(userKey, conn, req.UserID, deviceType)
// 启动心跳管理
heartbeatManager.Start()
// 处理WebSocket消息
ws.HandleWebSocketMessages(l.ctx, l.svcCtx, req, r, conn, heartbeatManager)
// WebSocket连接已建立，不需要返回HTTP响应
// 返回nil避免go-zero框架尝试写入HTTP响应头
return nil, nil
}
// manageUserConnection 管理用户连接
func manageUserConnection(userKey string, conn *websocket.Conn, userID, deviceType string) {
websocket_utils.WsMapMutex.Lock()
defer websocket_utils.WsMapMutex.Unlock()
addr := conn.RemoteAddr().String()
userWsInfo, ok := websocket_utils.UserOnlineWsMap[userKey]
// 检查连接数量限制
if ok {
// 桌面端和移动端限制为1个连接
if deviceType == "desktop" || deviceType == "mobile" {
if len(userWsInfo.WsClientMap) >= 1 {
// 关闭旧连接
for oldAddr, oldConn := range userWsInfo.WsClientMap {
logx.Infof("关闭旧连接，用户: %s, 设备: %s, 地址: %s", userID, deviceType, oldAddr)
oldConn.Close()
delete(userWsInfo.WsClientMap, oldAddr)
}
}
}
// 网页端允许多个连接（多个标签页）
userWsInfo.WsClientMap[addr] = conn
logx.Infof("添加连接映射, 用户: %s, 设备: %s, userKey: %s, 连接数: %d", userID, deviceType, userKey, len(userWsInfo.WsClientMap))
} else {
userWsInfo = &websocket_utils.UserWsInfo{
WsClientMap: map[string]*websocket.Conn{addr: conn},
}
websocket_utils.UserOnlineWsMap[userKey] = userWsInfo
logx.Infof("创建用户连接映射, 用户: %s, 设备: %s, userKey: %s", userID, deviceType, userKey)
}
// 打印当前用户的所有连接状态
logx.Infof("=== 用户连接状态 用户ID: %s ===", userID)
deviceTypes := []string{"desktop", "mobile", "web"}
for _, dt := range deviceTypes {
uk := websocket_utils.GetUserKey(userID, dt)
if info, exists := websocket_utils.UserOnlineWsMap[uk]; exists {
logx.Infof("设备类型: %s, userKey: %s, 连接数: %d", dt, uk, len(info.WsClientMap))
}
}
logx.Infof("=== 连接状态结束 ===")
}
// configureWebSocketConn 配置WebSocket连接的参数
// conn: 需要配置的WebSocket连接
// svcCtx: 服务上下文，包含配置信息
func configureWebSocketConn(conn *websocket.Conn, svcCtx *svc.ServiceContext) {
// 设置单个消息的最大大小限制
conn.SetReadLimit(int64(svcCtx.Config.WebSocket.MaxMessageSize))
// 设置读取超时时间
pongWait := time.Duration(svcCtx.Config.WebSocket.PongWait) * time.Second
conn.SetReadDeadline(time.Now().Add(pongWait))
// 设置Pong处理函数，当收到客户端的pong响应时重置读取超时
conn.SetPongHandler(func(string) error {
// 重置读取截止时间，延长连接生命周期
conn.SetReadDeadline(time.Now().Add(pongWait))
return nil
})
}
// UpgradeToWebSocket 将HTTP连接升级为WebSocket连接
// w: HTTP响应写入器
// r: HTTP请求
// 返回:
// - *websocket.Conn: 升级后的WebSocket连接
// - error: 升级过程中的错误
func UpgradeToWebSocket(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
// 创建WebSocket升级器
upGrader := websocket.Upgrader{
// 允许所有来源的跨域请求
CheckOrigin: func(r *http.Request) bool {
return true
},
}
// 执行升级
conn, err := upGrader.Upgrade(w, r, nil)
if err != nil {
return nil, err
}
return conn, nil
}
// cleanupConnection 清理用户连接资源
func cleanupConnection(userID string, conn *websocket.Conn) {
// 关闭连接
conn.Close()
// 获取连接地址
addr := conn.RemoteAddr().String()
logx.Infof("开始清理连接资源, 用户: %s, 地址: %s", userID, addr)
// 使用互斥锁保护共享资源操作
websocket_utils.WsMapMutex.Lock()
defer websocket_utils.WsMapMutex.Unlock()
// 遍历所有设备类型查找并清理连接
deviceTypes := []string{"desktop", "mobile", "web"}
for _, deviceType := range deviceTypes {
userKey := websocket_utils.GetUserKey(userID, deviceType)
userWsInfo, ok := websocket_utils.UserOnlineWsMap[userKey]
if ok {
delete(userWsInfo.WsClientMap, addr)
// 如果用户没有任何活跃连接，从用户映射中删除用户
if len(userWsInfo.WsClientMap) == 0 {
delete(websocket_utils.UserOnlineWsMap, userKey)
logx.Infof("删除用户连接映射, 用户: %s, 设备: %s", userID, deviceType)
} else {
logx.Infof("保留用户连接映射, 用户: %s, 设备: %s, 剩余连接数: %d", userID, deviceType, len(userWsInfo.WsClientMap))
}
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/proxysendmsglogic.go | app/ws/ws_api/internal/logic/proxysendmsglogic.go | package logic
import (
"context"
"encoding/json"
"fmt"
websocket_utils "beaver/app/ws/ws_api/internal/logic/websocket/utils"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
"beaver/common/wsEnum/wsTypeConst"
"github.com/zeromicro/go-zero/core/logx"
)
type ProxySendMsgLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewProxySendMsgLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ProxySendMsgLogic {
return &ProxySendMsgLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ProxySendMsgLogic) ProxySendMsg(req *types.ProxySendMsgReq) (resp *types.ProxySendMsgRes, err error) {
fmt.Println("收到ws转发的消息")
// 将map转换为json.RawMessage
bodyBytes, err := json.Marshal(req.Body)
if err != nil {
return nil, err
}
content := type_struct.WsContent{
Timestamp: 0,
Data: type_struct.WsData{
Type: wsTypeConst.Type(req.Type),
Body: bodyBytes,
ConversationID: req.ConversationId,
},
}
// 打印内容
fmt.Println("消息内容：", string(bodyBytes))
fmt.Println("发送者ID：", req.UserID, "，目标ID：", req.TargetID)
fmt.Println("命令类型：", req.Command, "，消息类型：", req.Type, "，会话ID：", req.ConversationId)
websocket_utils.SendMsgToUser(req.TargetID, wsCommandConst.Command(req.Command), content)
return
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/enter.go | app/ws/ws_api/internal/logic/websocket/enter.go | package ws
import (
"context"
"encoding/json"
"fmt"
"net/http"
"beaver/app/ws/ws_api/internal/logic/websocket/chat_message"
"beaver/app/ws/ws_api/internal/logic/websocket/heartbeat"
"beaver/app/ws/ws_api/internal/logic/websocket/proxy_message"
"beaver/app/ws/ws_api/internal/logic/websocket/webrtc_message"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
"github.com/gorilla/websocket"
)
func HandleWebSocketMessages(ctx context.Context, svcCtx *svc.ServiceContext, req *types.WsReq, r *http.Request, conn *websocket.Conn, heartbeatManager *heartbeat.Manager) {
for {
_, p, err := conn.ReadMessage()
if err != nil {
// 检查是否是正常关闭或网络错误
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
fmt.Printf("WebSocket连接异常关闭, 用户: %s, 错误: %v\n", req.UserID, err)
} else {
// 正常关闭包括 CloseNormalClosure (1000)
fmt.Printf("WebSocket连接正常关闭, 用户: %s, 错误: %v\n", req.UserID, err)
}
break
}
var wsMessage type_struct.WsMessage
fmt.Printf("收到ws消息, 用户: %s, 内容: %s\n", req.UserID, string(p))
err = json.Unmarshal(p, &wsMessage)
if err != nil {
fmt.Printf("消息解析错误, 用户: %s, 错误: %s, 原始消息: %s\n", req.UserID, err.Error(), string(p))
continue
}
if wsMessage.Command == "" {
fmt.Printf("command不能为空, 用户: %s, 消息: %s\n", req.UserID, string(p))
continue
}
switch wsCommandConst.Command(wsMessage.Command) {
case wsCommandConst.CHAT_MESSAGE:
chat_message.HandleChatMessageTypes(ctx, svcCtx, req, r, conn, wsMessage.Content)
case wsCommandConst.FRIEND_OPERATION:
proxy_message.HandleProxyMessageTypes(ctx, svcCtx, req, r, conn, wsMessage.Content)
case wsCommandConst.GROUP_OPERATION:
webrtc_message.HandleWebRTCAnswer(ctx, svcCtx, req, r, conn, wsMessage.Content)
case wsCommandConst.HEARTBEAT:
// 添加调试信息
fmt.Printf("处理心跳消息, 用户: %s, 命令: %s\n", req.UserID, wsMessage.Command)
// 使用心跳管理器处理心跳
heartbeatManager.HandleClientHeartbeat(wsMessage.Content)
default:
fmt.Printf("未支持的消息类型, 用户: %s, 命令: %s, 命令类型: %T\n", req.UserID, wsMessage.Command, wsMessage.Command)
fmt.Printf("HEARTBEAT常量值: %s, 命令值: %s, 是否相等: %v\n", wsCommandConst.HEARTBEAT, wsMessage.Command, wsCommandConst.HEARTBEAT == wsCommandConst.Command(wsMessage.Command))
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/webrtc_message/enter.go | app/ws/ws_api/internal/logic/websocket/webrtc_message/enter.go | package webrtc_message
import (
"context"
"fmt"
"net/http"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"github.com/gorilla/websocket"
)
func HandleWebRTCAnswer(ctx context.Context, svcCtx *svc.ServiceContext, req *types.WsReq, r *http.Request, conn *websocket.Conn, content type_struct.WsContent) {
switch content.Data.Type {
default:
fmt.Println("未支持的 WebRTC 消息类型", content.Data.Type)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/utils/websocket_utils.go | app/ws/ws_api/internal/logic/websocket/utils/websocket_utils.go | package websocket_utils
import (
"encoding/json"
"fmt"
"strings"
"sync"
ws_response "beaver/app/ws/ws_api/response"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
"github.com/gorilla/websocket"
"github.com/zeromicro/go-zero/core/logx"
)
var UserOnlineWsMap = make(map[string]*UserWsInfo)
var WsMapMutex sync.RWMutex // 导出互斥锁以供其他包使用
type UserWsInfo struct {
WsClientMap map[string]*websocket.Conn // 用户管理的所有 WebSocket 通道
}
// GetUserKey 生成用户连接的唯一key
func GetUserKey(userID string, deviceType string) string {
return userID + "_" + deviceType
}
// SendMsgToReceiverAndSyncToSender 发消息给接收者，并同步给发送者的其他设备
func SendMsgToReceiverAndSyncToSender(
revUserID string,
sendUserID string,
command wsCommandConst.Command,
receiverContent type_struct.WsContent,
senderSyncContent type_struct.WsContent,
excludeConn *websocket.Conn, // 排除发送消息的连接，避免重复
) {
// 调试：打印发送者的所有连接状态
logx.Infof("=== 消息发送前 发送者连接状态 用户ID: %s ===", sendUserID)
WsMapMutex.RLock()
for userKey, userInfo := range UserOnlineWsMap {
if strings.HasPrefix(userKey, sendUserID+"_") {
deviceType := strings.TrimPrefix(userKey, sendUserID+"_")
logx.Infof("发送者设备类型: %s, userKey: %s, 连接数: %d", deviceType, userKey, len(userInfo.WsClientMap))
}
}
WsMapMutex.RUnlock()
logx.Infof("=== 发送者连接状态结束 ===")
// 发送给接收者B的所有设备
WsMapMutex.RLock()
for userKey, userInfo := range UserOnlineWsMap {
if strings.HasPrefix(userKey, revUserID+"_") {
deviceType := strings.TrimPrefix(userKey, revUserID+"_")
jsonContent, _ := json.Marshal(receiverContent)
logx.Info("发送消息给接收者：", revUserID, "设备类型：", deviceType, "发送者：", sendUserID, "消息内容：", string(jsonContent))
sendWsMapMsg(userInfo.WsClientMap, command, receiverContent)
}
}
WsMapMutex.RUnlock()
// 发送给发送者A的其他设备（用于多端同步）
WsMapMutex.RLock()
excludeAddr := ""
if excludeConn != nil {
excludeAddr = excludeConn.RemoteAddr().String()
}
for userKey, userInfo := range UserOnlineWsMap {
if strings.HasPrefix(userKey, sendUserID+"_") {
deviceType := strings.TrimPrefix(userKey, sendUserID+"_")
// 如果指定了要排除的连接，需要检查这个连接是否在当前设备类型中
if excludeConn != nil {
filteredMap := make(map[string]*websocket.Conn)
hasExcludedConn := false
logx.Infof("检查设备类型 %s 的连接，排除地址: %s", deviceType, excludeAddr)
for addr, conn := range userInfo.WsClientMap {
if addr == excludeAddr {
hasExcludedConn = true
logx.Infof("在设备类型 %s 中跳过发送方连接: %s", deviceType, addr)
} else {
filteredMap[addr] = conn
logx.Infof("在设备类型 %s 中保留连接: %s", deviceType, addr)
}
}
if hasExcludedConn && len(filteredMap) == 0 {
logx.Infof("设备类型 %s 只有发送方连接，无需同步", deviceType)
} else if len(filteredMap) > 0 {
jsonContent, _ := json.Marshal(senderSyncContent)
logx.Info("同步消息给发送者的其他设备：", sendUserID, "设备类型：", deviceType, "接收者：", revUserID, "消息内容：", string(jsonContent))
sendWsMapMsg(filteredMap, command, senderSyncContent)
} else {
// 当前设备类型没有排除的连接，说明这不是发送方设备类型，全部发送
jsonContent, _ := json.Marshal(senderSyncContent)
logx.Info("同步消息给发送者的其他设备类型：", sendUserID, "设备类型：", deviceType, "接收者：", revUserID, "消息内容：", string(jsonContent))
sendWsMapMsg(userInfo.WsClientMap, command, senderSyncContent)
}
} else {
jsonContent, _ := json.Marshal(senderSyncContent)
logx.Info("同步消息给发送者：", sendUserID, "设备类型：", deviceType, "接收者：", revUserID, "消息内容：", string(jsonContent))
sendWsMapMsg(userInfo.WsClientMap, command, senderSyncContent)
}
}
}
WsMapMutex.RUnlock()
}
// sendWsMapMsg 给一组的 WebSocket 通道发送消息
func sendWsMapMsg(wsMap map[string]*websocket.Conn, command wsCommandConst.Command, content type_struct.WsContent) {
for addr, conn := range wsMap {
if err := ws_response.WsResponse(conn, command, content); err != nil {
logx.Errorf("发送WebSocket消息失败, 地址: %s, 错误: %v", addr, err)
// 如果发送失败，关闭连接并从map中移除
conn.Close()
delete(wsMap, addr)
}
}
}
func IsGroupChat(conversationID string) bool {
return !strings.Contains(conversationID, "_")
}
func GetRecipientIdFromConversationID(conversationID string, userID string) string {
ids := strings.Split(conversationID, "_")
if len(ids) != 2 {
fmt.Println("无效的会话Id：", conversationID)
return ""
}
if ids[0] == userID {
return ids[1]
}
return ids[0]
}
// SendMsgToUser 只发送消息给指定用户的所有设备
func SendMsgToUser(targetUserID string, command wsCommandConst.Command, content type_struct.WsContent) {
WsMapMutex.RLock()
defer WsMapMutex.RUnlock()
// 遍历用户的所有连接
for userKey, userInfo := range UserOnlineWsMap {
if strings.HasPrefix(userKey, targetUserID+"_") {
deviceType := strings.TrimPrefix(userKey, targetUserID+"_")
jsonContent, _ := json.Marshal(content)
logx.Infof("发送消息给用户：%s, 设备类型：%s, 消息内容：%s", targetUserID, deviceType, string(jsonContent))
sendWsMapMsg(userInfo.WsClientMap, command, content)
}
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/proxy_message/proxy_message_send.go | app/ws/ws_api/internal/logic/websocket/proxy_message/proxy_message_send.go | package proxy_message
import (
"context"
"encoding/json"
"net/http"
websocket_utils "beaver/app/ws/ws_api/internal/logic/websocket/utils"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
"github.com/gorilla/websocket"
)
func HandleProxyMessageSend(ctx context.Context, svcCtx *svc.ServiceContext, req *types.WsReq, r *http.Request, conn *websocket.Conn, bodyRaw json.RawMessage, ConversationID string) {
if websocket_utils.IsGroupChat(ConversationID) {
} else {
recipientID := websocket_utils.GetRecipientIdFromConversationID(ConversationID, req.UserID)
content := type_struct.WsContent{
Timestamp: 0,
Data: type_struct.WsData{
Type: "transform_websocket_message",
ConversationID: ConversationID,
Body: bodyRaw,
},
}
// 分别给接收者和发送者发送消息
websocket_utils.SendMsgToUser(recipientID, wsCommandConst.FRIEND_OPERATION, content)
websocket_utils.SendMsgToUser(req.UserID, wsCommandConst.FRIEND_OPERATION, content)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/proxy_message/enter.go | app/ws/ws_api/internal/logic/websocket/proxy_message/enter.go | package proxy_message
import (
"context"
"fmt"
"net/http"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"github.com/gorilla/websocket"
)
func HandleProxyMessageTypes(ctx context.Context, svcCtx *svc.ServiceContext, req *types.WsReq, r *http.Request, conn *websocket.Conn, content type_struct.WsContent) {
switch content.Data.Type {
case "transform_websocket_message":
HandleProxyMessageSend(ctx, svcCtx, req, r, conn, content.Data.Body, content.Data.ConversationID)
default:
fmt.Println("未支持的消息类型3", content.Data.Type)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/types/chat.go | app/ws/ws_api/internal/logic/websocket/types/chat.go | package websocket_types
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
)
type SendMsgReq struct {
UserID string `json:"userID"`
ConversationID string `json:"conversationId"`
MessageID string `json:"messageId"` // 客户端消息ID
Msg *chat_rpc.Msg `json:"msg"`
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/heartbeat/manager.go | app/ws/ws_api/internal/logic/websocket/heartbeat/manager.go | package heartbeat
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"beaver/app/ws/ws_api/internal/svc"
ws_response "beaver/app/ws/ws_api/response"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
"github.com/gorilla/websocket"
"github.com/zeromicro/go-zero/core/logx"
)
// Manager 心跳管理器
type Manager struct {
conn *websocket.Conn
userID string
svcCtx *svc.ServiceContext
ctx context.Context
cancel context.CancelFunc
mu sync.Mutex // 添加互斥锁保护并发写入
}
// NewManager 创建心跳管理器
func NewManager(conn *websocket.Conn, userID string, svcCtx *svc.ServiceContext) *Manager {
ctx, cancel := context.WithCancel(context.Background())
return &Manager{
conn: conn,
userID: userID,
svcCtx: svcCtx,
ctx: ctx,
cancel: cancel,
}
}
// Start 启动心跳管理
func (m *Manager) Start() {
go m.startProtocolHeartbeat()
go m.startApplicationHeartbeat()
}
// Stop 停止心跳管理
func (m *Manager) Stop() {
m.cancel()
}
// HandleClientHeartbeat 处理客户端心跳
func (m *Manager) HandleClientHeartbeat(content type_struct.WsContent) {
logx.Infof("收到客户端心跳, 用户: %s", m.userID)
responseContent := type_struct.WsContent{
Timestamp: time.Now().UnixMilli(),
MessageID: m.generateMessageID("heartbeat_response"),
Data: type_struct.WsData{
Type: "heartbeat_response",
Body: json.RawMessage(fmt.Sprintf(`{"server_time": %d}`, time.Now().UnixMilli())),
},
}
m.sendMessage(wsCommandConst.HEARTBEAT, responseContent)
logx.Infof("💗 心跳响应发送成功, 用户: %s", m.userID)
}
// startProtocolHeartbeat 启动协议级心跳
func (m *Manager) startProtocolHeartbeat() {
pingPeriod := time.Duration(m.svcCtx.Config.WebSocket.PingPeriod) * time.Second
ticker := time.NewTicker(pingPeriod)
defer ticker.Stop()
logx.Infof("启动协议级心跳, 用户: %s, 间隔: %v", m.userID, pingPeriod)
for {
select {
case <-m.ctx.Done():
return
case <-ticker.C:
if err := m.sendProtocolPing(); err != nil {
logx.Errorf("协议级心跳失败, 用户: %s, 错误: %v", m.userID, err)
return
}
}
}
}
// startApplicationHeartbeat 启动应用级心跳
func (m *Manager) startApplicationHeartbeat() {
interval := m.getAppHeartbeatInterval()
ticker := time.NewTicker(interval)
defer ticker.Stop()
logx.Infof("启动应用级心跳, 用户: %s, 间隔: %v", m.userID, interval)
for {
select {
case <-m.ctx.Done():
return
case <-ticker.C:
m.sendApplicationHeartbeat()
}
}
}
// sendProtocolPing 发送协议级ping
func (m *Manager) sendProtocolPing() error {
m.mu.Lock()
defer m.mu.Unlock()
writeWait := time.Duration(m.svcCtx.Config.WebSocket.WriteWait) * time.Second
if err := m.conn.SetWriteDeadline(time.Now().Add(writeWait)); err != nil {
return err
}
if err := m.conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
return err
}
logx.Debugf("💗 协议级心跳成功, 用户: %s", m.userID)
return nil
}
// sendApplicationHeartbeat 发送应用级心跳
func (m *Manager) sendApplicationHeartbeat() {
content := type_struct.WsContent{
Timestamp: time.Now().UnixMilli(),
MessageID: m.generateMessageID("server_heartbeat"),
Data: type_struct.WsData{
Type: "server_heartbeat",
Body: json.RawMessage(fmt.Sprintf(`{"server_time": %d}`, time.Now().UnixMilli())),
},
}
m.sendMessage(wsCommandConst.HEARTBEAT, content)
logx.Infof("💓 应用级心跳成功, 用户: %s", m.userID)
}
// sendMessage 安全发送消息（带锁保护）
func (m *Manager) sendMessage(command wsCommandConst.Command, content type_struct.WsContent) {
m.mu.Lock()
defer m.mu.Unlock()
// 检查连接是否已关闭
if m.conn == nil {
logx.Errorf("WebSocket连接已关闭, 用户: %s", m.userID)
return
}
if err := ws_response.WsResponse(m.conn, command, content); err != nil {
logx.Errorf("发送WebSocket消息失败, 用户: %s, 错误: %v", m.userID, err)
// 如果发送失败，可能需要关闭连接
m.conn.Close()
}
}
// getAppHeartbeatInterval 获取应用级心跳间隔
func (m *Manager) getAppHeartbeatInterval() time.Duration {
if m.svcCtx.Config.WebSocket.AppHeartbeatInterval > 0 {
return time.Duration(m.svcCtx.Config.WebSocket.AppHeartbeatInterval) * time.Second
}
return time.Duration(m.svcCtx.Config.WebSocket.PingPeriod*2) * time.Second
}
// generateMessageID 生成消息ID
func (m *Manager) generateMessageID(prefix string) string {
return fmt.Sprintf("%s_%d_%s", prefix, time.Now().UnixNano(), m.userID)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/chat_message/group_message_send.go | app/ws/ws_api/internal/logic/websocket/chat_message/group_message_send.go | package chat_message
import (
"context"
"encoding/json"
"fmt"
"net/http"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"github.com/gorilla/websocket"
)
// HandleGroupMessageSend 处理群聊消息发送
func HandleGroupMessageSend(
ctx context.Context,
svcCtx *svc.ServiceContext,
req *types.WsReq,
r *http.Request,
conn *websocket.Conn,
messageId string,
bodyRaw json.RawMessage,
) {
fmt.Println("群聊消息开始代理")
var body type_struct.BodySendMsg
err := json.Unmarshal(bodyRaw, &body)
if err != nil {
fmt.Println("群聊消息解析错误", err.Error())
return
}
// 将原始消息转换为RPC消息格式
rpcMsg, err := convertToRpcMsg(body.Msg)
if err != nil {
fmt.Println("消息格式转换错误", err.Error())
return
}
// 构建RPC请求
rpcReq := &chat_rpc.SendMsgReq{
UserId: req.UserID,
ConversationId: body.ConversationID,
MessageId: messageId,
Msg: rpcMsg,
}
// 调用RPC服务
_, err = svcCtx.ChatRpc.SendMsg(ctx, rpcReq)
if err != nil {
fmt.Println("群聊消息发送失败", err)
return
}
// // 构建响应数据
// responseJSON, err := buildResponseData(rpcResp, body.Msg)
// if err != nil {
// fmt.Println("构建响应数据失败", err)
// return
// }
// // 处理群聊消息转发
// println("当前会话是群聊")
// res, err := svcCtx.GroupRpc.GetGroupMembers(ctx, &group_rpc.GetGroupMembersReq{
// GroupID: body.ConversationID,
// })
// if err != nil {
// fmt.Println("获取群聊成员列表失败", err)
// return
// }
// fmt.Println("群聊成员列表", res.Members)
// // 给所有群成员发送消息
// for _, memberInfo := range res.Members {
// websocket_utils.SendMsgToUser(memberInfo.UserID, wsCommandConst.CHAT_MESSAGE, type_struct.WsContent{
// Timestamp: 0,
// MessageID: messageId,
// Data: type_struct.WsData{
// Type: wsTypeConst.ChatConversationMessageReceive,
// ConversationID: body.ConversationID,
// Body: json.RawMessage(responseJSON),
// },
// })
// }
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/chat_message/enter.go | app/ws/ws_api/internal/logic/websocket/chat_message/enter.go | package chat_message
import (
"context"
"fmt"
"net/http"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsTypeConst"
"github.com/gorilla/websocket"
)
func HandleChatMessageTypes(ctx context.Context, svcCtx *svc.ServiceContext, req *types.WsReq, r *http.Request, conn *websocket.Conn, content type_struct.WsContent) {
switch content.Data.Type {
case wsTypeConst.GroupMessageSend:
HandleGroupMessageSend(ctx, svcCtx, req, r, conn, content.MessageID, content.Data.Body)
case wsTypeConst.PrivateMessageSend:
HandlePrivateMessageSend(ctx, svcCtx, req, r, conn, content.MessageID, content.Data.Body)
default:
fmt.Println("未支持的消息类型", content.Data.Type)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/chat_message/common.go | app/ws/ws_api/internal/logic/websocket/chat_message/common.go | package chat_message
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
"encoding/json"
)
// convertToRpcMsg 将原始消息转换为RPC消息格式
func convertToRpcMsg(msg json.RawMessage) (*chat_rpc.Msg, error) {
var msgData map[string]interface{}
err := json.Unmarshal(msg, &msgData)
if err != nil {
return nil, err
}
rpcMsg := &chat_rpc.Msg{}
// 获取消息类型
if msgType, ok := msgData["type"].(float64); ok {
rpcMsg.Type = uint32(msgType)
}
// 根据消息类型设置对应的消息内容
switch rpcMsg.Type {
case 1: // 文本消息
if textMsg, ok := msgData["textMsg"].(map[string]interface{}); ok {
if content, ok := textMsg["content"].(string); ok {
rpcMsg.TextMsg = &chat_rpc.TextMsg{Content: content}
}
}
case 2: // 图片消息
if imageMsg, ok := msgData["imageMsg"].(map[string]interface{}); ok {
rpcMsg.ImageMsg = &chat_rpc.ImageMsg{}
if fileKey, ok := imageMsg["fileKey"].(string); ok {
rpcMsg.ImageMsg.FileKey = fileKey
}
if width, ok := imageMsg["width"].(float64); ok {
rpcMsg.ImageMsg.Width = int32(width)
}
if height, ok := imageMsg["height"].(float64); ok {
rpcMsg.ImageMsg.Height = int32(height)
}
if size, ok := imageMsg["size"].(float64); ok {
rpcMsg.ImageMsg.Size = int64(size)
}
}
case 3: // 视频消息
if videoMsg, ok := msgData["videoMsg"].(map[string]interface{}); ok {
rpcMsg.VideoMsg = &chat_rpc.VideoMsg{}
if fileKey, ok := videoMsg["fileKey"].(string); ok {
rpcMsg.VideoMsg.FileKey = fileKey
}
if width, ok := videoMsg["width"].(float64); ok {
rpcMsg.VideoMsg.Width = int32(width)
}
if height, ok := videoMsg["height"].(float64); ok {
rpcMsg.VideoMsg.Height = int32(height)
}
if duration, ok := videoMsg["duration"].(float64); ok {
rpcMsg.VideoMsg.Duration = int32(duration)
}
if thumbnailKey, ok := videoMsg["thumbnailKey"].(string); ok {
rpcMsg.VideoMsg.ThumbnailKey = thumbnailKey
}
if size, ok := videoMsg["size"].(float64); ok {
rpcMsg.VideoMsg.Size = int64(size)
}
}
case 4: // 文件消息
if fileMsg, ok := msgData["fileMsg"].(map[string]interface{}); ok {
file := &chat_rpc.FileMsg{}
if fileKey, ok := fileMsg["fileKey"].(string); ok {
file.FileKey = fileKey
}
if size, ok := fileMsg["size"].(float64); ok {
file.Size = int64(size)
}
if mimeType, ok := fileMsg["mimeType"].(string); ok {
file.MimeType = mimeType
}
rpcMsg.FileMsg = file
}
case 5: // 语音消息
if voiceMsg, ok := msgData["voiceMsg"].(map[string]interface{}); ok {
rpcMsg.VoiceMsg = &chat_rpc.VoiceMsg{}
if fileKey, ok := voiceMsg["fileKey"].(string); ok {
rpcMsg.VoiceMsg.FileKey = fileKey
}
if duration, ok := voiceMsg["duration"].(float64); ok {
rpcMsg.VoiceMsg.Duration = int32(duration)
}
if size, ok := voiceMsg["size"].(float64); ok {
rpcMsg.VoiceMsg.Size = int64(size)
}
}
case 6: // 表情消息
if emojiMsg, ok := msgData["emojiMsg"].(map[string]interface{}); ok {
emoji := &chat_rpc.EmojiMsg{}
if fileKey, ok := emojiMsg["fileKey"].(string); ok {
emoji.FileKey = fileKey
}
if emojiId, ok := emojiMsg["emojiId"].(string); ok {
emoji.EmojiId = emojiId
}
if packageId, ok := emojiMsg["packageId"].(string); ok {
emoji.PackageId = packageId
}
if width, ok := emojiMsg["width"].(float64); ok {
emoji.Width = int64(width)
}
if height, ok := emojiMsg["height"].(float64); ok {
emoji.Height = int64(height)
}
rpcMsg.EmojiMsg = emoji
}
case 7: // 通知消息
if notificationMsg, ok := msgData["notificationMsg"].(map[string]interface{}); ok {
rpcMsg.NotificationMsg = &chat_rpc.NotificationMsg{}
if msgType, ok := notificationMsg["type"].(float64); ok {
rpcMsg.NotificationMsg.Type = int32(msgType)
}
if actors, ok := notificationMsg["actors"].([]interface{}); ok {
for _, actor := range actors {
if actorStr, ok := actor.(string); ok {
rpcMsg.NotificationMsg.Actors = append(rpcMsg.NotificationMsg.Actors, actorStr)
}
}
}
}
case 8: // 音频文件消息
if audioFileMsg, ok := msgData["audioFileMsg"].(map[string]interface{}); ok {
rpcMsg.AudioFileMsg = &chat_rpc.AudioFileMsg{}
if fileKey, ok := audioFileMsg["fileKey"].(string); ok {
rpcMsg.AudioFileMsg.FileKey = fileKey
}
if duration, ok := audioFileMsg["duration"].(float64); ok {
rpcMsg.AudioFileMsg.Duration = int32(duration)
}
if size, ok := audioFileMsg["size"].(float64); ok {
rpcMsg.AudioFileMsg.Size = int64(size)
}
}
}
return rpcMsg, nil
}
// buildResponseData 构建响应数据
func buildResponseData(rpcResp *chat_rpc.SendMsgRes, originalMsg json.RawMessage) ([]byte, error) {
responseData := map[string]interface{}{
"id": rpcResp.Id,
"messageId": rpcResp.MessageId,
"conversationId": rpcResp.ConversationId,
"msg": originalMsg, // 使用原始消息数据
"sender": map[string]interface{}{
"userId": rpcResp.Sender.UserId,
"avatar": rpcResp.Sender.Avatar,
"nickName": rpcResp.Sender.NickName,
},
"conversationType": rpcResp.ConversationType,
"createdAt": rpcResp.CreatedAt,
"msgPreview": rpcResp.MsgPreview,
"status": rpcResp.Status,
"seq": rpcResp.Seq,
}
// 将响应数据转换为 JSON 格式
responseJSON, err := json.Marshal(responseData)
if err != nil {
return nil, err
}
return responseJSON, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/internal/logic/websocket/chat_message/private_message_send.go | app/ws/ws_api/internal/logic/websocket/chat_message/private_message_send.go | package chat_message
import (
"context"
"encoding/json"
"fmt"
"net/http"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/ws/ws_api/internal/svc"
"beaver/app/ws/ws_api/internal/types"
type_struct "beaver/app/ws/ws_api/types"
"github.com/gorilla/websocket"
)
// HandlePrivateMessageSend 处理私聊消息发送
func HandlePrivateMessageSend(
ctx context.Context,
svcCtx *svc.ServiceContext,
req *types.WsReq,
r *http.Request,
conn *websocket.Conn,
messageId string,
bodyRaw json.RawMessage,
) {
fmt.Println("私聊消息开始代理")
var body type_struct.BodySendMsg
err := json.Unmarshal(bodyRaw, &body)
if err != nil {
fmt.Println("私聊消息解析错误", err.Error())
return
}
// 将原始消息转换为RPC消息格式
rpcMsg, err := convertToRpcMsg(body.Msg)
if err != nil {
fmt.Println("消息格式转换错误", err.Error())
return
}
// 构建RPC请求
rpcReq := &chat_rpc.SendMsgReq{
UserId: req.UserID,
ConversationId: body.ConversationID,
MessageId: messageId,
Msg: rpcMsg,
}
// 调用RPC服务
_, err = svcCtx.ChatRpc.SendMsg(ctx, rpcReq)
if err != nil {
fmt.Println("私聊消息发送失败", err)
return
}
// // 构建响应数据
// responseJSON, err := buildResponseData(rpcResp, body.Msg)
// if err != nil {
// fmt.Println("构建响应数据失败", err)
// return
// }
// 处理私聊消息转发
// println("当前会话是私聊")
// recipientID := websocket_utils.GetRecipientIdFromConversationID(body.ConversationID, req.UserID)
// // 发送给接收者的消息
// receiverContent := type_struct.WsContent{
// Timestamp: 0,
// MessageID: messageId,
// Data: type_struct.WsData{
// Type: wsTypeConst.PrivateMessageReceive,
// ConversationID: body.ConversationID,
// Body: json.RawMessage(responseJSON),
// },
// }
// 发送给发送方设备的确认消息（包括发送方自己）
// senderConfirmContent := type_struct.WsContent{
// Timestamp: 0,
// MessageID: messageId,
// Data: type_struct.WsData{
// Type: wsTypeConst.PrivateMessageSync, // 发送方也用sync类型，表示消息已处理
// ConversationID: body.ConversationID,
// Body: json.RawMessage(responseJSON),
// },
// }
// // 1. 发送给接收者的所有设备
// websocket_utils.SendMsgToUser(recipientID, wsCommandConst.CHAT_MESSAGE, receiverContent)
// // 2. 发送给发送者的所有设备（包括发送方设备）
// websocket_utils.SendMsgToUser(req.UserID, wsCommandConst.CHAT_MESSAGE, senderConfirmContent)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/ws/ws_api/response/response.go | app/ws/ws_api/response/response.go | package ws_response
import (
type_struct "beaver/app/ws/ws_api/types"
"beaver/common/wsEnum/wsCommandConst"
utils "beaver/utils/rand"
"encoding/json"
"time"
"github.com/gorilla/websocket"
"github.com/zeromicro/go-zero/core/logx"
)
type Response struct {
Code int `json:"code"`
Command wsCommandConst.Command `json:"command"`
Content type_struct.WsContent `json:"content"`
MessageID string `json:"messageId"`
ServerTime int64 `json:"serverTime"`
}
func WsResponse(conn *websocket.Conn, command wsCommandConst.Command, content type_struct.WsContent) error {
code := 0
response := Response{
Command: command,
Code: code,
Content: content,
MessageID: utils.GenerateRandomString(8),
ServerTime: time.Now().Unix(),
}
responseJSON, err := json.Marshal(response)
if err != nil {
logx.Errorf("序列化WebSocket响应失败: %v", err)
return err
}
// 设置写入超时
if err := conn.SetWriteDeadline(time.Now().Add(10 * time.Second)); err != nil {
logx.Errorf("设置WebSocket写入超时失败: %v", err)
return err
}
if err := conn.WriteMessage(websocket.TextMessage, responseJSON); err != nil {
logx.Errorf("发送WebSocket消息失败: %v", err)
return err
}
return nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/update.go | app/update/update_api/update.go | package main
import (
"beaver/app/update/update_api/internal/config"
"beaver/app/update/update_api/internal/handler"
"beaver/app/update/update_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"flag"
"fmt"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/update.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
server.Use(middleware.LogMiddleware)
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/internal/svc/servicecontext.go | app/update/update_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/file/file_rpc/file"
"beaver/app/file/file_rpc/types/file_rpc"
"beaver/app/update/update_api/internal/config"
"beaver/common/zrpc_interceptor"
"beaver/core"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
DB *gorm.DB
Redis *redis.Client
FileRpc file_rpc.FileClient
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
return &ServiceContext{
Config: c,
DB: mysqlDb,
Redis: client,
FileRpc: file.NewFile(zrpc.MustNewClient(c.FileRpc, 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/update/update_api/internal/types/types.go | app/update/update_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type GetLatestVersionReq struct {
UserID string `header:"Beaver-User-Id,optional"` // 用户ID(可选)
CityName string `header:"X-City-Name,optional"` // 城市名称(可选)
DeviceID string `header:"deviceId"` // 客户端生成的设备唯一标识符
AppID string `json:"appId"` // 应用ID
PlatformID uint `json:"platformId"` // 平台ID：1=Windows, 2=MacOS, 3=iOS, 4=Android, 5=HarmonyOS
ArchID uint `json:"archId"` // 架构ID：1=WinX64, 2=WinArm64, 3=MacIntel, 4=MacApple, 5=iOS, 6=Android, 7=HarmonyOS
Version string `header:"version"` // 当前版本号
}
type GetLatestVersionRes struct {
HasUpdate bool `json:"hasUpdate"` // 是否有更新
ArchitectureID uint `json:"architectureId,omitempty"` // 架构ID（内部使用）
Version string `json:"version,omitempty"` // 最新版本号
FileKey string `json:"fileKey"` // 文件Key
Size int64 `json:"size"` // 安装包大小
MD5 string `json:"md5"` // MD5校验
Description string `json:"description,omitempty"` // 版本描述
ReleaseNotes string `json:"releaseNotes,omitempty"` // 更新日志
}
type ReportVersionReq struct {
UserID string `header:"Beaver-User-Id,optional"` // 用户ID(可选)
DeviceID string `header:"deviceId"` // 客户端生成的设备唯一标识符
Version string `header:"version"` // 版本号
AppID string `json:"appId"` // 应用ID
PlatformID uint `json:"platformId"` // 平台ID：1=Windows, 2=MacOS, 3=iOS, 4=Android, 5=HarmonyOS
ArchID uint `json:"archId"` // 架构ID：0=h5, 1=WinX64, 2=WinArm64, 3=MacIntel, 4=MacApple, 5=iOS, 6=Android, 7=HarmonyOS
}
type ReportVersionRes struct {
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/internal/config/config.go | app/update/update_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Etcd string
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
FileRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/internal/handler/getlatestversionhandler.go | app/update/update_api/internal/handler/getlatestversionhandler.go | package handler
import (
"beaver/app/update/update_api/internal/logic"
"beaver/app/update/update_api/internal/svc"
"beaver/app/update/update_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getLatestVersionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetLatestVersionReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetLatestVersionLogic(r.Context(), svcCtx)
resp, err := l.GetLatestVersion(&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/update/update_api/internal/handler/reportversionhandler.go | app/update/update_api/internal/handler/reportversionhandler.go | package handler
import (
"beaver/app/update/update_api/internal/logic"
"beaver/app/update/update_api/internal/svc"
"beaver/app/update/update_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func reportVersionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ReportVersionReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewReportVersionLogic(r.Context(), svcCtx)
resp, err := l.ReportVersion(&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/update/update_api/internal/handler/routes.go | app/update/update_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/update/update_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 获取最新版本
Method: http.MethodPost,
Path: "/api/update/latest",
Handler: getLatestVersionHandler(serverCtx),
},
{
// 上报版本信息
Method: http.MethodPost,
Path: "/api/update/report",
Handler: reportVersionHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/internal/logic/getlatestversionlogic.go | app/update/update_api/internal/logic/getlatestversionlogic.go | package logic
import (
"context"
"fmt"
"strings"
"beaver/app/file/file_rpc/types/file_rpc"
"beaver/app/update/update_api/internal/svc"
"beaver/app/update/update_api/internal/types"
"beaver/app/update/update_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type GetLatestVersionLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetLatestVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetLatestVersionLogic {
return &GetLatestVersionLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetLatestVersionLogic) GetLatestVersion(req *types.GetLatestVersionReq) (resp *types.GetLatestVersionRes, err error) {
fmt.Println("req.CityName:", req.CityName)
// H5架构特殊处理
if req.ArchID == 0 {
logx.Infof("H5获取最新版本: AppID=%s, Version=%s, DeviceID=%s", req.AppID, req.Version, req.DeviceID)
return &types.GetLatestVersionRes{
HasUpdate: false,
}, nil
}
// 1. 验证应用是否存在
var app update_models.UpdateApp
if err := l.svcCtx.DB.Where("app_id = ? AND is_active = ?", req.AppID, true).First(&app).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("应用不存在或已停用")
}
logx.Errorf("查询应用失败: %v", err)
return nil, fmt.Errorf("查询应用失败")
}
// 2. 验证架构是否存在
var architecture update_models.UpdateArchitecture
if err := l.svcCtx.DB.Where("app_id = ? AND platform_id = ? AND arch_id = ? AND is_active = ?",
req.AppID, req.PlatformID, req.ArchID, true).First(&architecture).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("不支持的平台或架构")
}
logx.Errorf("查询架构失败: %v", err)
return nil, fmt.Errorf("查询架构失败")
}
// 3. 查找该架构下的最新版本
var latestVersion update_models.UpdateVersion
if err := l.svcCtx.DB.Where("architecture_id = ?", architecture.Id).
Order("created_at DESC").First(&latestVersion).Error; err != nil {
if err == gorm.ErrRecordNotFound {
// 没有找到版本，返回无更新
return &types.GetLatestVersionRes{
HasUpdate: false,
}, nil
}
logx.Errorf("查询最新版本失败: %v", err)
return nil, fmt.Errorf("查询最新版本失败")
}
// 4. 比较版本号（简单字符串比较，实际项目中可能需要更复杂的版本比较逻辑）
if !l.isNewerVersion(latestVersion.Version, req.Version) {
// 当前版本已经是最新或更新
return &types.GetLatestVersionRes{
HasUpdate: false,
}, nil
}
// 5. 通过file_rpc获取文件详情
fileDetail, err := l.svcCtx.FileRpc.GetFileDetail(l.ctx, &file_rpc.GetFileDetailReq{
FileKey: latestVersion.FileKey,
})
if err != nil {
logx.Errorf("获取文件详情失败: %v", err)
// 即使获取文件详情失败，也返回版本信息，只是没有文件大小和MD5
resp = &types.GetLatestVersionRes{
HasUpdate: true,
ArchitectureID: uint(architecture.Id),
Version: latestVersion.Version,
FileKey: latestVersion.FileKey,
Size: fileDetail.Size,
MD5: fileDetail.Md5,
Description: latestVersion.Description,
ReleaseNotes: latestVersion.ReleaseNotes,
}
} else {
// 6. 构建响应
resp = &types.GetLatestVersionRes{
HasUpdate: true,
ArchitectureID: uint(architecture.Id),
Version: latestVersion.Version,
FileKey: latestVersion.FileKey,
Size: fileDetail.Size,
MD5: fileDetail.Md5,
Description: latestVersion.Description,
ReleaseNotes: latestVersion.ReleaseNotes,
}
}
logx.Infof("获取最新版本成功: AppID=%s, PlatformID=%d, ArchID=%d, CurrentVersion=%s, LatestVersion=%s",
req.AppID, req.PlatformID, req.ArchID, req.Version, latestVersion.Version)
return resp, nil
}
// 简单的版本比较逻辑（实际项目中可能需要更复杂的版本比较）
func (l *GetLatestVersionLogic) isNewerVersion(latestVersion, currentVersion string) bool {
// 这里使用简单的字符串比较，实际项目中应该使用语义化版本比较
return strings.Compare(latestVersion, currentVersion) > 0
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_api/internal/logic/reportversionlogic.go | app/update/update_api/internal/logic/reportversionlogic.go | package logic
import (
"context"
"fmt"
"beaver/app/update/update_api/internal/svc"
"beaver/app/update/update_api/internal/types"
"beaver/app/update/update_models"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type ReportVersionLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewReportVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ReportVersionLogic {
return &ReportVersionLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ReportVersionLogic) ReportVersion(req *types.ReportVersionReq) (resp *types.ReportVersionRes, err error) {
// H5架构特殊处理
if req.ArchID == 0 {
logx.Infof("H5版本上报: AppID=%s, Version=%s, DeviceID=%s", req.AppID, req.Version, req.DeviceID)
return &types.ReportVersionRes{}, nil
}
// 1. 验证应用是否存在
var app update_models.UpdateApp
if err := l.svcCtx.DB.Where("app_id = ? AND is_active = ?", req.AppID, true).First(&app).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("应用不存在或已停用")
}
logx.Errorf("查询应用失败: %v", err)
return nil, fmt.Errorf("查询应用失败")
}
// 2. 验证架构是否存在
var architecture update_models.UpdateArchitecture
if err := l.svcCtx.DB.Where("app_id = ? AND platform_id = ? AND arch_id = ? AND is_active = ?",
req.AppID, req.PlatformID, req.ArchID, true).First(&architecture).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, fmt.Errorf("不支持的平台或架构")
}
logx.Errorf("查询架构失败: %v", err)
return nil, fmt.Errorf("查询架构失败")
}
// 3. 查找是否已有该设备的记录
var existingReport update_models.UpdateReport
err = l.svcCtx.DB.Where("device_id = ? AND app_id = ? AND architecture_id = ?",
req.DeviceID, req.AppID, architecture.Id).First(&existingReport).Error
if err != nil && err != gorm.ErrRecordNotFound {
logx.Errorf("查询设备记录失败: %v", err)
return nil, fmt.Errorf("查询设备记录失败")
}
if err == gorm.ErrRecordNotFound {
// 没有记录，创建新记录
report := update_models.UpdateReport{
UserID: req.UserID,
DeviceID: req.DeviceID,
AppID: req.AppID,
ArchitectureID: architecture.Id,
Version: req.Version,
}
if err := l.svcCtx.DB.Create(&report).Error; err != nil {
logx.Errorf("创建版本上报记录失败: %v", err)
return nil, fmt.Errorf("创建上报记录失败")
}
} else {
// 有记录，更新现有记录
updates := map[string]interface{}{
"user_id": req.UserID,
"version": req.Version,
}
if err := l.svcCtx.DB.Model(&existingReport).Updates(updates).Error; err != nil {
logx.Errorf("更新版本上报记录失败: %v", err)
return nil, fmt.Errorf("更新上报记录失败")
}
}
logx.Infof("版本上报成功: AppID=%s, PlatformID=%d, ArchID=%d, Version=%s, DeviceID=%s",
req.AppID, req.PlatformID, req.ArchID, req.Version, req.DeviceID)
return &types.ReportVersionRes{}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_models/update_report.go | app/update/update_models/update_report.go | package update_models
import (
"beaver/common/models"
)
type UpdateReport struct {
models.Model
UserID string `json:"userId" gorm:"size:64;index"` // 用户ID
DeviceID string `json:"deviceId" gorm:"size:64;index"` // 设备ID
AppID string `json:"appId" gorm:"size:64;index"` // 应用ID
ArchitectureID uint `json:"architectureId" gorm:"index"` // 架构ID
Version string `json:"version"` // 版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_models/update_strategy.go | app/update/update_models/update_strategy.go | package update_models
import (
"beaver/common/models"
"database/sql/driver"
"encoding/json"
)
// 架构版本配置信息
type StrategyInfo struct {
ArchitectureID uint `json:"architectureId"` // 架构ID
VersionID uint `json:"versionId"` // 版本ID
ForceUpdate bool `json:"forceUpdate"` // 是否强制更新
IsActive bool `json:"isActive"` // 是否启用
}
type Strategy []StrategyInfo
// Scan 方法 - 从数据库读取数据
func (c *Strategy) Scan(val interface{}) error {
return json.Unmarshal(val.([]byte), c)
}
// Value 方法 - 存储到数据库
func (c *Strategy) Value() (driver.Value, error) {
b, err := json.Marshal(c)
return string(b), err
}
// 应用城市策略模型
type UpdateStrategy struct {
models.Model
AppID string `json:"appId" gorm:"size:64;index"` // 应用ID（关联 UpdateApp.AppID）
CityID string `json:"cityId" gorm:"size:32"` // 城市代码
Strategy *Strategy `json:"strategy"` // 城市策略配置
IsActive bool `json:"isActive"` // 是否启用
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_models/upload_app.go | app/update/update_models/upload_app.go | package update_models
import "beaver/common/models"
// 应用信息表 - 顶层
type UpdateApp struct {
models.Model
Name string `json:"name" gorm:"size:64"` // 应用名称，如"飞书"、"微信"
Description string `json:"description"` // 应用描述
AppID string `gorm:"column:app_id;size:64;uniqueIndex" json:"appId"` // 应用ID
Icon string `json:"icon"` // 应用图标URL
IsActive bool `json:"isActive"` // 是否活跃
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_models/update_version.go | app/update/update_models/update_version.go | package update_models
import (
"beaver/common/models"
)
type UpdateVersion struct {
models.Model
ArchitectureID uint `json:"architectureId" gorm:"index"` // 架构id (统一小写d)
Version string `json:"version"` // 版本号
FileKey string `json:"fileKey"` // 文件Key
Description string `json:"description"` // 版本描述
ReleaseNotes string `json:"releaseNotes"` // 更新日志
// 关联关系
Architecture *UpdateArchitecture `gorm:"foreignKey:ArchitectureID"` // 架构关联
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/update/update_models/update_architecture.go | app/update/update_models/update_architecture.go | package update_models
import (
"beaver/common/models"
)
// 架构信息表 - 用于存储不同平台的架构信息
type UpdateArchitecture struct {
models.Model
AppID string `json:"appId" gorm:"type:varchar(64);index"` // 关联的应用ID
App *UpdateApp `json:"app" gorm:"foreignKey:AppID;references:AppID"` // 关联的应用信息
PlatformID uint `json:"platformId"` // 平台ID：1=Windows, 2=MacOS, 3=iOS, 4=Android, 5=HarmonyOS
ArchID uint `json:"archId"` // 架构类型 1=WinX64, 2=WinArm64, 3=MacIntel, 4=MacApple, 5=iOS, 6=Android, 7=HarmonyOS
Description string `json:"description"` // 架构描述
Versions []UpdateVersion `gorm:"foreignKey:ArchitectureID"` // 关联的版本信息
IsActive bool `json:"isActive"` // 是否活跃
}
// 预定义平台类型
const (
PlatformWindows uint = 1 // Windows平台
PlatformMacOS uint = 2 // MacOS平台（苹果电脑）
PlatformIOS uint = 3 // iOS平台（苹果手机/平板）
PlatformAndroid uint = 4 // Android平台
PlatformHarmonyOS uint = 5 // 鸿蒙系统平台
)
// 预定义架构类型常量 - 按平台区分
const (
// H5架构
H5 uint = 0 // H5网页版本
// Windows架构
WinX64 uint = 1 // Intel x64 (64位)
WinArm64 uint = 2 // ARM64 (Surface等设备)
// MacOS架构
MacIntel uint = 3 // Intel版本
MacApple uint = 4 // Apple Silicon (M1/M2/M3系列)
// iOS架构
IOS uint = 5 // iOS通用版本
// Android架构
Android uint = 6 // 通用版本
// 鸿蒙系统架构
HarmonyOS uint = 7 // 鸿蒙系统通用版本
)
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_models/datasync_model.go | app/datasync/datasync_models/datasync_model.go | package datasync_models
import (
"beaver/common/models"
)
// DatasyncModel 数据同步模型
type DatasyncModel struct {
models.Model
DataType string `gorm:"size:32;unique" json:"dataType"` // 数据类型：users/friends/groups/chats/conversations（唯一键）
LastSeq int64 `gorm:"default:0" json:"lastSeq"` // 最后同步的序列号（消息用）或版本号（基础数据用）
LastSyncTime int64 `gorm:"default:0" json:"lastSyncTime"` // 最后同步的时间戳
SyncStatus string `gorm:"size:16;default:'pending'" json:"syncStatus"` // 同步状态：pending/syncing/completed/failed
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/datasync.go | app/datasync/datasync_api/datasync.go | package main
import (
"beaver/app/datasync/datasync_api/internal/config"
"beaver/app/datasync/datasync_api/internal/handler"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"flag"
"fmt"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/datasync.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
server.Use(middleware.RequestLogMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/svc/servicecontext.go | app/datasync/datasync_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/datasync/datasync_api/internal/config"
"beaver/app/emoji/emoji_rpc/types/emoji_rpc"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/core"
"time"
"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
FriendRpc friend_rpc.FriendClient
GroupRpc group_rpc.GroupClient
UserRpc user_rpc.UserClient
ChatRpc chat_rpc.ChatClient
EmojiRpc emoji_rpc.EmojiClient
NotificationRpc notification_rpc.NotificationClient
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
return &ServiceContext{
Config: c,
DB: mysqlDb,
Redis: client,
FriendRpc: friend_rpc.NewFriendClient(zrpc.MustNewClient(c.FriendRpc, zrpc.WithTimeout(time.Duration(c.FriendRpc.Timeout)*time.Millisecond)).Conn()),
GroupRpc: group_rpc.NewGroupClient(zrpc.MustNewClient(c.GroupRpc, zrpc.WithTimeout(time.Duration(c.GroupRpc.Timeout)*time.Millisecond)).Conn()),
UserRpc: user_rpc.NewUserClient(zrpc.MustNewClient(c.UserRpc, zrpc.WithTimeout(time.Duration(c.UserRpc.Timeout)*time.Millisecond)).Conn()),
ChatRpc: chat_rpc.NewChatClient(zrpc.MustNewClient(c.ChatRpc, zrpc.WithTimeout(time.Duration(c.ChatRpc.Timeout)*time.Millisecond)).Conn()),
EmojiRpc: emoji_rpc.NewEmojiClient(zrpc.MustNewClient(c.EmojiRpc, zrpc.WithTimeout(time.Duration(c.EmojiRpc.Timeout)*time.Millisecond)).Conn()),
NotificationRpc: notification_rpc.NewNotificationClient(zrpc.MustNewClient(c.NotificationRpc, zrpc.WithTimeout(time.Duration(c.NotificationRpc.Timeout)*time.Millisecond)).Conn()),
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/types/types.go | app/datasync/datasync_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type ChatConversationVersionItem struct {
ConversationID string `json:"conversationId"` // 会话ID
Version int64 `json:"version"` // 会话版本号
}
type ChatMessageVersionItem struct {
ConversationID string `json:"conversationId"` // 会话ID
Seq int64 `json:"seq"` // 会话最新消息序列号
}
type ChatUserConversationVersionItem struct {
ConversationID string `json:"conversationId"` // 会话ID
Version int64 `json:"version"` // 用户会话设置版本号
}
type EmojiCollectVersionItem struct {
EmojiCollectId string `json:"emojiCollectId"` // 收藏记录ID
Version int64 `json:"version"` // 收藏版本号
}
type EmojiPackageCollectVersionItem struct {
PackageCollectId string `json:"packageCollectId"` // 收藏记录ID
Version int64 `json:"version"` // 收藏版本号
}
type EmojiPackageContentVersionItem struct {
PackageId string `json:"packageId"` // 表情包ID
Version int64 `json:"version"` // 表情包内容版本号
}
type EmojiPackageVersionItem struct {
PackageId string `json:"packageId"` // 表情包ID
Version int64 `json:"version"` // 表情包版本号
}
type EmojiVersionItem struct {
EmojiId string `json:"emojiId"` // 表情ID
Version int64 `json:"version"` // 表情版本号
}
type FriendVerifyVersionItem struct {
VerifyId string `json:"verifyId"` // 验证记录ID
Version int64 `json:"version"` // 验证记录版本号
}
type FriendVersionItem struct {
FriendId string `json:"friendId"` // 好友ID
Version int64 `json:"version"` // 好友关系版本号
}
type GetSyncAllUsersReq struct {
Type string `json:"type,optional"` // 类型：friends/group/all，不传或为空则同步所有相关用户
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个时间戳之后开始同步，不传则同步所有
}
type GetSyncAllUsersRes struct {
UserVersions []UserVersionItem `json:"userVersions"` // 变更的用户版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncChatConversationsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncChatConversationsRes struct {
ConversationVersions []ChatConversationVersionItem `json:"conversationVersions"` // 变更的会话版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncChatMessagesReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个序列号之后开始同步，不传则同步所有
}
type GetSyncChatMessagesRes struct {
MessageVersions []ChatMessageVersionItem `json:"messageVersions"` // 变更的消息版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncChatUserConversationsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncChatUserConversationsRes struct {
UserConversationVersions []ChatUserConversationVersionItem `json:"userConversationVersions"` // 变更的用户会话设置版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncEmojiCollectsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个时间戳之后开始同步，不传则同步所有
}
type GetSyncEmojiCollectsRes struct {
EmojiCollectVersions []EmojiCollectVersionItem `json:"emojiCollectVersions"` // 用户收藏的表情变更摘要
EmojiPackageCollectVersions []EmojiPackageCollectVersionItem `json:"emojiPackageCollectVersions"` // 用户收藏的表情包变更摘要
EmojiPackageVersions []EmojiPackageVersionItem `json:"emojiPackageVersions"` // 表情包数据变更摘要
EmojiPackageContentVersions []EmojiPackageContentVersionItem `json:"emojiPackageContentVersions"` // 表情包内容变更摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncEmojisReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个时间戳之后开始同步，不传则同步所有
}
type GetSyncEmojisRes struct {
EmojiVersions []EmojiVersionItem `json:"emojiVersions"` // 表情基础数据摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncFriendVerifiesReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncFriendVerifiesRes struct {
FriendVerifyVersions []FriendVerifyVersionItem `json:"friendVerifyVersions"` // 变更的好友验证版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncFriendsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncFriendsRes struct {
FriendVersions []FriendVersionItem `json:"friendVersions"` // 变更的好友版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncGroupInfoReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncGroupInfoRes struct {
GroupVersions []GroupInfoVersionItem `json:"groupVersions"` // 变更的群组信息版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncGroupMembersReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncGroupMembersRes struct {
GroupVersions []GroupMembersVersionItem `json:"groupVersions"` // 变更的群成员版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncGroupRequestsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
Since int64 `json:"since,optional"` // 从这个版本号之后开始同步，不传则同步所有
}
type GetSyncGroupRequestsRes struct {
GroupVersions []GroupRequestsVersionItem `json:"groupVersions"` // 变更的入群申请版本摘要
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncNotificationEventsReq struct {
SinceVersion int64 `json:"sinceVersion,optional"` // 事件表的版本游标，>sinceVersion
Limit int32 `json:"limit,optional"` // 可选分页大小
}
type GetSyncNotificationEventsRes struct {
EventVersions []NotificationEventVersionItem `json:"eventVersions"` // 事件版本摘要
MaxVersion int64 `json:"maxVersion"` // 本次返回的最大版本
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncNotificationInboxesReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
SinceVersion int64 `json:"sinceVersion,optional"` // 收件箱表的版本游标，>sinceVersion
Limit int32 `json:"limit,optional"` // 可选分页大小
}
type GetSyncNotificationInboxesRes struct {
InboxVersions []NotificationInboxVersionItem `json:"inboxVersions"` // 收件箱版本摘要
MaxVersion int64 `json:"maxVersion"` // 本次返回的最大版本
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GetSyncNotificationReadCursorsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID，从请求头获取
SinceVersion int64 `json:"sinceVersion,optional"` // 已读游标表的版本游标，>sinceVersion
}
type GetSyncNotificationReadCursorsRes struct {
CursorVersions []NotificationReadCursorVersionItem `json:"cursorVersions"` // 已读游标版本摘要
MaxVersion int64 `json:"maxVersion"` // 本次返回的最大版本
ServerTimestamp int64 `json:"serverTimestamp"` // 服务端处理时间戳
}
type GroupInfoVersionItem struct {
GroupID string `json:"groupId"` // 群组ID
Version int64 `json:"version"` // 群资料版本
}
type GroupMembersVersionItem struct {
GroupID string `json:"groupId"` // 群组ID
Version int64 `json:"version"` // 群成员版本
}
type GroupRequestsVersionItem struct {
GroupID string `json:"groupId"` // 群组ID
Version int64 `json:"version"` // 入群申请版本
}
type NotificationEventVersionItem struct {
EventID string `json:"eventId"` // 事件ID
Version int64 `json:"version"` // 事件版本
}
type NotificationInboxVersionItem struct {
EventID string `json:"eventId"` // 事件ID
Version int64 `json:"version"` // 收件箱版本
}
type NotificationReadCursorVersionItem struct {
Category string `json:"category"` // 分类
Version int64 `json:"version"` // 游标版本
}
type UserVersionItem struct {
UserID string `json:"userId"` // 用户ID
Version int64 `json:"version"` // 最新版本号
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/config/config.go | app/datasync/datasync_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Etcd string
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
FriendRpc zrpc.RpcClientConf
GroupRpc zrpc.RpcClientConf
UserRpc zrpc.RpcClientConf
ChatRpc zrpc.RpcClientConf
MomentRpc zrpc.RpcClientConf
EmojiRpc zrpc.RpcClientConf
DatasyncRpc zrpc.RpcClientConf
NotificationRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/handler/getsyncallusershandler.go | app/datasync/datasync_api/internal/handler/getsyncallusershandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncAllUsersHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncAllUsersReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncAllUsersLogic(r.Context(), svcCtx)
resp, err := l.GetSyncAllUsers(&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/datasync/datasync_api/internal/handler/getsyncchatconversationshandler.go | app/datasync/datasync_api/internal/handler/getsyncchatconversationshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncChatConversationsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncChatConversationsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncChatConversationsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncChatConversations(&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/datasync/datasync_api/internal/handler/getsyncnotificationinboxeshandler.go | app/datasync/datasync_api/internal/handler/getsyncnotificationinboxeshandler.go | package handler
import (
"net/http"
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncNotificationInboxesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncNotificationInboxesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncNotificationInboxesLogic(r.Context(), svcCtx)
resp, err := l.GetSyncNotificationInboxes(&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/datasync/datasync_api/internal/handler/getsyncemojishandler.go | app/datasync/datasync_api/internal/handler/getsyncemojishandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncEmojisHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncEmojisReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncEmojisLogic(r.Context(), svcCtx)
resp, err := l.GetSyncEmojis(&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/datasync/datasync_api/internal/handler/getsyncfriendverifieshandler.go | app/datasync/datasync_api/internal/handler/getsyncfriendverifieshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncFriendVerifiesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncFriendVerifiesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncFriendVerifiesLogic(r.Context(), svcCtx)
resp, err := l.GetSyncFriendVerifies(&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/datasync/datasync_api/internal/handler/getsyncchatuserconversationshandler.go | app/datasync/datasync_api/internal/handler/getsyncchatuserconversationshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncChatUserConversationsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncChatUserConversationsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncChatUserConversationsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncChatUserConversations(&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/datasync/datasync_api/internal/handler/getsyncchatmessageshandler.go | app/datasync/datasync_api/internal/handler/getsyncchatmessageshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncChatMessagesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncChatMessagesReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncChatMessagesLogic(r.Context(), svcCtx)
resp, err := l.GetSyncChatMessages(&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/datasync/datasync_api/internal/handler/getsyncfriendshandler.go | app/datasync/datasync_api/internal/handler/getsyncfriendshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncFriendsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncFriendsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncFriendsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncFriends(&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/datasync/datasync_api/internal/handler/getsyncnotificationeventshandler.go | app/datasync/datasync_api/internal/handler/getsyncnotificationeventshandler.go | package handler
import (
"net/http"
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncNotificationEventsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncNotificationEventsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncNotificationEventsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncNotificationEvents(&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/datasync/datasync_api/internal/handler/getsyncnotificationreadcursorshandler.go | app/datasync/datasync_api/internal/handler/getsyncnotificationreadcursorshandler.go | package handler
import (
"net/http"
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncNotificationReadCursorsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncNotificationReadCursorsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncNotificationReadCursorsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncNotificationReadCursors(&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/datasync/datasync_api/internal/handler/getsyncemojicollectshandler.go | app/datasync/datasync_api/internal/handler/getsyncemojicollectshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncEmojiCollectsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncEmojiCollectsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncEmojiCollectsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncEmojiCollects(&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/datasync/datasync_api/internal/handler/getsyncgroupinfohandler.go | app/datasync/datasync_api/internal/handler/getsyncgroupinfohandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncGroupInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncGroupInfoReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncGroupInfoLogic(r.Context(), svcCtx)
resp, err := l.GetSyncGroupInfo(&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/datasync/datasync_api/internal/handler/getsyncgroupmembershandler.go | app/datasync/datasync_api/internal/handler/getsyncgroupmembershandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncGroupMembersHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncGroupMembersReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncGroupMembersLogic(r.Context(), svcCtx)
resp, err := l.GetSyncGroupMembers(&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/datasync/datasync_api/internal/handler/getsyncgrouprequestshandler.go | app/datasync/datasync_api/internal/handler/getsyncgrouprequestshandler.go | package handler
import (
"beaver/app/datasync/datasync_api/internal/logic"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getSyncGroupRequestsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSyncGroupRequestsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetSyncGroupRequestsLogic(r.Context(), svcCtx)
resp, err := l.GetSyncGroupRequests(&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/datasync/datasync_api/internal/handler/routes.go | app/datasync/datasync_api/internal/handler/routes.go | // Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
"beaver/app/datasync/datasync_api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 获取所有需要更新的用户版本信息
Method: http.MethodPost,
Path: "/api/datasync/getSyncAllUsers",
Handler: getSyncAllUsersHandler(serverCtx),
},
{
// 获取所有需要更新的会话元信息版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncChatConversations",
Handler: getSyncChatConversationsHandler(serverCtx),
},
{
// 获取所有需要更新的聊天消息版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncChatMessages",
Handler: getSyncChatMessagesHandler(serverCtx),
},
{
// 获取所有需要更新的用户会话设置版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncChatUserConversations",
Handler: getSyncChatUserConversationsHandler(serverCtx),
},
{
// 获取用户表情收藏的版本信息
Method: http.MethodPost,
Path: "/api/datasync/getSyncEmojiCollects",
Handler: getSyncEmojiCollectsHandler(serverCtx),
},
{
// 获取表情基础数据版本信息
Method: http.MethodPost,
Path: "/api/datasync/getSyncEmojis",
Handler: getSyncEmojisHandler(serverCtx),
},
{
// 获取所有需要更新的好友验证版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncFriendVerifies",
Handler: getSyncFriendVerifiesHandler(serverCtx),
},
{
// 获取所有需要更新的好友版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncFriends",
Handler: getSyncFriendsHandler(serverCtx),
},
{
// 获取所有需要更新的群组信息版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncGroupInfo",
Handler: getSyncGroupInfoHandler(serverCtx),
},
{
// 获取所有需要更新的群成员版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncGroupMembers",
Handler: getSyncGroupMembersHandler(serverCtx),
},
{
// 获取所有需要更新的入群申请版本
Method: http.MethodPost,
Path: "/api/datasync/getSyncGroupRequests",
Handler: getSyncGroupRequestsHandler(serverCtx),
},
{
// 获取通知事件版本摘要
Method: http.MethodPost,
Path: "/api/datasync/getSyncNotificationEvents",
Handler: getSyncNotificationEventsHandler(serverCtx),
},
{
// 获取通知收件箱版本摘要
Method: http.MethodPost,
Path: "/api/datasync/getSyncNotificationInboxes",
Handler: getSyncNotificationInboxesHandler(serverCtx),
},
{
// 获取通知已读游标版本摘要
Method: http.MethodPost,
Path: "/api/datasync/getSyncNotificationReadCursors",
Handler: getSyncNotificationReadCursorsHandler(serverCtx),
},
},
)
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncgrouprequestslogic.go | app/datasync/datasync_api/internal/logic/getsyncgrouprequestslogic.go | package logic
import (
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/group/group_rpc/types/group_rpc"
"context"
"errors"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncGroupRequestsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的入群申请版本
func NewGetSyncGroupRequestsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncGroupRequestsLogic {
return &GetSyncGroupRequestsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncGroupRequestsLogic) GetSyncGroupRequests(req *types.GetSyncGroupRequestsReq) (resp *types.GetSyncGroupRequestsRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 获取用户群组申请版本信息
versionResp, err := l.svcCtx.GroupRpc.GetUserGroupRequestVersions(l.ctx, &group_rpc.GetUserGroupRequestVersionsReq{
UserID: userId,
Since: req.Since,
})
if err != nil {
l.Errorf("获取用户群组申请版本失败: %v", err)
return nil, err
}
// 转换为响应格式，确保返回空数组而不是null
groupVersions := make([]types.GroupRequestsVersionItem, 0)
if versionResp.Versions != nil {
for _, version := range versionResp.Versions {
groupVersions = append(groupVersions, types.GroupRequestsVersionItem{
GroupID: version.GroupID,
Version: version.Version,
})
}
}
return &types.GetSyncGroupRequestsRes{
GroupVersions: groupVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncalluserslogic.go | app/datasync/datasync_api/internal/logic/getsyncalluserslogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/user/user_rpc/types/user_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncAllUsersLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取需要同步的用户列表
func NewGetSyncAllUsersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncAllUsersLogic {
return &GetSyncAllUsersLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncAllUsersLogic) GetSyncAllUsers(req *types.GetSyncAllUsersReq) (resp *types.GetSyncAllUsersRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 根据类型获取相关用户ID列表
var relatedUserIds []string
// 确定需要获取哪些数据
needFriends := req.Type == "" || req.Type == "all" || req.Type == "friends"
needGroups := req.Type == "" || req.Type == "all" || req.Type == "groups"
// 使用map进行去重
userMap := make(map[string]bool)
// 始终包含自己的ID
userMap[userId] = true
// 获取好友列表
if needFriends {
friendResp, err := l.svcCtx.FriendRpc.GetFriendIds(l.ctx, &friend_rpc.GetFriendIdsRequest{
UserID: userId,
})
if err != nil {
l.Errorf("获取好友列表失败: %v", err)
return nil, err
}
for _, uid := range friendResp.FriendIds {
userMap[uid] = true
}
}
// 获取群成员列表
if needGroups {
groupResp, err := l.svcCtx.GroupRpc.GetUserGroupMembers(l.ctx, &group_rpc.GetUserGroupMembersReq{
UserID: userId,
})
if err != nil {
l.Errorf("获取群成员列表失败: %v", err)
return nil, err
}
for _, uid := range groupResp.MemberIDs {
userMap[uid] = true
}
}
// 获取好友验证申请相关的用户（申请加我好友的人）
if needFriends {
verifyResp, err := l.svcCtx.FriendRpc.GetFriendVerifyVersions(l.ctx, &friend_rpc.GetFriendVerifyVersionsReq{
UserId: userId,
Since: 0, // 获取所有相关验证，不需要增量
})
if err != nil {
l.Errorf("获取好友验证列表失败: %v", err)
return nil, err
}
// 获取验证详情以提取申请者ID
if len(verifyResp.FriendVerifyVersions) > 0 {
verifyIds := make([]string, 0, len(verifyResp.FriendVerifyVersions))
for _, verify := range verifyResp.FriendVerifyVersions {
verifyIds = append(verifyIds, verify.VerifyId)
}
verifyDetailResp, err := l.svcCtx.FriendRpc.GetFriendVerifiesListByIds(l.ctx, &friend_rpc.GetFriendVerifiesListByIdsReq{
VerifyIds: verifyIds,
})
if err != nil {
l.Errorf("获取好友验证详情失败: %v", err)
return nil, err
}
for _, verify := range verifyDetailResp.FriendVerifies {
// 添加发送申请的用户
userMap[verify.SendUserId] = true
// 添加接收申请的用户（通常是当前用户自己，但为了完整性也添加）
userMap[verify.RevUserId] = true
}
}
}
// 获取群申请相关的用户（申请加入我管理的群的人）
if needGroups {
// 1. 获取用户管理的群组
groupIDsResp, err := l.svcCtx.GroupRpc.GetUserGroupIDs(l.ctx, &group_rpc.GetUserGroupIDsReq{
UserID: userId,
})
if err != nil {
l.Errorf("获取用户群组ID列表失败: %v", err)
return nil, err
}
if len(groupIDsResp.GroupIDs) > 0 {
// 2. 获取这些群的加入申请
requestResp, err := l.svcCtx.GroupRpc.GetGroupJoinRequestsListByIds(l.ctx, &group_rpc.GetGroupJoinRequestsListByIdsReq{
GroupIDs: groupIDsResp.GroupIDs,
Since: 0, // 获取所有申请，不需要增量
})
if err != nil {
l.Errorf("获取群加入申请失败: %v", err)
return nil, err
}
// 3. 提取申请者用户ID
for _, request := range requestResp.Requests {
userMap[request.UserID] = true
}
}
}
// 检查是否有不支持的类型
if !needFriends && !needGroups {
l.Errorf("不支持的类型: %s", req.Type)
return nil, errors.New("不支持的类型")
}
// 转换为切片
for uid := range userMap {
relatedUserIds = append(relatedUserIds, uid)
}
if len(relatedUserIds) == 0 {
return &types.GetSyncAllUsersRes{
UserVersions: []types.UserVersionItem{},
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
// 调用user RPC获取用户信息，支持增量同步
userResp, err := l.svcCtx.UserRpc.UserListInfo(l.ctx, &user_rpc.UserListInfoReq{
UserIdList: relatedUserIds,
SinceTimestamp: req.Since, // 传递since参数进行增量过滤
})
if err != nil {
l.Errorf("调用user RPC获取用户信息失败: %v", err)
return nil, err
}
// 转换为版本摘要，确保返回空数组而不是null
userVersions := make([]types.UserVersionItem, 0)
if userResp.UserInfo != nil {
for userId, userInfo := range userResp.UserInfo {
userVersions = append(userVersions, types.UserVersionItem{
UserID: userId,
Version: userInfo.Version,
})
}
}
return &types.GetSyncAllUsersRes{
UserVersions: userVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncfriendslogic.go | app/datasync/datasync_api/internal/logic/getsyncfriendslogic.go | package logic
import (
"context"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncFriendsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的好友版本
func NewGetSyncFriendsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncFriendsLogic {
return &GetSyncFriendsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncFriendsLogic) GetSyncFriends(req *types.GetSyncFriendsReq) (resp *types.GetSyncFriendsRes, err error) {
// 调用Friend RPC获取好友版本信息
friendResp, err := l.svcCtx.FriendRpc.GetFriendVersions(l.ctx, &friend_rpc.GetFriendVersionsReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取好友版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
l.Infof("查询到 %d 个好友版本信息", len(friendResp.FriendVersions))
// 转换为响应格式，确保返回空数组而不是null
friendVersions := make([]types.FriendVersionItem, 0)
if friendResp.FriendVersions != nil {
for _, friend := range friendResp.FriendVersions {
friendVersions = append(friendVersions, types.FriendVersionItem{
FriendId: friend.FriendId,
Version: friend.Version,
})
}
}
return &types.GetSyncFriendsRes{
FriendVersions: friendVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncchatmessageslogic.go | app/datasync/datasync_api/internal/logic/getsyncchatmessageslogic.go | package logic
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"context"
"errors"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncChatMessagesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的聊天消息版本
func NewGetSyncChatMessagesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncChatMessagesLogic {
return &GetSyncChatMessagesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncChatMessagesLogic) GetSyncChatMessages(req *types.GetSyncChatMessagesReq) (resp *types.GetSyncChatMessagesRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 获取用户参与的会话列表
conversationsResp, err := l.svcCtx.ChatRpc.GetUserConversations(l.ctx, &chat_rpc.GetUserConversationsReq{
UserId: userId,
})
if err != nil {
l.Errorf("获取用户会话列表失败: %v", err)
return nil, err
}
conversationIDs := make([]string, 0, len(conversationsResp.Conversations))
for _, conv := range conversationsResp.Conversations {
conversationIDs = append(conversationIDs, conv.ConversationId)
}
if len(conversationIDs) == 0 {
return &types.GetSyncChatMessagesRes{
MessageVersions: []types.ChatMessageVersionItem{},
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
// 获取变更的消息版本信息
serverTimestamp := time.Now().UnixMilli()
messagesResp, err := l.svcCtx.ChatRpc.GetConversationsListByIds(l.ctx, &chat_rpc.GetConversationsListByIdsReq{
ConversationIds: conversationIDs,
Since: req.Since,
})
if err != nil {
l.Errorf("获取变更的会话版本失败: %v", err)
return nil, err
}
// 转换为响应格式，只提取消息序列号信息，确保返回空数组而不是null
messageVersions := make([]types.ChatMessageVersionItem, 0)
if messagesResp.Conversations != nil {
for _, conv := range messagesResp.Conversations {
messageVersions = append(messageVersions, types.ChatMessageVersionItem{
ConversationID: conv.ConversationId,
Seq: conv.Seq,
})
}
}
return &types.GetSyncChatMessagesRes{
MessageVersions: messageVersions,
ServerTimestamp: serverTimestamp,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncchatuserconversationslogic.go | app/datasync/datasync_api/internal/logic/getsyncchatuserconversationslogic.go | package logic
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"context"
"errors"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncChatUserConversationsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的用户会话设置版本
func NewGetSyncChatUserConversationsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncChatUserConversationsLogic {
return &GetSyncChatUserConversationsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncChatUserConversationsLogic) GetSyncChatUserConversations(req *types.GetSyncChatUserConversationsReq) (resp *types.GetSyncChatUserConversationsRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 直接获取用户的所有会话设置版本（一个RPC调用搞定）
serverTimestamp := time.Now().UnixMilli()
userConvResp, err := l.svcCtx.ChatRpc.GetUserConversationVersions(l.ctx, &chat_rpc.GetUserConversationVersionsReq{
UserId: userId,
Since: req.Since,
})
if err != nil {
l.Errorf("获取用户会话设置版本失败: %v", err)
return nil, err
}
// 转换为响应格式，确保返回空数组而不是null
userConversationVersions := make([]types.ChatUserConversationVersionItem, 0)
if userConvResp.UserConversationVersions != nil {
for _, userConv := range userConvResp.UserConversationVersions {
userConversationVersions = append(userConversationVersions, types.ChatUserConversationVersionItem{
ConversationID: userConv.ConversationId,
Version: userConv.Version,
})
}
}
return &types.GetSyncChatUserConversationsRes{
UserConversationVersions: userConversationVersions,
ServerTimestamp: serverTimestamp,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncnotificationeventslogic.go | app/datasync/datasync_api/internal/logic/getsyncnotificationeventslogic.go | package logic
import (
"context"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncNotificationEventsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取通知事件版本摘要
func NewGetSyncNotificationEventsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncNotificationEventsLogic {
return &GetSyncNotificationEventsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncNotificationEventsLogic) GetSyncNotificationEvents(req *types.GetSyncNotificationEventsReq) (resp *types.GetSyncNotificationEventsRes, err error) {
rpcResp, err := l.svcCtx.NotificationRpc.GetEventVersions(l.ctx, ¬ification_rpc.GetEventVersionsReq{
SinceVersion: req.SinceVersion,
Limit: req.Limit,
})
if err != nil {
l.Errorf("获取通知事件版本摘要失败: sinceVersion=%d, limit=%d, err=%v", req.SinceVersion, req.Limit, err)
return nil, err
}
eventVersions := make([]types.NotificationEventVersionItem, 0)
for _, item := range rpcResp.EventVersions {
eventVersions = append(eventVersions, types.NotificationEventVersionItem{
EventID: item.EventId,
Version: item.Version,
})
}
return &types.GetSyncNotificationEventsRes{
EventVersions: eventVersions,
MaxVersion: rpcResp.MaxVersion,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncnotificationreadcursorslogic.go | app/datasync/datasync_api/internal/logic/getsyncnotificationreadcursorslogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncNotificationReadCursorsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取通知已读游标版本摘要
func NewGetSyncNotificationReadCursorsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncNotificationReadCursorsLogic {
return &GetSyncNotificationReadCursorsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncNotificationReadCursorsLogic) GetSyncNotificationReadCursors(req *types.GetSyncNotificationReadCursorsReq) (resp *types.GetSyncNotificationReadCursorsRes, err error) {
if req.UserID == "" {
return nil, errors.New("用户ID不能为空")
}
rpcResp, err := l.svcCtx.NotificationRpc.GetReadCursorVersions(l.ctx, ¬ification_rpc.GetReadCursorVersionsReq{
UserId: req.UserID,
SinceVersion: req.SinceVersion,
})
if err != nil {
l.Errorf("获取通知已读游标版本摘要失败: userId=%s, sinceVersion=%d, err=%v", req.UserID, req.SinceVersion, err)
return nil, err
}
cursorVersions := make([]types.NotificationReadCursorVersionItem, 0)
for _, item := range rpcResp.CursorVersions {
cursorVersions = append(cursorVersions, types.NotificationReadCursorVersionItem{
Category: item.Category,
Version: item.Version,
})
}
return &types.GetSyncNotificationReadCursorsRes{
CursorVersions: cursorVersions,
MaxVersion: rpcResp.MaxVersion,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncnotificationinboxeslogic.go | app/datasync/datasync_api/internal/logic/getsyncnotificationinboxeslogic.go | package logic
import (
"context"
"errors"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/notification/notification_rpc/types/notification_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncNotificationInboxesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取通知收件箱版本摘要
func NewGetSyncNotificationInboxesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncNotificationInboxesLogic {
return &GetSyncNotificationInboxesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncNotificationInboxesLogic) GetSyncNotificationInboxes(req *types.GetSyncNotificationInboxesReq) (resp *types.GetSyncNotificationInboxesRes, err error) {
if req.UserID == "" {
return nil, errors.New("用户ID不能为空")
}
rpcResp, err := l.svcCtx.NotificationRpc.GetInboxVersions(l.ctx, ¬ification_rpc.GetInboxVersionsReq{
UserId: req.UserID,
SinceVersion: req.SinceVersion,
Limit: req.Limit,
})
if err != nil {
l.Errorf("获取通知收件箱版本摘要失败: userId=%s, sinceVersion=%d, limit=%d, err=%v", req.UserID, req.SinceVersion, req.Limit, err)
return nil, err
}
inboxVersions := make([]types.NotificationInboxVersionItem, 0)
for _, item := range rpcResp.InboxVersions {
inboxVersions = append(inboxVersions, types.NotificationInboxVersionItem{
EventID: item.EventId,
Version: item.Version,
})
}
return &types.GetSyncNotificationInboxesRes{
InboxVersions: inboxVersions,
MaxVersion: rpcResp.MaxVersion,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncemojicollectslogic.go | app/datasync/datasync_api/internal/logic/getsyncemojicollectslogic.go | package logic
import (
"context"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/emoji/emoji_rpc/types/emoji_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncEmojiCollectsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取用户表情收藏的版本信息
func NewGetSyncEmojiCollectsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncEmojiCollectsLogic {
return &GetSyncEmojiCollectsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncEmojiCollectsLogic) GetSyncEmojiCollects(req *types.GetSyncEmojiCollectsReq) (resp *types.GetSyncEmojiCollectsRes, err error) {
// 初始化结果变量
emojiCollectVersions := make([]types.EmojiCollectVersionItem, 0)
emojiPackageCollectVersions := make([]types.EmojiPackageCollectVersionItem, 0)
emojiPackageVersions := make([]types.EmojiPackageVersionItem, 0)
emojiPackageContentVersions := make([]types.EmojiPackageContentVersionItem, 0)
// 1. 获取用户收藏的表情版本信息
emojiCollectResp, err := l.svcCtx.EmojiRpc.GetUserEmojiCollects(l.ctx, &emoji_rpc.GetUserEmojiCollectsReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取用户收藏表情版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
// 转换用户收藏的表情数据（使用收藏记录ID）
if emojiCollectResp.EmojiCollectVersions != nil {
for _, item := range emojiCollectResp.EmojiCollectVersions {
emojiCollectVersions = append(emojiCollectVersions, types.EmojiCollectVersionItem{
EmojiCollectId: item.EmojiCollectId,
Version: item.Version,
})
}
}
// 2. 获取用户收藏的表情包版本信息
emojiPackageCollectResp, err := l.svcCtx.EmojiRpc.GetUserEmojiPackageCollects(l.ctx, &emoji_rpc.GetUserEmojiPackageCollectsReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取用户收藏表情包版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
// 转换用户收藏的表情包数据（使用收藏记录ID）
if emojiPackageCollectResp.EmojiPackageCollectVersions != nil {
for _, item := range emojiPackageCollectResp.EmojiPackageCollectVersions {
emojiPackageCollectVersions = append(emojiPackageCollectVersions, types.EmojiPackageCollectVersionItem{
PackageCollectId: item.PackageCollectId,
Version: item.Version,
})
}
}
// 3. 获取表情包基础数据版本信息
emojiPackagesResp, err := l.svcCtx.EmojiRpc.GetEmojiPackages(l.ctx, &emoji_rpc.GetEmojiPackagesReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取表情包基础数据版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
// 转换表情包数据
if emojiPackagesResp.EmojiPackageVersions != nil {
for _, item := range emojiPackagesResp.EmojiPackageVersions {
emojiPackageVersions = append(emojiPackageVersions, types.EmojiPackageVersionItem{
PackageId: item.PackageId,
Version: item.Version,
})
}
}
// 4. 获取表情包内容版本信息
emojiPackageContentsResp, err := l.svcCtx.EmojiRpc.GetEmojiPackageContents(l.ctx, &emoji_rpc.GetEmojiPackageContentsReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取表情包内容版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
// 转换表情包内容数据
if emojiPackageContentsResp.EmojiPackageContentVersions != nil {
for _, item := range emojiPackageContentsResp.EmojiPackageContentVersions {
emojiPackageContentVersions = append(emojiPackageContentVersions, types.EmojiPackageContentVersionItem{
PackageId: item.PackageId,
Version: item.Version,
})
}
}
l.Infof("用户 %s 表情收藏同步完成: 收藏表情=%d, 收藏表情包=%d, 表情包=%d, 表情包内容=%d",
req.UserID, len(emojiCollectVersions), len(emojiPackageCollectVersions),
len(emojiPackageVersions), len(emojiPackageContentVersions))
return &types.GetSyncEmojiCollectsRes{
EmojiCollectVersions: emojiCollectVersions,
EmojiPackageCollectVersions: emojiPackageCollectVersions,
EmojiPackageVersions: emojiPackageVersions,
EmojiPackageContentVersions: emojiPackageContentVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncemojislogic.go | app/datasync/datasync_api/internal/logic/getsyncemojislogic.go | package logic
import (
"context"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/emoji/emoji_rpc/types/emoji_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncEmojisLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取表情基础数据版本信息
func NewGetSyncEmojisLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncEmojisLogic {
return &GetSyncEmojisLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncEmojisLogic) GetSyncEmojis(req *types.GetSyncEmojisReq) (resp *types.GetSyncEmojisRes, err error) {
// 调用Emoji RPC获取表情版本信息
emojiResp, err := l.svcCtx.EmojiRpc.GetEmojis(l.ctx, &emoji_rpc.GetEmojisReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取表情版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
l.Infof("查询到 %d 个表情版本信息", len(emojiResp.EmojiVersions))
// 转换为响应格式，确保返回空数组而不是null
emojiVersions := make([]types.EmojiVersionItem, 0)
if emojiResp.EmojiVersions != nil {
for _, emoji := range emojiResp.EmojiVersions {
emojiVersions = append(emojiVersions, types.EmojiVersionItem{
EmojiId: emoji.EmojiId,
Version: emoji.Version,
})
}
}
return &types.GetSyncEmojisRes{
EmojiVersions: emojiVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncchatconversationslogic.go | app/datasync/datasync_api/internal/logic/getsyncchatconversationslogic.go | package logic
import (
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"context"
"errors"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncChatConversationsLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的会话元信息版本
func NewGetSyncChatConversationsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncChatConversationsLogic {
return &GetSyncChatConversationsLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncChatConversationsLogic) GetSyncChatConversations(req *types.GetSyncChatConversationsReq) (resp *types.GetSyncChatConversationsRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 获取用户参与的会话列表
conversationsResp, err := l.svcCtx.ChatRpc.GetUserConversations(l.ctx, &chat_rpc.GetUserConversationsReq{
UserId: userId,
})
if err != nil {
l.Errorf("获取用户会话列表失败: %v", err)
return nil, err
}
conversationIDs := make([]string, 0, len(conversationsResp.Conversations))
for _, conv := range conversationsResp.Conversations {
conversationIDs = append(conversationIDs, conv.ConversationId)
}
if len(conversationIDs) == 0 {
return &types.GetSyncChatConversationsRes{
ConversationVersions: []types.ChatConversationVersionItem{},
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
// 获取变更的会话元信息版本
serverTimestamp := time.Now().UnixMilli()
convResp, err := l.svcCtx.ChatRpc.GetConversationsListByIds(l.ctx, &chat_rpc.GetConversationsListByIdsReq{
ConversationIds: conversationIDs,
Since: req.Since,
})
if err != nil {
l.Errorf("获取变更的会话版本信息失败: %v", err)
return nil, err
}
// 转换为响应格式，只提取会话元信息版本，确保返回空数组而不是null
conversationVersions := make([]types.ChatConversationVersionItem, 0)
if convResp.Conversations != nil {
for _, conv := range convResp.Conversations {
conversationVersions = append(conversationVersions, types.ChatConversationVersionItem{
ConversationID: conv.ConversationId,
Version: conv.Version,
})
}
}
return &types.GetSyncChatConversationsRes{
ConversationVersions: conversationVersions,
ServerTimestamp: serverTimestamp,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncfriendverifieslogic.go | app/datasync/datasync_api/internal/logic/getsyncfriendverifieslogic.go | package logic
import (
"context"
"time"
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncFriendVerifiesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的好友验证版本
func NewGetSyncFriendVerifiesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncFriendVerifiesLogic {
return &GetSyncFriendVerifiesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncFriendVerifiesLogic) GetSyncFriendVerifies(req *types.GetSyncFriendVerifiesReq) (resp *types.GetSyncFriendVerifiesRes, err error) {
// 调用Friend RPC获取好友验证版本信息
verifyResp, err := l.svcCtx.FriendRpc.GetFriendVerifyVersions(l.ctx, &friend_rpc.GetFriendVerifyVersionsReq{
UserId: req.UserID,
Since: req.Since,
})
if err != nil {
l.Errorf("获取好友验证版本信息失败: userId=%s, since=%d, error=%v", req.UserID, req.Since, err)
return nil, err
}
l.Infof("查询到 %d 个好友验证版本信息", len(verifyResp.FriendVerifyVersions))
// 转换为响应格式，确保返回空数组而不是null
friendVerifyVersions := make([]types.FriendVerifyVersionItem, 0)
if verifyResp.FriendVerifyVersions != nil {
for _, verify := range verifyResp.FriendVerifyVersions {
friendVerifyVersions = append(friendVerifyVersions, types.FriendVerifyVersionItem{
VerifyId: verify.VerifyId,
Version: verify.Version,
})
}
}
return &types.GetSyncFriendVerifiesRes{
FriendVerifyVersions: friendVerifyVersions,
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncgroupinfologic.go | app/datasync/datasync_api/internal/logic/getsyncgroupinfologic.go | package logic
import (
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/group/group_rpc/types/group_rpc"
"context"
"errors"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncGroupInfoLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的群组信息版本
func NewGetSyncGroupInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncGroupInfoLogic {
return &GetSyncGroupInfoLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncGroupInfoLogic) GetSyncGroupInfo(req *types.GetSyncGroupInfoReq) (resp *types.GetSyncGroupInfoRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 1. 获取用户加入的群组ID列表
groupIDsResp, err := l.svcCtx.GroupRpc.GetUserGroupIDs(l.ctx, &group_rpc.GetUserGroupIDsReq{
UserID: userId,
})
if err != nil {
l.Errorf("获取用户群组ID列表失败: %v", err)
return nil, err
}
groupIDs := groupIDsResp.GroupIDs
if len(groupIDs) == 0 {
return &types.GetSyncGroupInfoRes{
GroupVersions: []types.GroupInfoVersionItem{},
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
fmt.Println("111111111111111111")
fmt.Println(groupIDs)
// 2. 获取变更的群组资料
serverTimestamp := time.Now().UnixMilli()
groupResp, err := l.svcCtx.GroupRpc.GetGroupsListByIds(l.ctx, &group_rpc.GetGroupsListByIdsReq{
GroupIDs: groupIDs,
Since: req.Since,
})
if err != nil {
l.Errorf("获取变更的群组资料失败: %v", err)
return nil, err
}
// 3. 转换为响应格式，确保返回空数组而不是null
groupVersions := make([]types.GroupInfoVersionItem, 0)
if groupResp.Groups != nil {
for _, group := range groupResp.Groups {
groupVersions = append(groupVersions, types.GroupInfoVersionItem{
GroupID: group.GroupID,
Version: group.Version,
})
}
}
return &types.GetSyncGroupInfoRes{
GroupVersions: groupVersions,
ServerTimestamp: serverTimestamp,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/datasync/datasync_api/internal/logic/getsyncgroupmemberslogic.go | app/datasync/datasync_api/internal/logic/getsyncgroupmemberslogic.go | package logic
import (
"beaver/app/datasync/datasync_api/internal/svc"
"beaver/app/datasync/datasync_api/internal/types"
"beaver/app/group/group_rpc/types/group_rpc"
"context"
"errors"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
type GetSyncGroupMembersLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取所有需要更新的群成员版本
func NewGetSyncGroupMembersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSyncGroupMembersLogic {
return &GetSyncGroupMembersLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetSyncGroupMembersLogic) GetSyncGroupMembers(req *types.GetSyncGroupMembersReq) (resp *types.GetSyncGroupMembersRes, err error) {
userId := req.UserID
if userId == "" {
l.Errorf("用户ID为空")
return nil, errors.New("用户ID不能为空")
}
// 1. 获取用户加入的群组ID列表
groupIDsResp, err := l.svcCtx.GroupRpc.GetUserGroupIDs(l.ctx, &group_rpc.GetUserGroupIDsReq{
UserID: userId,
})
if err != nil {
l.Errorf("获取用户群组ID列表失败: %v", err)
return nil, err
}
groupIDs := groupIDsResp.GroupIDs
if len(groupIDs) == 0 {
return &types.GetSyncGroupMembersRes{
GroupVersions: []types.GroupMembersVersionItem{},
ServerTimestamp: time.Now().UnixMilli(),
}, nil
}
// 2. 获取变更的群成员
serverTimestamp := time.Now().UnixMilli()
memberResp, err := l.svcCtx.GroupRpc.GetGroupMembersListByIds(l.ctx, &group_rpc.GetGroupMembersListByIdsReq{
GroupIDs: groupIDs,
Since: req.Since,
})
if err != nil {
l.Errorf("获取变更的群成员失败: %v", err)
return nil, err
}
// 3. 合并版本信息，按群组聚合最新版本
groupVersionsMap := make(map[string]int64)
for _, member := range memberResp.Members {
if currentVersion, exists := groupVersionsMap[member.GroupID]; !exists || member.Version > currentVersion {
groupVersionsMap[member.GroupID] = member.Version
}
}
// 4. 转换为响应格式，确保返回空数组而不是null
groupVersions := make([]types.GroupMembersVersionItem, 0)
if groupVersionsMap != nil {
for groupID, version := range groupVersionsMap {
groupVersions = append(groupVersions, types.GroupMembersVersionItem{
GroupID: groupID,
Version: version,
})
}
}
return &types.GetSyncGroupMembersRes{
GroupVersions: groupVersions,
ServerTimestamp: serverTimestamp,
}, nil
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/mcp/mcp_api/mcp.go | app/mcp/mcp_api/mcp.go | package main
import (
"beaver/app/mcp/mcp_api/internal/config"
"beaver/app/mcp/mcp_api/internal/handler"
"beaver/app/mcp/mcp_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"flag"
"fmt"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/mcp.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
server.Use(middleware.RequestLogMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/mcp/mcp_api/internal/svc/servicecontext.go | app/mcp/mcp_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/mcp/mcp_api/internal/config"
)
type ServiceContext struct {
Config config.Config
}
func NewServiceContext(c config.Config) *ServiceContext {
return &ServiceContext{
Config: c,
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/mcp/mcp_api/internal/types/types.go | app/mcp/mcp_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type ExecuteToolReq struct {
Action string `json:"action"` // 工具名称
Params map[string]interface{} `json:"params"` // 工具参数
}
type ExecuteToolRes struct {
Success bool `json:"success"` // 是否成功
Action string `json:"action"` // 执行的工具
Result interface{} `json:"result"` // 执行结果
}
type ListToolsRes struct {
Success bool `json:"success"` // 是否成功
Total int64 `json:"total"` // 工具总数
Tools []MCPTool `json:"tools"` // 工具列表
Usage UsageInfo `json:"usage"` // 使用说明
}
type MCPTool struct {
Name string `json:"name"` // 工具名称
Description string `json:"description"` // 工具描述
InputSchema map[string]interface{} `json:"inputSchema"` // 输入参数schema
Category string `json:"category"` // 工具分类
Version string `json:"version"` // 版本号
}
type UsageInfo struct {
ExecuteURL string `json:"execute_url"` // 执行接口URL
Method string `json:"method"` // 请求方法
BodyFormat map[string]interface{} `json:"body_format"` // 请求体格式
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/mcp/mcp_api/internal/config/config.go | app/mcp/mcp_api/internal/config/config.go | package config
import "github.com/zeromicro/go-zero/rest"
type Config struct {
rest.RestConf
Mysql struct {
DataSource string
}
Etcd string
Redis struct {
Addr string
Password string
Db int
}
}
| 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.