init

Backend/internal/logic/ForumComments/forum_comments.go

@@ -0,0 +1,218 @@
+package ForumComments
+
+import (
+	"context"
+	"errors"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"leke/api/forum/v1"
+	"leke/internal/dao"
+	"leke/internal/model/entity"
+	"leke/internal/service"
+)
+
+// ForumComments  评论相关方法
+type sForumComments struct{}
+
+func init() {
+	service.RegisterForumComments(&sForumComments{})
+}
+
+// ForumCommentsCreate 创建评论
+func (s *sForumComments) Create(ctx context.Context, req *v1.ForumCommentsCreateReq) (res *v1.ForumCommentsCreateRes, err error) {
+	data := &entity.ForumComments{
+		UserId:     req.UserId,
+		PostId:     req.PostId,
+		ParentId:   req.ParentId,
+		Content:    req.Content,
+		Status:     req.Status,
+		LikeCount:  0,
+		ReplyCount: 0,
+	}
+
+	result, err := dao.ForumComments.Ctx(ctx).Data(data).OmitEmpty().Insert()
+	if err != nil {
+		return nil, gerror.Wrap(err, "创建评论失败")
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, gerror.Wrap(err, "获取评论ID失败")
+	}
+
+	// 更新帖子的评论数
+	if req.PostId > 0 {
+		_, err = dao.ForumPosts.Ctx(ctx).WherePri(req.PostId).OnDuplicate("comment_count", 1).Update()
+		if err != nil {
+			g.Log().Warning(ctx, "更新帖子评论数失败:", err)
+		}
+	}
+
+	// 如果是回复评论，则更新父评论的回复数
+	if req.ParentId > 0 {
+		_, err = dao.ForumComments.Ctx(ctx).WherePri(req.ParentId).OnDuplicate("reply_count", 1).Update()
+		if err != nil {
+			g.Log().Warning(ctx, "更新父评论回复数失败:", err)
+		}
+	}
+
+	return &v1.ForumCommentsCreateRes{
+		Id: uint64(id),
+	}, nil
+}
+
+// ForumCommentsUpdate 更新评论
+func (s *sForumComments) Update(ctx context.Context, req *v1.ForumCommentsUpdateReq) (res *v1.ForumCommentsUpdateRes, err error) {
+	// 检查评论是否存在
+	one, err := dao.ForumComments.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询评论失败")
+	}
+	if one.IsEmpty() {
+		return nil, errors.New("评论不存在")
+	}
+
+	// 更新评论
+	_, err = dao.ForumComments.Ctx(ctx).WherePri(req.Id).Data(req).OmitEmpty().Update()
+	if err != nil {
+		return nil, gerror.Wrap(err, "更新评论失败")
+	}
+
+	return &v1.ForumCommentsUpdateRes{
+		Id: req.Id,
+	}, nil
+}
+
+// ForumCommentsView 查看评论
+func (s *sForumComments) View(ctx context.Context, req *v1.ForumCommentsViewReq) (res *v1.ForumCommentsViewRes, err error) {
+	record, err := dao.ForumComments.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询评论失败")
+	}
+	if record.IsEmpty() {
+		return nil, errors.New("评论不存在")
+	}
+
+	var entity *entity.ForumComments
+	err = record.Struct(&entity)
+	if err != nil {
+		return nil, gerror.Wrap(err, "解析评论数据失败")
+	}
+
+	res = &v1.ForumCommentsViewRes{
+		Id:         entity.Id,
+		UserId:     entity.UserId,
+		PostId:     entity.PostId,
+		ParentId:   entity.ParentId,
+		Content:    entity.Content,
+		Status:     entity.Status,
+		LikeCount:  entity.LikeCount,
+		ReplyCount: entity.ReplyCount,
+		CreatedAt:  entity.CreatedAt,
+		UpdatedAt:  entity.UpdatedAt,
+	}
+
+	return res, nil
+}
+
+// ForumCommentsList 评论列表
+func (s *sForumComments) List(ctx context.Context, req *v1.ForumCommentsListReq) (res *v1.ForumCommentsListRes, err error) {
+	query := dao.ForumComments.Ctx(ctx).OmitEmpty()
+
+	if req.UserId > 0 {
+		query = query.Where("user_id", req.UserId)
+	}
+	if req.PostId > 0 {
+		query = query.Where("post_id", req.PostId)
+	}
+	if req.ParentId > 0 {
+		query = query.Where("parent_id", req.ParentId)
+	}
+	if req.Status != "" {
+		query = query.Where("status", req.Status)
+	}
+
+	// 分页查询
+	pageResult, err := query.Page(req.Page, req.PageSize).Order("created_at DESC").All()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询评论列表失败")
+	}
+
+	var list []*v1.ForumCommentsViewRes
+	for _, record := range pageResult {
+		var entity *entity.ForumComments
+		err = record.Struct(&entity)
+		if err != nil {
+			return nil, gerror.Wrap(err, "解析评论数据失败")
+		}
+
+		item := &v1.ForumCommentsViewRes{
+			Id:         entity.Id,
+			UserId:     entity.UserId,
+			PostId:     entity.PostId,
+			ParentId:   entity.ParentId,
+			Content:    entity.Content,
+			Status:     entity.Status,
+			LikeCount:  entity.LikeCount,
+			ReplyCount: entity.ReplyCount,
+			CreatedAt:  entity.CreatedAt,
+			UpdatedAt:  entity.UpdatedAt,
+		}
+		list = append(list, item)
+	}
+
+	total, err := query.Count()
+	if err != nil {
+		return nil, gerror.Wrap(err, "统计评论总数失败")
+	}
+
+	res = &v1.ForumCommentsListRes{}
+	res.List = list
+	res.Page = req.Page
+	res.PageSize = req.PageSize
+	res.Total = total
+
+	return res, nil
+}
+
+// ForumCommentsDelete 删除评论
+func (s *sForumComments) Delete(ctx context.Context, req *v1.ForumCommentsDeleteReq) (res *v1.ForumCommentsDeleteRes, err error) {
+	// 检查评论是否存在
+	one, err := dao.ForumComments.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询评论失败")
+	}
+	if one.IsEmpty() {
+		return nil, errors.New("评论不存在")
+	}
+
+	var comment *entity.ForumComments
+	err = one.Struct(&comment)
+	if err != nil {
+		return nil, gerror.Wrap(err, "解析评论数据失败")
+	}
+
+	// 软删除评论
+	_, err = dao.ForumComments.Ctx(ctx).WherePri(req.Id).Delete()
+	if err != nil {
+		return nil, gerror.Wrap(err, "删除评论失败")
+	}
+
+	// 更新帖子的评论数
+	if comment.PostId > 0 {
+		_, err = dao.ForumPosts.Ctx(ctx).WherePri(comment.PostId).OnDuplicate("comment_count", 1).Update()
+		if err != nil {
+			g.Log().Warning(ctx, "更新帖子评论数失败:", err)
+		}
+	}
+
+	// 如果是回复评论，则更新父评论的回复数
+	if comment.ParentId > 0 {
+		_, err = dao.ForumComments.Ctx(ctx).WherePri(comment.ParentId).OnDuplicate("reply_count", 1).Update()
+		if err != nil {
+			g.Log().Warning(ctx, "更新父评论回复数失败:", err)
+		}
+	}
+
+	return &v1.ForumCommentsDeleteRes{}, nil
+}

Backend/internal/logic/ForumComments/forum_posts.go

@@ -0,0 +1,186 @@
+package ForumComments
+
+import (
+	"context"
+	"errors"
+	"leke/api/forum/v1"
+	"leke/internal/dao"
+	"leke/internal/model/entity"
+	"leke/internal/service"
+
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+type sForumPosts struct{}
+
+func init() {
+	service.RegisterForumPosts(&sForumPosts{})
+}
+
+// ForumPostsCreate 创建帖子
+func (s *sForumPosts) Create(ctx context.Context, req *v1.ForumPostsCreateReq) (res *v1.ForumPostsCreateRes, err error) {
+	data := &entity.ForumPosts{
+		UserId:       req.UserId,
+		Title:        req.Title,
+		Content:      req.Content,
+		CoverImage:   req.CoverImage,
+		Status:       req.Status,
+		ViewCount:    0,
+		LikeCount:    0,
+		CommentCount: 0,
+	}
+
+	result, err := dao.ForumPosts.Ctx(ctx).Data(data).OmitEmpty().Insert()
+	if err != nil {
+		return nil, gerror.Wrap(err, "创建帖子失败")
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, gerror.Wrap(err, "获取帖子ID失败")
+	}
+
+	return &v1.ForumPostsCreateRes{
+		Id: uint64(id),
+	}, nil
+}
+
+// ForumPostsUpdate 更新帖子
+func (s *sForumPosts) Update(ctx context.Context, req *v1.ForumPostsUpdateReq) (res *v1.ForumPostsUpdateRes, err error) {
+	// 检查帖子是否存在
+	one, err := dao.ForumPosts.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询帖子失败")
+	}
+	if one.IsEmpty() {
+		return nil, errors.New("帖子不存在")
+	}
+
+	// 更新帖子
+	_, err = dao.ForumPosts.Ctx(ctx).WherePri(req.Id).Data(req).OmitEmpty().Update()
+	if err != nil {
+		return nil, gerror.Wrap(err, "更新帖子失败")
+	}
+
+	return &v1.ForumPostsUpdateRes{
+		Id: req.Id,
+	}, nil
+}
+
+// ForumPostsView 查看帖子
+func (s *sForumPosts) View(ctx context.Context, req *v1.ForumPostsViewReq) (res *v1.ForumPostsViewRes, err error) {
+	record, err := dao.ForumPosts.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询帖子失败")
+	}
+	if record.IsEmpty() {
+		return nil, errors.New("帖子不存在")
+	}
+
+	// 更新浏览量
+	_, err = dao.ForumPosts.Ctx(ctx).WherePri(req.Id).OnDuplicate("view_count", "view_count+1").Update()
+	if err != nil {
+		g.Log().Warning(ctx, "更新浏览量失败:", err)
+	}
+
+	var entity *entity.ForumPosts
+	err = record.Struct(&entity)
+	if err != nil {
+		return nil, gerror.Wrap(err, "解析帖子数据失败")
+	}
+
+	res = &v1.ForumPostsViewRes{
+		Id:           entity.Id,
+		UserId:       entity.UserId,
+		Title:        entity.Title,
+		Content:      entity.Content,
+		CoverImage:   entity.CoverImage,
+		Status:       entity.Status,
+		ViewCount:    entity.ViewCount,
+		LikeCount:    entity.LikeCount,
+		CommentCount: entity.CommentCount,
+		CreatedAt:    entity.CreatedAt,
+		UpdatedAt:    entity.UpdatedAt,
+	}
+
+	return res, nil
+}
+
+// ForumPostsList 帖子列表
+func (s *sForumPosts) List(ctx context.Context, req *v1.ForumPostsListReq) (res *v1.ForumPostsListRes, err error) {
+	query := dao.ForumPosts.Ctx(ctx).OmitEmpty()
+
+	if req.UserId > 0 {
+		query = query.Where("user_id", req.UserId)
+	}
+	if req.Title != "" {
+		query = query.WhereLike("title", "%"+req.Title+"%")
+	}
+	if req.Status != "" {
+		query = query.Where("status", req.Status)
+	}
+
+	// 分页查询
+	pageResult, err := query.Page(req.Page, req.PageSize).Order("created_at DESC").All()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询帖子列表失败")
+	}
+
+	var list []*v1.ForumPostsViewRes
+	for _, record := range pageResult {
+		var entity *entity.ForumPosts
+		err = record.Struct(&entity)
+		if err != nil {
+			return nil, gerror.Wrap(err, "解析帖子数据失败")
+		}
+
+		item := &v1.ForumPostsViewRes{
+			Id:           entity.Id,
+			UserId:       entity.UserId,
+			Title:        entity.Title,
+			Content:      entity.Content,
+			CoverImage:   entity.CoverImage,
+			Status:       entity.Status,
+			ViewCount:    entity.ViewCount,
+			LikeCount:    entity.LikeCount,
+			CommentCount: entity.CommentCount,
+			CreatedAt:    entity.CreatedAt,
+			UpdatedAt:    entity.UpdatedAt,
+		}
+		list = append(list, item)
+	}
+
+	total, err := query.Count()
+	if err != nil {
+		return nil, gerror.Wrap(err, "统计帖子总数失败")
+	}
+
+	res = &v1.ForumPostsListRes{}
+	res.List = list
+	res.PageResult.Page = req.Page
+	res.PageResult.PageSize = req.PageSize
+	res.PageResult.Total = total
+
+	return res, nil
+}
+
+// ForumPostsDelete 删除帖子
+func (s *sForumPosts) Delete(ctx context.Context, req *v1.ForumPostsDeleteReq) (res *v1.ForumPostsDeleteRes, err error) {
+	// 检查帖子是否存在
+	one, err := dao.ForumPosts.Ctx(ctx).WherePri(req.Id).One()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询帖子失败")
+	}
+	if one.IsEmpty() {
+		return nil, errors.New("帖子不存在")
+	}
+
+	// 软删除帖子
+	_, err = dao.ForumPosts.Ctx(ctx).WherePri(req.Id).Delete()
+	if err != nil {
+		return nil, gerror.Wrap(err, "删除帖子失败")
+	}
+
+	return &v1.ForumPostsDeleteRes{}, nil
+}

Backend/internal/logic/containment/containment.go

@@ -0,0 +1,115 @@
+package containment
+
+import (
+	"context"
+	"github.com/gogf/gf/v2/frame/g"
+	v1 "leke/api/containment/v1"
+	"leke/internal/model/response"
+	"leke/internal/service"
+)
+
+type sContainment struct{}
+
+func New() *sContainment {
+	return &sContainment{}
+}
+
+func init() {
+	service.RegisterContainment(New())
+}
+
+func (s *sContainment) ContainmentRepoList(ctx context.Context, req *v1.ContainmentRepoListReq) (res *v1.ContainmentRepoListRes, err error) {
+	m := g.Model("containment_repo")
+	if req.AgentName != "" {
+		m.Where("agent_name", req.AgentName)
+	}
+	if req.AnomalyName != "" {
+		m.Where("anomaly_name", req.AnomalyName)
+	}
+	if req.RepoName != "" {
+		m.Where("repo_name", req.RepoName)
+	}
+
+	// 创建返回结果
+	res = &v1.ContainmentRepoListRes{
+		PageResult: response.PageResult{
+			Page:     req.Page,
+			PageSize: req.PageSize,
+		},
+	}
+
+	// 查询总数
+	res.Total, err = m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页查询
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询数据列表
+	err = m.Scan(&res.List)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+func (s *sContainment) ContainmentRepoView(ctx context.Context, req *v1.ContainmentRepoViewReq) (res *v1.ContainmentRepoViewRes, err error) {
+	// 创建返回结果
+	res = &v1.ContainmentRepoViewRes{}
+
+	// 从数据库获取指定ID的数据
+	err = g.Model("containment_repo").Where("id", req.Id).Scan(&res.ContainmentRepoInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+func (s *sContainment) ContainmentRepoUpdate(ctx context.Context, req *v1.ContainmentRepoUpdateReq) (res *v1.ContainmentRepoUpdateRes, err error) {
+	// 创建返回结果
+	res = &v1.ContainmentRepoUpdateRes{}
+
+	// 准备数据
+	data := g.Map{
+		"terminal_id":  req.TerminalId,
+		"anomaly_name": req.AnomalyName,
+		"agent_name":   req.AgentName,
+		"repo_name":    req.RepoName,
+	}
+
+	// 根据ID判断是更新还是新增
+	if req.Id > 0 {
+		// 更新操作
+		_, err = g.Model("containment_repo").Data(data).Where("id", req.Id).Update()
+		res.Id = req.Id
+	} else {
+		// 新增操作
+		result, err := g.Model("containment_repo").Data(data).Insert()
+		if err != nil {
+			return nil, err
+		}
+
+		// 获取插入记录的ID
+		id, err := result.LastInsertId()
+		if err != nil {
+			return nil, err
+		}
+		res.Id = uint64(id)
+	}
+
+	return res, err
+}
+func (s *sContainment) ContainmentRepoDelete(ctx context.Context, req *v1.ContainmentRepoDeleteReq) (res *v1.ContainmentRepoDeleteRes, err error) {
+	// 创建返回结果
+	res = &v1.ContainmentRepoDeleteRes{}
+
+	// 删除指定ID的记录
+	_, err = g.Model("containment_repo").Where("id", req.Id).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}

Backend/internal/logic/department/department.go

@@ -0,0 +1,143 @@
+package department
+
+import (
+	"context"
+	v1 "leke/api/department/v1"
+	"leke/internal/dao"
+	"leke/internal/model"
+	"leke/internal/service"
+)
+
+type sDepartment struct{}
+
+func New() *sDepartment {
+	return &sDepartment{}
+}
+
+func init() {
+	service.RegisterDepartment(New())
+}
+
+// DepartmentList 获取部门列表
+func (s *sDepartment) DepartmentList(ctx context.Context, req *v1.DepartmentListReq) (res *v1.DepartmentListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Department.Ctx(ctx)
+
+	// 根据分部名称查询
+	if req.BranchName != "" {
+		m = m.WhereLike(dao.Department.Columns().BranchName, "%"+req.BranchName+"%")
+	}
+
+	// 根据经理名称查询
+	if req.ManagerName != "" {
+		m = m.WhereLike(dao.Department.Columns().ManagerName, "%"+req.ManagerName+"%")
+	}
+
+	// 根据用户ID查询
+	if req.UserId != 0 {
+		m = m.Where(dao.Department.Columns().UserId, req.UserId)
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据
+	var departmentList []*v1.Department
+	err = m.Scan(&departmentList)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.DepartmentListRes{
+		List: departmentList,
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+// DepartmentView 获取部门详情
+func (s *sDepartment) DepartmentView(ctx context.Context, req *v1.DepartmentViewReq) (res *v1.DepartmentViewRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Department.Ctx(ctx)
+
+	// 根据ID查询
+	m = m.Where(dao.Department.Columns().Id, req.Id)
+
+	res = &v1.DepartmentViewRes{}
+	err = m.Scan(&res.Department)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+// DepartmentCreate 创建部门
+func (s *sDepartment) DepartmentCreate(ctx context.Context, req *v1.DepartmentCreateReq) (res *v1.DepartmentCreateRes, err error) {
+	// 准备数据
+	departmentData := model.Department{
+		UserId:        req.UserId,
+		BranchName:    req.BranchName,
+		TerminalCount: req.TerminalCount,
+		Weather:       req.Weather,
+		ManagerName:   req.ManagerName,
+		Location:      req.Location,
+	}
+
+	// 插入数据
+	result, err := dao.Department.Ctx(ctx).Data(departmentData).Insert()
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取插入的ID
+	lastInsertId, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.DepartmentCreateRes{
+		Id: uint64(lastInsertId),
+	}
+
+	return
+}
+
+// DepartmentUpdate 更新部门
+func (s *sDepartment) DepartmentUpdate(ctx context.Context, req *v1.DepartmentUpdateReq) (res *v1.DepartmentUpdateRes, err error) {
+	// 更新数据
+	_, err = dao.Department.Ctx(ctx).Data(req).Where(dao.Department.Columns().Id, req.Id).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.DepartmentUpdateRes{
+		Id: req.Id,
+	}
+
+	return
+}
+
+// DepartmentDelete 删除部门
+func (s *sDepartment) DepartmentDelete(ctx context.Context, req *v1.DepartmentDeleteReq) (res *v1.DepartmentDeleteRes, err error) {
+	// 根据ID删除
+	_, err = dao.Department.Ctx(ctx).Where(dao.Department.Columns().Id, req.Id).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.DepartmentDeleteRes{}
+
+	return
+}

Backend/internal/logic/fans/fans.go

@@ -0,0 +1,182 @@
+package fans
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gtime"
+	v1 "leke/api/user/v1"
+	"leke/internal/dao"
+	"leke/internal/service"
+)
+
+type sFans struct{}
+
+func New() *sFans {
+	return &sFans{}
+}
+
+func init() {
+	service.RegisterFans(New())
+}
+
+// FansList 获取粉丝列表
+//
+// 参数:
+//   - ctx context.Context: 上下文信息
+//   - req *v1.FansListReq: 粉丝列表请求参数
+//
+// 返回:
+//   - res *v1.FansListRes: 粉丝列表响应结果
+//   - err error: 错误信息
+func (s *sFans) FansList(ctx context.Context, req *v1.FansListReq) (res *v1.FansListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Fans.Ctx(ctx)
+
+	// 根据用户ID查询
+	m = m.Where(dao.Fans.Columns().UserId, req.UserId)
+
+	// 根据状态查询
+	if req.Status != 0 {
+		m = m.Where(dao.Fans.Columns().Status, req.Status)
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据
+	var fansList []*v1.FansListItem
+	err = m.Scan(&fansList)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.FansListRes{
+		List: fansList,
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+// FansView 获取粉丝详情
+//
+// 参数:
+//   - ctx context.Context: 上下文信息
+//   - req *v1.FansViewReq: 粉丝详情请求参数
+//
+// 返回:
+//   - res *v1.FansViewRes: 粉丝详情响应结果
+//   - err error: 错误信息
+func (s *sFans) FansView(ctx context.Context, req *v1.FansViewReq) (res *v1.FansViewRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Fans.Ctx(ctx)
+
+	// 根据ID查询
+	m = m.Where(dao.Fans.Columns().Id, req.Id)
+
+	res = &v1.FansViewRes{}
+	err = m.Scan(&res.FansListItem)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+// FansUpdate 更新粉丝信息
+//
+// 参数:
+//   - ctx context.Context: 上下文信息
+//   - req *v1.FansUpdateReq: 粉丝更新请求参数
+//
+// 返回:
+//   - res *v1.FansUpdateRes: 粉丝更新响应结果
+//   - err error: 错误信息
+func (s *sFans) FansUpdate(ctx context.Context, req *v1.FansUpdateReq) (res *v1.FansUpdateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Fans.Ctx(ctx)
+
+	// 更新粉丝信息
+	_, err = m.Data(req).Where(dao.Fans.Columns().Id, req.Id).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.FansUpdateRes{
+		Id: req.Id,
+	}
+
+	return
+}
+
+// FansDelete 删除粉丝关系
+//
+// 参数:
+//   - ctx context.Context: 上下文信息
+//   - req *v1.FansDeleteReq: 粉丝删除请求参数
+//
+// 返回:
+//   - res *v1.FansDeleteRes: 粉丝删除响应结果
+//   - err error: 错误信息
+func (s *sFans) FansDelete(ctx context.Context, req *v1.FansDeleteReq) (res *v1.FansDeleteRes, err error) {
+	// 根据ID删除粉丝关系
+	_, err = dao.Fans.Ctx(ctx).Where(dao.Fans.Columns().Id, req.Id).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.FansDeleteRes{}
+	return
+}
+
+// FansCreate 创建粉丝关系
+//
+// 参数:
+//   - ctx context.Context: 上下文信息
+//   - req *v1.FansCreateReq: 粉丝创建请求参数
+//
+// 返回:
+//   - res *v1.FansCreateRes: 粉丝创建响应结果
+//   - err error: 错误信息
+func (s *sFans) FansCreate(ctx context.Context, req *v1.FansCreateReq) (res *v1.FansCreateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Fans.Ctx(ctx)
+
+	// 准备数据
+	data := map[string]interface{}{
+		"user_id":    req.UserId,
+		"fan_id":     req.FanId,
+		"status":     1, // 默认状态为关注中
+		"remark":     req.Remark,
+		"created_at": gtime.Now(),
+		"updated_at": gtime.Now(),
+	}
+
+	// 插入数据
+	result, err := m.Data(data).Insert()
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取插入的ID
+	lastInsertId, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.FansCreateRes{
+		Id: uint64(lastInsertId),
+	}
+
+	return
+}

Backend/internal/logic/logic.go

@@ -0,0 +1,17 @@
+// ==========================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+package logic
+
+import (
+	_ "leke/internal/logic/ForumComments"
+	_ "leke/internal/logic/containment"
+	_ "leke/internal/logic/department"
+	_ "leke/internal/logic/fans"
+	_ "leke/internal/logic/login"
+	_ "leke/internal/logic/room"
+	_ "leke/internal/logic/subscribe"
+	_ "leke/internal/logic/trace"
+	_ "leke/internal/logic/user"
+)

Backend/internal/logic/login/login.go

@@ -0,0 +1,296 @@
+// Package login internal/logic/login/login.go
+package login
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	v1 "leke/api/login/v1"
+	"leke/internal/consts"
+	"leke/internal/dao"
+	"leke/internal/middleware"
+	"leke/internal/model"
+	"leke/internal/service"
+	"time"
+
+	"github.com/gogf/gf/v2/crypto/gmd5"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/glog"
+	"github.com/gogf/gf/v2/util/grand"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// 注意：名字改成 sLogin，首字母小写 s + 大写 Login
+type sLogin struct{}
+
+func New() *sLogin {
+	return &sLogin{}
+}
+
+// 关键！！在 init 里完成注册
+func init() {
+	service.RegisterLogin(New())
+}
+
+func (s *sLogin) Register(ctx context.Context, loginReq *v1.RegisterReq) (res *v1.RegisterRes, err error) {
+
+	// 判断参数是否正常 账户的长度要在5-10 密码要经过MD5加密
+	if len(loginReq.Account) < 5 || len(loginReq.Account) > 10 {
+		glog.Debugf(ctx, "账户长度校验失败，长度：%d", len(loginReq.Account))
+		return nil, errors.New("账户长度要在5-10之间")
+	}
+	if len(loginReq.Password) < 6 || len(loginReq.Password) > 32 {
+		glog.Debugf(ctx, "密码长度校验失败，长度：%d", len(loginReq.Password))
+		return nil, errors.New("密码长度要在6-32之间")
+	}
+
+	password, err := gmd5.Encrypt(loginReq.Password + consts.Salt)
+	if err != nil {
+		glog.Errorf(ctx, "密码加密失败：%v", err)
+		return nil, gerror.Wrap(err, "密码加密失败，请稍后重试！")
+	}
+
+	loginData := model.LoginField{
+		Account:  loginReq.Account,
+		Password: password,
+		Nickname: "特工007",
+	}
+
+	_, err = dao.Users.Ctx(ctx).Data(loginData).Insert()
+	if err != nil {
+		glog.Errorf(ctx, "插入账号到数据库失败：%v", err)
+		return nil, gerror.Wrap(err, "插入账号到数，据库失败，请稍后重试！")
+	}
+	return
+}
+
+func (s *sLogin) Login(ctx context.Context, loginReq *v1.LoginReq) (res *v1.LoginRes, err error) {
+
+	//校验参数
+	if len(loginReq.Account) < 5 || len(loginReq.Account) > 10 {
+		glog.Debugf(ctx, "账户长度校验失败，长度：%d", len(loginReq.Account))
+		return nil, errors.New("账户长度要在5-10之间")
+	}
+	if len(loginReq.Password) < 6 || len(loginReq.Password) > 32 {
+		glog.Debugf(ctx, "密码长度校验失败，长度：%d", len(loginReq.Password))
+		return nil, errors.New("密码长度要在6-32之间")
+	}
+
+	// 2. 先根据账号查数据库
+	var user model.LoginField
+	err = dao.Users.Ctx(ctx).Where("account", loginReq.Account).Scan(&user)
+	if err != nil {
+		glog.Errorf(ctx, "查询用户失败：%v", err)
+		return nil, gerror.Wrap(err, "登录失败，请稍后重试！")
+	}
+	if user.Account == "" {
+		// 没查到用户
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "账号或密码错误")
+	}
+
+	// 3. 使用"相同规则"加密用户输入的密码，并和 DB 中的密码对比
+	// 注意：这里的加密规则必须和 Register 时一致
+	encryptedInput, err := gmd5.Encrypt(loginReq.Password + consts.Salt)
+	if err != nil {
+		glog.Errorf(ctx, "密码加密失败：%v", err)
+		return nil, gerror.Wrap(err, "密码加密失败，请稍后重试！")
+	}
+	if user.Password != encryptedInput {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "账号或密码错误")
+	}
+
+	// 5. 种 Session（如果你确实需要 session）
+	if err := setSession(ctx, user.Account); err != nil {
+		glog.Errorf(ctx, "设置Session失败：%v", err)
+		return nil, gerror.Wrap(err, "设置登录状态失败，请稍后重试！")
+	}
+
+	//JWT 生成
+	// Create claims with user information
+	claims := &middleware.JWTClaims{
+		Username: loginReq.Account,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			NotBefore: jwt.NewNumericDate(time.Now()),
+		},
+	}
+
+	// 生成Token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signedToken, err := token.SignedString([]byte(middleware.JwtSecretKey))
+	if err != nil {
+		return nil, gerror.NewCode(gcode.CodeInternalError, "Failed to generate token")
+	}
+	res = &v1.LoginRes{
+		Token:   signedToken,
+		Account: user.Account,
+	}
+	return
+}
+
+// 通过邮箱注册
+func (s *sLogin) RegisterByEmail(ctx context.Context, req *v1.RegisterByEmailReq) (res *v1.RegisterByEmailRes, err error) {
+	// 先验证验证码
+	emailService := service.NewEmailService()
+	if !emailService.VerifyVerificationCode(req.Email, req.Code) {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "验证码错误或已过期")
+	}
+
+	// 检查邮箱是否已存在
+	count, err := dao.Users.Ctx(ctx).Where("email", req.Email).Count()
+	if err != nil {
+		return nil, gerror.Wrap(err, "查询用户失败")
+	}
+	if count > 0 {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "该邮箱已被注册")
+	}
+
+	// 生成随机账号和密码
+	account := fmt.Sprintf("user_%s", grand.S(6))
+	password := grand.S(10)
+
+	// 加密密码
+	encryptedPassword, err := gmd5.Encrypt(password + consts.Salt)
+	if err != nil {
+		return nil, gerror.Wrap(err, "密码加密失败")
+	}
+
+	// 创建用户
+	userData := model.LoginField{
+		Account:  account,
+		Password: encryptedPassword,
+		Nickname: "特工007",
+		Email:    req.Email,
+	}
+
+	_, err = dao.Users.Ctx(ctx).Data(userData).Insert()
+	if err != nil {
+		return nil, gerror.Wrap(err, "注册失败")
+	}
+
+	res = &v1.RegisterByEmailRes{
+		Email: req.Email,
+	}
+	return
+}
+
+// 通过邮箱登录
+func (s *sLogin) LoginByEmail(ctx context.Context, req *v1.LoginByEmailReq) (res *v1.LoginByEmailRes, err error) {
+	emailService := service.NewEmailService()
+
+	// 验证验证码
+	if !emailService.VerifyVerificationCode(req.Email, req.Code) {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "验证码错误或已过期")
+	}
+
+	// 根据邮箱查找用户
+	var user model.LoginField
+	err = dao.Users.Ctx(ctx).Where("email", req.Email).Scan(&user)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, gerror.WrapCode(gcode.CodeInternalError, err, "查询用户失败")
+	}
+
+	// 如果用户不存在，则创建新用户
+	if user.Email == "" {
+		account := fmt.Sprintf("user_%s", grand.S(6))
+		password := grand.S(10)
+
+		// 加密密码
+		encryptedPassword, err := gmd5.Encrypt(password + consts.Salt)
+		if err != nil {
+			return nil, gerror.Wrap(err, "密码加密失败")
+		}
+
+		// 创建用户
+		userData := model.LoginField{
+			Account:  account,
+			Password: encryptedPassword,
+			Nickname: "特工007",
+			Email:    req.Email,
+		}
+
+		_, err = dao.Users.Ctx(ctx).Data(userData).Insert()
+		if err != nil {
+			return nil, gerror.Wrap(err, "创建用户失败")
+		}
+
+		user = userData
+	}
+
+	// 设置session
+	if err := setSession(ctx, user.Account); err != nil {
+		glog.Errorf(ctx, "设置Session失败：%v", err)
+		return nil, gerror.Wrap(err, "设置登录状态失败，请稍后重试！")
+	}
+
+	// 生成JWT Token
+	claims := &middleware.JWTClaims{
+		Username: user.Account,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			NotBefore: jwt.NewNumericDate(time.Now()),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signedToken, err := token.SignedString([]byte(middleware.JwtSecretKey))
+	if err != nil {
+		return nil, gerror.NewCode(gcode.CodeInternalError, "Failed to generate token")
+	}
+
+	res = &v1.LoginByEmailRes{
+		Token: signedToken,
+		Email: req.Email,
+	}
+
+	return
+}
+
+// 发送验证码
+func (s *sLogin) SendVerificationCode(ctx context.Context, req *v1.SendVerificationCodeReq) (res *v1.SendVerificationCodeRes, err error) {
+	emailService := service.NewEmailService()
+
+	err = emailService.SendVerificationCode(ctx, req.Email)
+	if err != nil {
+		return nil, gerror.Wrap(err, "发送验证码失败")
+	}
+
+	res = &v1.SendVerificationCodeRes{
+		Success: true,
+	}
+
+	return
+}
+
+// 退出登录
+func (s *sLogin) Logout(ctx context.Context, req *v1.LogoutReq) (res *v1.LogoutRes, err error) {
+	// 从上下文里拿到当前请求
+	r := g.RequestFromCtx(ctx)
+	if r == nil {
+		return nil, gerror.New("无效的请求上下文")
+	}
+
+	// 1. 删除当前登录用到的 Session 信息
+	//    和 Login / setSession 里保持一致：都是用 "userAccount" 这个 key
+	if err = r.Session.Remove("userAccount"); err != nil {
+		glog.Errorf(ctx, "删除Session失败：%v", err)
+		return nil, gerror.Wrap(err, "退出登录失败，请稍后重试！")
+	}
+
+	// 如果你想彻底清空这个 Session（不只删一个字段），可以用：
+	// if err = r.Session.RemoveAll(); err != nil { ... }
+
+	// 2. 构造返回结果（一般是一个空结构就够了）
+	res = &v1.LogoutRes{}
+	return res, nil
+}
+
+// 给前端种session
+func setSession(ctx context.Context, account string) error {
+	return g.RequestFromCtx(ctx).Session.Set("userAccount", account)
+}

Backend/internal/logic/room/room.go

@@ -0,0 +1,252 @@
+package room
+
+import (
+	"context"
+	v1 "leke/api/room/v1"
+	"leke/internal/dao"
+	"leke/internal/model"
+	"leke/internal/model/entity"
+	"leke/internal/service"
+)
+
+type sRoom struct{}
+
+func New() *sRoom {
+	return &sRoom{}
+}
+
+func init() {
+	service.RegisterRoom(New())
+}
+
+func (s *sRoom) RoomList(ctx context.Context, req *v1.RoomListReq) (res *v1.RoomListRes, err error) {
+	// 构建查询条件
+	m := dao.TrpgRoom.Ctx(ctx)
+
+	if req.RoomCode != "" {
+		m = m.Where(dao.TrpgRoom.Columns().RoomCode, req.RoomCode)
+	}
+	if req.RoomName != "" {
+		m = m.Where(dao.TrpgRoom.Columns().RoomName, req.RoomName)
+	}
+	if req.HostId != 0 {
+		m = m.Where(dao.TrpgRoom.Columns().HostId, req.HostId)
+	}
+	if req.Status != 0 {
+		m = m.Where(dao.TrpgRoom.Columns().Status, req.Status)
+	}
+	if req.SystemName != "" {
+		m = m.Where(dao.TrpgRoom.Columns().SystemName, req.SystemName)
+	}
+
+	// 分页处理
+	if req.Page <= 0 {
+		req.Page = 1
+	}
+	if req.PageSize <= 0 {
+		req.PageSize = 10
+	}
+
+	// 查询总数
+	totalCount, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 查询数据列表
+	var rooms []*entity.TrpgRoom
+	err = m.Page(req.Page, req.PageSize).Scan(&rooms)
+	if err != nil {
+		return nil, err
+	}
+
+	// 组装返回结果
+	res = &v1.RoomListRes{
+		PageResult: req.PageResult,
+		Rooms:      make([]*model.RoomParams, len(rooms)),
+	}
+
+	// 转换数据格式
+	for i, room := range rooms {
+		res.Rooms[i] = &model.RoomParams{
+			Id:             room.Id,
+			RoomId:         room.RoomId,
+			RoomCode:       room.RoomCode,
+			RoomName:       room.RoomName,
+			HostId:         room.HostId,
+			HostNickname:   room.HostNickname,
+			MaxPlayers:     room.MaxPlayers,
+			CurrentPlayers: room.CurrentPlayers,
+			HasPassword:    room.HasPassword,
+			IsPrivate:      room.IsPrivate,
+			Status:         room.Status,
+			SystemName:     room.SystemName,
+			ScenarioName:   room.ScenarioName,
+			Description:    room.Description,
+			CreatedAt:      room.CreatedAt,
+			StartedAt:      room.StartedAt,
+			EndedAt:        room.EndedAt,
+			UpdatedAt:      room.UpdatedAt,
+		}
+	}
+
+	// 设置分页信息
+	res.PageResult.Total = totalCount
+	res.PageResult.Page = req.Page
+	res.PageResult.PageSize = req.PageSize
+
+	return res, nil
+}
+
+func (s *sRoom) RoomView(ctx context.Context, req *v1.RoomViewReq) (res *v1.RoomViewRes, err error) {
+	// 构建查询条件
+	m := dao.TrpgRoom.Ctx(ctx)
+
+	if req.Id != 0 {
+		m = m.Where(dao.TrpgRoom.Columns().Id, req.Id)
+	}
+	if req.RoomCode != "" {
+		m = m.Where(dao.TrpgRoom.Columns().RoomCode, req.RoomCode)
+	}
+
+	// 查询数据
+	var room *entity.TrpgRoom
+	err = m.Scan(&room)
+	if err != nil {
+		return nil, err
+	}
+	if room == nil {
+		return nil, nil
+	}
+
+	// 组装返回结果
+	res = &v1.RoomViewRes{
+		RoomView: model.RoomView{
+			Id:             room.Id,
+			RoomId:         room.RoomId,
+			RoomCode:       room.RoomCode,
+			RoomName:       room.RoomName,
+			HostId:         room.HostId,
+			HostNickname:   room.HostNickname,
+			MaxPlayers:     room.MaxPlayers,
+			CurrentPlayers: room.CurrentPlayers,
+			HasPassword:    room.HasPassword,
+			IsPrivate:      room.IsPrivate,
+			Status:         room.Status,
+			SystemName:     room.SystemName,
+			ScenarioName:   room.ScenarioName,
+			Description:    room.Description,
+			CreatedAt:      room.CreatedAt,
+			StartedAt:      room.StartedAt,
+			EndedAt:        room.EndedAt,
+		},
+	}
+
+	return res, nil
+}
+
+func (s *sRoom) RoomUpdate(ctx context.Context, req *v1.RoomUpdateReq) (res *v1.RoomUpdateRes, err error) {
+	// 根据房间号更新房间信息
+	data := model.RoomParams{
+		RoomName:       req.RoomName,
+		HostId:         req.HostId,
+		HostNickname:   req.HostNickname,
+		MaxPlayers:     req.MaxPlayers,
+		CurrentPlayers: req.CurrentPlayers,
+		HasPassword:    req.HasPassword,
+		IsPrivate:      req.IsPrivate,
+		Status:         req.Status,
+		SystemName:     req.SystemName,
+		ScenarioName:   req.ScenarioName,
+		Description:    req.Description,
+	}
+
+	_, err = dao.TrpgRoom.Ctx(ctx).Data(data).Where(dao.TrpgRoom.Columns().RoomCode, req.RoomCode).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取更新后的房间ID
+	var room *entity.TrpgRoom
+	err = dao.TrpgRoom.Ctx(ctx).Where(dao.TrpgRoom.Columns().RoomCode, req.RoomCode).Scan(&room)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoomUpdateRes{
+		Id: room.Id,
+	}
+
+	return res, nil
+}
+
+func (s *sRoom) RoomDelete(ctx context.Context, req *v1.RoomDeleteReq) (res *v1.RoomDeleteRes, err error) {
+	// 根据房间号删除房间
+	_, err = dao.TrpgRoom.Ctx(ctx).Where(dao.TrpgRoom.Columns().RoomCode, req.RoomCode).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoomDeleteRes{}
+	return res, nil
+}
+
+func (s *sRoom) RoomCreate(ctx context.Context, req *v1.RoomCreateReq) (res *v1.RoomCreateRes, err error) {
+	// 准备房间数据
+	room := entity.TrpgRoom{
+		RoomCode:     req.RoomCode,
+		RoomName:     req.RoomName,
+		HostId:       req.HostId,
+		MaxPlayers:   req.MaxPlayers,
+		HasPassword:  req.HasPassword,
+		IsPrivate:    req.IsPrivate,
+		SystemName:   req.SystemName,
+		ScenarioName: req.ScenarioName,
+		Description:  req.Description,
+		Status:       0, // 默认状态为未开始
+	}
+
+	// 插入数据库
+	result, err := dao.TrpgRoom.Ctx(ctx).Data(room).Insert()
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取插入的ID
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	// 返回结果
+	res = &v1.RoomCreateRes{
+		Id:       uint64(id),
+		RoomCode: req.RoomCode,
+	}
+
+	return res, nil
+}
+
+func (s *sRoom) RoomJoin(ctx context.Context, req *v1.RoomJoinReq) (res *v1.RoomJoinRes, err error) {
+	if req.RoomId == 0 {
+		return nil, nil
+	}
+
+	var room *entity.TrpgRoom
+	err = dao.TrpgRoom.Ctx(ctx).
+		Where(dao.TrpgRoom.Columns().Id, req.RoomId).
+		Scan(&room)
+	if err != nil {
+		return nil, err
+	}
+	if room == nil {
+		return nil, nil
+	}
+
+	res = &v1.RoomJoinRes{
+		Id:       room.Id,
+		RoomCode: room.RoomCode,
+	}
+
+	return res, nil
+}

Backend/internal/logic/subscribe/subscribe.go

@@ -0,0 +1,146 @@
+package subscribe
+
+import (
+	"context"
+	v1 "leke/api/user/v1"
+	"leke/internal/dao"
+	"leke/internal/service"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type sSubscribe struct{}
+
+func New() *sSubscribe {
+	return &sSubscribe{}
+}
+
+func init() {
+	service.RegisterSubscribe(New())
+}
+
+// SubscribeList 获取关注列表
+func (s *sSubscribe) SubscribeList(ctx context.Context, req *v1.SubscribeListReq) (res *v1.SubscribeListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Subscribe.Ctx(ctx)
+
+	// 根据用户ID查询
+	m = m.Where(dao.Subscribe.Columns().UserId, req.UserId)
+
+	// 根据状态查询
+	if req.Status != 0 {
+		m = m.Where(dao.Subscribe.Columns().Status, req.Status)
+	}
+
+	// 根据被关注用户ID查询
+	if req.FollowId != 0 {
+		m = m.Where(dao.Subscribe.Columns().FollowId, req.FollowId)
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据
+	var subscribeList []*v1.SubscribeListItem
+	err = m.Scan(&subscribeList)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.SubscribeListRes{
+		List: subscribeList,
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+// SubscribeView 获取关注详情
+func (s *sSubscribe) SubscribeView(ctx context.Context, req *v1.SubscribeViewReq) (res *v1.SubscribeViewRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Subscribe.Ctx(ctx)
+
+	// 根据ID查询
+	m = m.Where(dao.Subscribe.Columns().Id, req.Id)
+
+	res = &v1.SubscribeViewRes{}
+	err = m.Scan(&res.SubscribeListItem)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+// SubscribeUpdate 更新关注信息
+func (s *sSubscribe) SubscribeUpdate(ctx context.Context, req *v1.SubscribeUpdateReq) (res *v1.SubscribeUpdateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Subscribe.Ctx(ctx)
+
+	// 更新关注信息
+	_, err = m.Data(req).Where(dao.Subscribe.Columns().Id, req.Id).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.SubscribeUpdateRes{
+		Id: req.Id,
+	}
+
+	return
+}
+
+// SubscribeDelete 删除关注关系
+func (s *sSubscribe) SubscribeDelete(ctx context.Context, req *v1.SubscribeDeleteReq) (res *v1.SubscribeDeleteRes, err error) {
+	// 根据ID删除关注关系
+	_, err = dao.Subscribe.Ctx(ctx).Where(dao.Subscribe.Columns().Id, req.Id).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.SubscribeDeleteRes{}
+	return
+}
+
+// SubscribeCreate 创建关注关系
+func (s *sSubscribe) SubscribeCreate(ctx context.Context, req *v1.SubscribeCreateReq) (res *v1.SubscribeCreateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Subscribe.Ctx(ctx)
+
+	// 准备数据
+	data := map[string]interface{}{
+		"user_id":    req.UserId,
+		"follow_id":  req.FollowId,
+		"status":     1, // 默认状态为关注中
+		"remark":     req.Remark,
+		"created_at": gtime.Now(),
+		"updated_at": gtime.Now(),
+	}
+
+	// 插入数据
+	result, err := m.Data(data).Insert()
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取插入的ID
+	lastInsertId, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.SubscribeCreateRes{
+		Id: uint64(lastInsertId),
+	}
+
+	return
+}

Backend/internal/logic/trace/trace.go

@@ -0,0 +1,189 @@
+package trace
+
+import (
+	"context"
+	"fmt"
+	v1 "leke/api/user/v1"
+	"leke/internal/dao"
+	"leke/internal/model/entity"
+	"leke/internal/service"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type sTrace struct{}
+
+func NewTrace() *sTrace {
+	return &sTrace{}
+}
+
+func init() {
+	service.RegisterTrace(NewTrace())
+}
+
+// TraceList 获取轨迹列表
+func (s *sTrace) TraceList(ctx context.Context, req *v1.TraceListReq) (res *v1.TraceListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.RoleCards.Ctx(ctx)
+
+	// 根据角色ID查询
+	if req.RoleId != 0 {
+		m = m.Where(dao.RoleCards.Columns().Id, req.RoleId)
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据 (Scan 到实体)
+	var roleCards []*entity.RoleCards
+	err = m.Scan(&roleCards)
+	if err != nil {
+		return nil, err
+	}
+
+	// 转换为视图参数
+	traceList := make([]*v1.TraceViewParams, 0, len(roleCards))
+	for _, card := range roleCards {
+		traceList = append(traceList, &v1.TraceViewParams{
+			UserId:       card.UserId,
+			RoleId:       card.Id,
+			DepartmentId: card.DepartmentId,
+			RedTrace:     int(card.RedTrack),
+			YellowTrace:  int(card.YellowTrack),
+			BlueTrace:    int(card.BlueTrack),
+		})
+	}
+
+	res = &v1.TraceListRes{
+		List: traceList,
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+// TraceView 查看轨迹详情
+func (s *sTrace) TraceView(ctx context.Context, req *v1.TraceViewReq) (res *v1.TraceViewRes, err error) {
+	// 创建数据库查询模型
+	m := dao.RoleCards.Ctx(ctx)
+
+	// 根据角色ID查询
+	var card entity.RoleCards
+	err = m.Where(dao.RoleCards.Columns().Id, req.RoleId).Scan(&card)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.TraceViewRes{
+		TraceViewParams: v1.TraceViewParams{
+			UserId:       card.UserId,
+			RoleId:       card.Id,
+			DepartmentId: card.DepartmentId,
+			RedTrace:     int(card.RedTrack),
+			YellowTrace:  int(card.YellowTrack),
+			BlueTrace:    int(card.BlueTrack),
+		},
+	}
+
+	return
+}
+
+// TraceUpdate 更新轨迹信息 (增加)
+func (s *sTrace) TraceUpdate(ctx context.Context, req *v1.TraceUpdateReq) (res *v1.TraceUpdateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.RoleCards.Ctx(ctx)
+
+	// 准备更新数据
+	data := make(map[string]interface{})
+
+	// 只有当数值不为0时才进行更新操作
+	if req.RedTrace != 0 {
+		data[dao.RoleCards.Columns().RedTrack] = gdb.Raw(fmt.Sprintf("%s + %d", dao.RoleCards.Columns().RedTrack, req.RedTrace))
+	}
+
+	if req.YellowTrace != 0 {
+		data[dao.RoleCards.Columns().YellowTrack] = gdb.Raw(fmt.Sprintf("%s + %d", dao.RoleCards.Columns().YellowTrack, req.YellowTrace))
+	}
+
+	if req.BlueTrace != 0 {
+		data[dao.RoleCards.Columns().BlueTrack] = gdb.Raw(fmt.Sprintf("%s + %d", dao.RoleCards.Columns().BlueTrack, req.BlueTrace))
+	}
+
+	// 如果没有需要更新的字段，直接返回
+	if len(data) == 0 {
+		return &v1.TraceUpdateRes{
+			RoleId:      req.RoleId,
+			RedTrace:    req.RedTrace,
+			YellowTrace: req.YellowTrace,
+			BlueTrace:   req.BlueTrace,
+		}, nil
+	}
+
+	// 添加更新时间
+	data[dao.RoleCards.Columns().UpdatedAt] = gtime.Now()
+
+	// 执行更新
+	_, err = m.Data(data).Where(dao.RoleCards.Columns().Id, req.RoleId).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.TraceUpdateRes{
+		RoleId:      req.RoleId,
+		RedTrace:    req.RedTrace,
+		YellowTrace: req.YellowTrace,
+		BlueTrace:   req.BlueTrace,
+	}
+
+	return
+}
+
+// TraceReduce 减少轨迹数值
+func (s *sTrace) TraceReduce(ctx context.Context, req *v1.TraceReduceReq) (res *v1.TraceReduceRes, err error) {
+	// 创建数据库查询模型
+	m := dao.RoleCards.Ctx(ctx)
+
+	// 准备更新数据
+	data := make(map[string]interface{})
+
+	// 只有当数值不为0时才进行减少操作
+	if req.RedTrace != 0 {
+		data[dao.RoleCards.Columns().RedTrack] = gdb.Raw(fmt.Sprintf("GREATEST(0, %s - %d)", dao.RoleCards.Columns().RedTrack, req.RedTrace))
+	}
+
+	if req.YellowTrace != 0 {
+		data[dao.RoleCards.Columns().YellowTrack] = gdb.Raw(fmt.Sprintf("GREATEST(0, %s - %d)", dao.RoleCards.Columns().YellowTrack, req.YellowTrace))
+	}
+
+	if req.BlueTrace != 0 {
+		data[dao.RoleCards.Columns().BlueTrack] = gdb.Raw(fmt.Sprintf("GREATEST(0, %s - %d)", dao.RoleCards.Columns().BlueTrack, req.BlueTrace))
+	}
+
+	// 如果没有需要更新的字段，直接返回
+	if len(data) == 0 {
+		return &v1.TraceReduceRes{}, nil
+	}
+
+	// 添加更新时间
+	data[dao.RoleCards.Columns().UpdatedAt] = gtime.Now()
+
+	// 执行更新
+	_, err = m.Data(data).Where(dao.RoleCards.Columns().Id, req.RoleId).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.TraceReduceRes{}
+	return
+}

Backend/internal/logic/user/user.go

@@ -0,0 +1,347 @@
+package user
+
+import (
+	"context"
+	v1 "leke/api/user/v1"
+	"leke/internal/dao"
+	"leke/internal/model"
+	"leke/internal/model/entity"
+	"leke/internal/service"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+type sUser struct{}
+
+func New() *sUser {
+	return &sUser{}
+}
+
+func init() {
+	service.RegisterUser(New())
+}
+
+func (s *sUser) UserList(ctx context.Context, req *v1.UserListReq) (res *v1.UserListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Users.Ctx(ctx)
+
+	// 按照账号搜索
+	if req.Account != "" {
+		m = m.WhereLike(dao.Users.Columns().Account, "%"+req.Account+"%")
+	}
+
+	// 按照昵称搜索
+	if req.Nickname != "" {
+		m = m.WhereLike(dao.Users.Columns().Nickname, "%"+req.Nickname+"%")
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据
+	var users []*model.User
+	err = m.Scan(&users)
+	if err != nil {
+		return nil, err
+	}
+
+	// 转换为视图参数
+	userViewList := make([]*model.UserViewParams, 0, len(users))
+	for _, user := range users {
+		userViewList = append(userViewList, &model.UserViewParams{
+			Id:         user.Id,
+			Account:    user.Account,
+			Nickname:   user.Nickname,
+			Gender:     user.Gender,
+			BirthDate:  user.BirthDate,
+			UserType:   user.UserType,
+			VipStartAt: user.VipStartAt,
+			VipEndAt:   user.VipEndAt,
+			CreatedAt:  user.CreatedAt,
+		})
+	}
+
+	res = &v1.UserListRes{
+		Users: userViewList,
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+func (s *sUser) UserView(ctx context.Context, req *v1.UserViewReq) (res *v1.UserViewRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Users.Ctx(ctx)
+
+	// 根据账号查询
+	if req.Account != "" {
+		m = m.Where(dao.Users.Columns().Account, req.Account)
+	}
+
+	res = &v1.UserViewRes{}
+	err = m.Scan(&res.UserViewParams)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+func (s *sUser) UserUpdate(ctx context.Context, req *v1.UserUpdateReq) (res *v1.UserUpdateRes, err error) {
+	// 创建数据库查询模型
+	m := dao.Users.Ctx(ctx)
+
+	// 根据账号更新用户信息
+	_, err = m.Data(req).Where(dao.Users.Columns().Account, req.Account).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.UserUpdateRes{}
+	// 获取更新后的用户信息
+	err = m.Where(dao.Users.Columns().Account, req.Account).Scan(&res)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+func (s *sUser) UserDelete(ctx context.Context, req *v1.UserDeleteReq) (res *v1.UserDeleteRes, err error) {
+	// 根据账号删除用户
+	_, err = dao.Users.Ctx(ctx).Where(dao.Users.Columns().Account, req.Account).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.UserDeleteRes{}
+	return
+}
+
+// RoleCreate 创建角色
+func (s *sUser) RoleCreate(ctx context.Context, req *v1.RoleCreateReq) (res *v1.RoleCreateRes, err error) {
+	// 插入角色数据
+	data := &entity.RoleCards{
+		UserId:       req.UserId,
+		DepartmentId: req.DepartmentId,
+		AgentName:    req.AgentName,
+		CodeName:     req.CodeName,
+		Gender:       req.Gender,
+		ArcAbnormal:  req.ArcAbnormal,
+		ArcReality:   req.ArcReality,
+		ArcPosition:  req.ArcPosition,
+	}
+
+	id, err := dao.RoleCards.Ctx(ctx).Data(data).InsertAndGetId()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoleCreateRes{
+		Id: uint64(id),
+	}
+	return
+}
+
+// RoleUpdate 更新角色
+func (s *sUser) RoleUpdate(ctx context.Context, req *v1.RoleUpdateReq) (res *v1.RoleUpdateRes, err error) {
+	// 更新角色数据
+	data := &entity.RoleCards{
+		DepartmentId: req.DepartmentId,
+		AgentName:    req.AgentName,
+		CodeName:     req.CodeName,
+		Gender:       req.Gender,
+		ArcAbnormal:  req.ArcAbnormal,
+		ArcReality:   req.ArcReality,
+		ArcPosition:  req.ArcPosition,
+		Commendation: req.Commendation,
+		Reprimand:    req.Reprimand,
+		BlueTrack:    req.BlueTrack,
+		YellowTrack:  req.YellowTrack,
+		RedTrack:     req.RedTrack,
+	}
+
+	_, err = dao.RoleCards.Ctx(ctx).Data(data).Where(dao.RoleCards.Columns().Id, req.Id).Update()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoleUpdateRes{
+		Id: req.Id,
+	}
+	return
+}
+
+// RoleView 查看角色详情
+func (s *sUser) RoleView(ctx context.Context, req *v1.RoleViewReq) (res *v1.RoleViewRes, err error) {
+	// 查询角色详情
+	var role entity.RoleCards
+	err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.Id).Scan(&role)
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoleViewRes{
+		RoleViewParams: v1.RoleViewParams{
+			Id:             role.Id,
+			UserId:         role.UserId,
+			DepartmentId:   role.DepartmentId,
+			Commendation:   role.Commendation,
+			Reprimand:      role.Reprimand,
+			BlueTrack:      role.BlueTrack,
+			YellowTrack:    role.YellowTrack,
+			RedTrack:       role.RedTrack,
+			ArcAbnormal:    role.ArcAbnormal,
+			ArcReality:     role.ArcReality,
+			ArcPosition:    role.ArcPosition,
+			AgentName:      role.AgentName,
+			CodeName:       role.CodeName,
+			Gender:         role.Gender,
+			QaMeticulous:   role.QaMeticulous,
+			QaDeception:    role.QaDeception,
+			QaVigor:        role.QaVigor,
+			QaEmpathy:      role.QaEmpathy,
+			QaInitiative:   role.QaInitiative,
+			QaResilience:   role.QaResilience,
+			QaPresence:     role.QaPresence,
+			QaProfessional: role.QaProfessional,
+			QaDiscretion:   role.QaDiscretion,
+		},
+	}
+	return
+}
+
+// RoleList 获取角色列表
+func (s *sUser) RoleList(ctx context.Context, req *v1.RoleListReq) (res *v1.RoleListRes, err error) {
+	// 创建数据库查询模型
+	m := dao.RoleCards.Ctx(ctx)
+
+	// 根据用户ID查询
+	if req.UserId != 0 {
+		m = m.Where(dao.RoleCards.Columns().UserId, req.UserId)
+	}
+
+	// 根据部门ID查询
+	if req.DepartmentId != 0 {
+		m = m.Where(dao.RoleCards.Columns().DepartmentId, req.DepartmentId)
+	}
+
+	// 查询总数
+	total, err := m.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	// 分页处理
+	m = m.Page(req.Page, req.PageSize)
+
+	// 查询列表数据
+	var roles []*entity.RoleCards
+	err = m.Scan(&roles)
+	if err != nil {
+		return nil, err
+	}
+
+	// 转换为视图参数
+	roleViewList := make([]*v1.RoleViewParams, 0, len(roles))
+	for _, role := range roles {
+		roleViewList = append(roleViewList, &v1.RoleViewParams{
+			Id:             role.Id,
+			UserId:         role.UserId,
+			DepartmentId:   role.DepartmentId,
+			Commendation:   role.Commendation,
+			Reprimand:      role.Reprimand,
+			BlueTrack:      role.BlueTrack,
+			YellowTrack:    role.YellowTrack,
+			RedTrack:       role.RedTrack,
+			ArcAbnormal:    role.ArcAbnormal,
+			ArcReality:     role.ArcReality,
+			ArcPosition:    role.ArcPosition,
+			AgentName:      role.AgentName,
+			CodeName:       role.CodeName,
+			Gender:         role.Gender,
+			QaMeticulous:   role.QaMeticulous,
+			QaDeception:    role.QaDeception,
+			QaVigor:        role.QaVigor,
+			QaEmpathy:      role.QaEmpathy,
+			QaInitiative:   role.QaInitiative,
+			QaResilience:   role.QaResilience,
+			QaPresence:     role.QaPresence,
+			QaProfessional: role.QaProfessional,
+			QaDiscretion:   role.QaDiscretion,
+		})
+	}
+
+	res = &v1.RoleListRes{
+		List:       roleViewList,
+		PageResult: req.PageResult, // 设置分页信息
+	}
+
+	// 设置分页信息
+	req.PageResult.Total = int(total)
+	req.PageResult.Page = req.Page
+	req.PageResult.PageSize = req.PageSize
+
+	return
+}
+
+// RoleDelete 删除角色
+func (s *sUser) RoleDelete(ctx context.Context, req *v1.RoleDeleteReq) (res *v1.RoleDeleteRes, err error) {
+	// 根据ID删除角色
+	_, err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.Id).Delete()
+	if err != nil {
+		return nil, err
+	}
+
+	res = &v1.RoleDeleteRes{
+		Id: req.Id,
+	}
+	return
+}
+
+// RolePermissionCheck 权限查询
+func (s *sUser) RolePermissionCheck(ctx context.Context, req *v1.RolePermissionCheckReq) (res *v1.RolePermissionCheckRes, err error) {
+	// 查询角色信息
+	var role entity.RoleCards
+	err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.RoleId).Scan(&role)
+	if err != nil {
+		return nil, err
+	}
+
+	// 根据轨道类型获取对应的轨道值
+	var trackValue uint
+	switch req.TrackType {
+	case "blue":
+		trackValue = role.BlueTrack
+	case "yellow":
+		trackValue = role.YellowTrack
+	case "red":
+		trackValue = role.RedTrack
+	default:
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "无效的轨道类型")
+	}
+
+	// 判断权限：如果角色的轨道值 >= 文件需要的值，则权限验证通过
+	if trackValue >= req.FileValue {
+		// 权限验证通过
+		res = &v1.RolePermissionCheckRes{
+			Code: 333,
+			Mes:  "权限验证通过",
+		}
+		return
+	}
+
+	// 权限不足，返回错误
+	return nil, gerror.New("权限不足")
+}