feat: 统一sql命名、函数命名

internal/service/admin/api.go

@@ -0,0 +1,163 @@
+package admin
+
+import (
+	"context"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/enum"
+	"server/internal/model/request"
+	"server/internal/pkg/cache"
+	"server/internal/pkg/cache/cachekey"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type ApiService struct {
+	store *db.Store
+	cache *cache.Caches
+}
+
+func NewApiService(store *db.Store, cache *cache.Caches) *ApiService {
+	return &ApiService{
+		store: store,
+		cache: cache,
+	}
+}
+
+func (s *ApiService) List(ctx context.Context, p request.SearchApiParams) (*common.PageResult[sqlc.SysApi], error) {
+	params := sqlc.ListApisParams{
+		Limit:     p.PageSize,
+		Offset:    (p.Page - 1) * p.PageSize,
+		Name:      p.Name,
+		GroupName: p.GroupName,
+		Method:    p.Method,
+	}
+
+	total, err := s.store.CountApis(ctx, sqlc.CountApisParams{
+		Name:      p.Name,
+		GroupName: p.GroupName,
+		Method:    p.Method,
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListApis(ctx, params)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.SysApi]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *ApiService) ListAll(ctx context.Context) ([]sqlc.SysApi, error) {
+	return s.store.ListAllApis(ctx)
+}
+
+func (s *ApiService) ListApiGroups(ctx context.Context) ([]string, error) {
+	return s.store.ListApiGroups(ctx)
+}
+
+func (s *ApiService) Create(ctx context.Context, req request.CreateApiRequest) error {
+
+	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		api := sqlc.CreateApiParams{
+			Name:      req.Name,
+			GroupName: req.GroupName,
+			Method:    req.Method,
+			Path:      req.Path,
+			Sort:      req.Sort,
+		}
+
+		// 创建权限
+		permissionId, err := q.CreatePermission(ctx, sqlc.CreatePermissionParams{
+			Type: int16(enum.PermissionTypeApi),
+		})
+
+		if err != nil {
+			return err
+		}
+
+		// 创建api
+		apiId, err := q.CreateApi(ctx, api)
+		if err != nil {
+			return dberr.MapUniqueViolation(err, dberr.SysApisMethodPathKey, errs.ErrApiMethodPathAlreadyExists)
+		}
+
+		// 关联权限
+		if err = q.CreateApiPermission(ctx, sqlc.CreateApiPermissionParams{
+			ApiID:        apiId,
+			PermissionID: permissionId,
+		}); err != nil {
+			return err
+		}
+
+		return nil
+
+	})
+}
+
+func (s *ApiService) Update(ctx context.Context, id int32, req request.UpdateApiRequest) error {
+	api := sqlc.UpdateApiParams{
+		ID:        id,
+		Name:      req.Name,
+		GroupName: req.GroupName,
+		Method:    req.Method,
+		Path:      req.Path,
+		Sort:      req.Sort,
+	}
+
+	rows, err := s.store.UpdateApi(ctx, api)
+	if err = dberr.MapRowsAffected(rows, err, errs.ErrApiNotFound); err != nil {
+		return dberr.MapUniqueViolation(err, dberr.SysApisMethodPathKey, errs.ErrApiMethodPathAlreadyExists)
+	}
+
+	// 如果更新成功 则清理缓存
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserApiPermissionsPattern)
+
+	return nil
+}
+
+func (s *ApiService) Delete(ctx context.Context, id int32) error {
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 1. 找出权限id
+		permissionID, err := q.GetPermissionIDBySysApiID(ctx, id)
+		if err != nil {
+			return dberr.MapNoRows(err, errs.ErrApiNotFound)
+		}
+		// 2. 根据权限id,删除角色权限关联数据
+		if err = q.DeleteRolePermissionByPermissionID(ctx, permissionID); err != nil {
+			return err
+		}
+		// 3. 根据api id 删除sys_api_permission关联表数据
+		if err = q.DeleteApiPermission(ctx, id); err != nil {
+			return err
+		}
+		// 4. 根据权限id,删除权限表权限数据
+		if err = q.DeletePermission(ctx, permissionID); err != nil {
+			return err
+		}
+		// 5. 删除api
+		rows, err := q.DeleteApi(ctx, id)
+		if err = dberr.MapRowsAffected(rows, err, errs.ErrApiNotFound); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存 事务执行成功后才清理
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserApiPermissionsPattern)
+
+	return nil
+}

internal/service/admin/auth.go

@@ -0,0 +1,180 @@
+package admin
+
+import (
+	"context"
+	"server/internal/config"
+	"server/internal/db"
+	"server/internal/middleware"
+	"server/internal/model/auth"
+	"server/internal/model/request"
+	"server/internal/model/response"
+	"server/internal/pkg/cache"
+	"server/internal/pkg/cache/cachekey"
+	"server/internal/pkg/errs"
+	"time"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+type AuthService struct {
+	jwt   *middleware.JWTMiddleware
+	cache *cache.Caches
+	store *db.Store
+	cfg   *config.Config
+}
+
+func NewAuthService(jwt *middleware.JWTMiddleware, cache *cache.Caches, store *db.Store, cfg *config.Config) *AuthService {
+	return &AuthService{
+		jwt:   jwt,
+		cache: cache,
+		store: store,
+		cfg:   cfg,
+	}
+}
+
+// generatePasswordHash 生成密码哈希
+func generatePasswordHash(password string) (string, error) {
+	hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return "", err
+	}
+	return string(hashed), nil
+}
+
+// comparePasswordHash 比较密码哈希
+func comparePasswordHash(passwordHash, inputPassword string) error {
+	return bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(inputPassword))
+}
+
+func (s *AuthService) Login(ctx context.Context, req request.LoginRequest) (*response.LoginResponse, error) {
+	user, err := s.store.GetUserByAccount(ctx, req.Account)
+
+	if err != nil {
+		return nil, errs.ErrInvalidCredentials
+	}
+
+	// 此处判断如果用户id不为1 且状态为0表示用户已被禁用
+	if user.ID != 1 && user.Status == 0 {
+		return nil, errs.ErrUserDisabled
+	}
+
+	if err = comparePasswordHash(user.PasswordHash, req.Password); err != nil {
+		return nil, errs.ErrInvalidCredentials
+	}
+
+	accessToken, accessTokenExp, err := s.jwt.GenerateAccessToken(user.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	refreshToken, err := s.jwt.GenerateRefreshToken()
+	if err != nil {
+		return nil, err
+	}
+
+	// 哈希
+	hash := s.jwt.HashRefreshToken(refreshToken)
+
+	now := time.Now()
+
+	refreshTokenExp := now.Add(s.cfg.JWTConfig.RefreshExpire)
+	refreshTokenRecord := &auth.RefreshTokenRecord{
+		UserID:    user.ID,
+		CreatedAt: now,
+		ExpiresAt: refreshTokenExp,
+	}
+
+	// 存入redis
+	err = s.cache.SetJSON(ctx, cachekey.AuthRefresh(hash), refreshTokenRecord, s.cfg.JWTConfig.RefreshExpire)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// 反向索引
+	err = s.cache.SAdd(ctx, cachekey.AuthRefreshUser(user.ID), hash)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// 给反向索引设置过期时间 这个过期时间需要覆盖最后一个token的过期时间 所以用最新的就行了
+	if err = s.cache.Expire(ctx, cachekey.AuthRefreshUser(user.ID), s.cfg.JWTConfig.RefreshExpire); err != nil {
+		return nil, err
+	}
+
+	return &response.LoginResponse{
+		AccessToken:     accessToken,
+		AccessTokenExp:  accessTokenExp,
+		RefreshToken:    refreshToken,
+		RefreshTokenExp: refreshTokenExp,
+	}, nil
+}
+
+func (s *AuthService) Logout(ctx context.Context, refreshToken string) error {
+	hash := s.jwt.HashRefreshToken(refreshToken)
+
+	// 获取用户信息
+	user, ok, err := cache.GetJSON[auth.RefreshTokenRecord](ctx, s.cache, cachekey.AuthRefresh(hash))
+	if err != nil {
+		return err
+	}
+
+	if ok {
+		// 清理反向索引
+		if err = s.cache.SRem(ctx, cachekey.AuthRefreshUser(user.UserID), hash); err != nil {
+			return err
+		}
+	}
+
+	// 清理当前登录的token
+	if err = s.cache.Del(ctx, cachekey.AuthRefresh(hash)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *AuthService) GetActiveSysUser(ctx context.Context, id int32) error {
+	var err error
+
+	_, err = s.store.GetActiveUserByID(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *AuthService) RefreshToken(ctx context.Context, refreshToken string) (*response.LoginResponse, error) {
+	// 获取哈希
+	hash := s.jwt.HashRefreshToken(refreshToken)
+	// 从redis中获取数据
+	record, ok, err := cache.GetJSON[auth.RefreshTokenRecord](ctx, s.cache, cachekey.AuthRefresh(hash))
+	if err != nil {
+		return nil, errs.ErrInvalidRefreshToken
+	}
+
+	if !ok {
+		return nil, errs.ErrInvalidRefreshToken
+	}
+
+	// 如果不是超级用户 需要判断用户状态
+	if record.UserID != 1 {
+		err = s.GetActiveSysUser(ctx, record.UserID)
+		if err != nil {
+			return nil, errs.ErrInvalidRefreshToken
+		}
+	}
+
+	// 获取新的access token
+	accessToken, accessTokenExp, err := s.jwt.GenerateAccessToken(record.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response.LoginResponse{
+		AccessToken:    accessToken,
+		AccessTokenExp: accessTokenExp,
+	}, nil
+}

internal/service/admin/category.go

@@ -0,0 +1,87 @@
+package admin
+
+import (
+	"context"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type CategoryService struct {
+	store *db.Store
+}
+
+func NewCategoryService(store *db.Store) *CategoryService {
+	return &CategoryService{
+		store: store,
+	}
+}
+
+func (s *CategoryService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.Category], error) {
+	params := sqlc.ListCategoriesParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountCategories(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListCategories(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.Category]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *CategoryService) ListAll(ctx context.Context) ([]sqlc.Category, error) {
+	return s.store.ListAllCategories(ctx)
+}
+
+func (s *CategoryService) Create(ctx context.Context, req request.CreateCategoryRequest) error {
+	params := sqlc.CreateCategoryParams{
+		Name: req.Name,
+		Code: req.Code,
+		Sort: req.Sort,
+	}
+
+	err := s.store.CreateCategory(ctx, params)
+	return dberr.MapUniqueViolation(err, dberr.CategoryCodeKey, errs.ErrCategoryCodeAlreadyExists)
+}
+
+func (s *CategoryService) Update(ctx context.Context, id int32, req request.UpdateCategoryRequest) error {
+	params := sqlc.UpdateCategoryParams{
+		ID:   id,
+		Name: req.Name,
+		Code: req.Code,
+		Sort: req.Sort,
+	}
+	rows, err := s.store.UpdateCategory(ctx, params)
+	// 先判断数据条目是否存在
+	if err = dberr.MapRowsAffected(rows, err, errs.ErrCategoryNotFound); err != nil {
+		// 再判断code是否重复
+		return dberr.MapUniqueViolation(err, dberr.CategoryCodeKey, errs.ErrCategoryCodeAlreadyExists)
+	}
+
+	return nil
+}
+
+func (s *CategoryService) Delete(ctx context.Context, id int32) error {
+	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		err := q.DeletePostCategoryByCategoryID(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		rows, err := q.DeleteCategory(ctx, id)
+		return dberr.MapRowsAffected(rows, err, errs.ErrCategoryNotFound)
+	})
+}

internal/service/admin/file.go

@@ -0,0 +1,120 @@
+package admin
+
+import (
+	"context"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/pkg/httputil"
+
+	gonanoid "github.com/matoous/go-nanoid/v2"
+)
+
+type FileService struct {
+	store *db.Store
+}
+
+func NewFileService(store *db.Store) *FileService {
+	return &FileService{
+		store: store,
+	}
+}
+
+// MakeSavedDir 创建目录并返回
+func MakeSavedDir(folder string) (string, error) {
+	rootDir, err := os.Getwd()
+
+	if err != nil {
+		return "", err
+	}
+
+	uploadDir := filepath.Join(rootDir, "uploads", folder)
+
+	if err = os.MkdirAll(uploadDir, 0755); err != nil {
+		return "", err
+	}
+
+	return uploadDir, nil
+}
+
+func (s *FileService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.File], error) {
+	params := sqlc.ListFilesParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountFiles(ctx)
+
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListFiles(ctx, params)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.File]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *FileService) Upload(ctx context.Context, folder string, file *multipart.FileHeader) (*sqlc.CreateFileRow, error) {
+	// 生成文件名
+	fileID, err := gonanoid.New()
+	if err != nil {
+		return nil, err
+	}
+
+	savedDir, err := MakeSavedDir(folder)
+	if err != nil {
+		return nil, err
+	}
+
+	fileExt := filepath.Ext(file.Filename)
+	filename := fileID + fileExt
+	filePath := filepath.Join(folder, filename)
+	// 用于保存文件
+	savedPath := filepath.Join(savedDir, filename)
+
+	// 打开上传的文件
+	src, err := file.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer src.Close()
+
+	// 创建目标文件
+	dst, err := os.Create(savedPath)
+	if err != nil {
+		return nil, err
+	}
+	defer dst.Close()
+
+	// 复制文件内容
+	if _, err = dst.ReadFrom(src); err != nil {
+		return nil, err
+	}
+
+	params := sqlc.CreateFileParams{
+		FileName:     filename,
+		FilePath:     filePath,
+		FileUrl:      httputil.BuildFileUrl(&filePath),
+		OriginalName: file.Filename,
+		FolderName:   folder,
+		MimeType:     file.Header.Get("Content-Type"),
+		FileSize:     file.Size,
+	}
+
+	result, err := s.store.CreateFile(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

internal/service/admin/menu.go

@@ -0,0 +1,197 @@
+package admin
+
+import (
+	"context"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/enum"
+	"server/internal/model/request"
+	"server/internal/pkg/cache"
+	"server/internal/pkg/cache/cachekey"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type MenuService struct {
+	store *db.Store
+	cache *cache.Caches
+}
+
+func NewMenuService(store *db.Store, cache *cache.Caches) *MenuService {
+	return &MenuService{
+		store: store,
+		cache: cache,
+	}
+}
+
+func (s *MenuService) Create(ctx context.Context, req request.CreateMenuRequest) error {
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		menu := sqlc.CreateMenuParams{
+			Name:      req.Name,
+			Path:      req.Path,
+			Component: req.Component,
+			Type:      *req.Type,
+			Status:    *req.Status,
+			Hidden:    req.Hidden,
+			Sort:      req.Sort,
+			Icon:      req.Icon,
+			ParentID:  req.ParentID,
+		}
+
+		// 先创建权限
+		permissionId, err := q.CreatePermission(ctx, sqlc.CreatePermissionParams{
+			Type: int16(enum.PermissionTypeMenu),
+			Code: &req.PermissionCode,
+		})
+
+		// code重复性校验
+		if err != nil {
+			return dberr.MapUniqueViolation(err, dberr.SysPermissionsCodeKey, errs.ErrPermissionCodeAlreadyExists)
+		}
+
+		// 创建菜单
+		menuId, err := q.CreateMenu(ctx, menu)
+		if err != nil {
+			return dberr.MapUniqueViolation(err, dberr.SysMenusPathUniqueIdx, errs.ErrMenusPathUniqueIdx)
+		}
+
+		// 绑定权限
+		if err = q.CreateMenuPermission(ctx, sqlc.CreateMenuPermissionParams{
+			MenuID:       menuId,
+			PermissionID: permissionId,
+		}); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *MenuService) Update(ctx context.Context, id int32, req request.UpdateMenuRequest) error {
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 构造 menu 参数
+		menu := sqlc.UpdateMenuParams{
+			ID:        id,
+			Name:      req.Name,
+			Path:      req.Path,
+			Component: req.Component,
+			Hidden:    req.Hidden,
+			Sort:      req.Sort,
+			Type:      req.Type,
+			Status:    req.Status,
+		}
+
+		if req.Icon.Set {
+			menu.UpdateIcon = true
+			if req.Icon.Valid {
+				menu.Icon = &req.Icon.Value
+			}
+		}
+
+		if req.ParentID.Set {
+			menu.UpdateParentID = true
+			if req.ParentID.Valid {
+				menu.ParentID = &req.ParentID.Value
+			}
+		}
+
+		// 执行更新
+		rows, err := q.UpdateMenu(ctx, menu)
+
+		// 先判断数据是否存在 在判断path是否重复
+		if err = dberr.MapRowsAffected(rows, err, errs.ErrMenuNotFound); err != nil {
+			return dberr.MapUniqueViolation(err, dberr.SysMenusPathUniqueIdx, errs.ErrMenusPathUniqueIdx)
+		}
+
+		permission := sqlc.UpdateMenuPermissionCodeParams{
+			MenuID: id,
+			Code:   req.PermissionCode,
+		}
+
+		if err = q.UpdateMenuPermissionCode(ctx, permission); err != nil {
+			return dberr.MapUniqueViolation(err, dberr.SysPermissionsCodeKey, errs.ErrPermissionCodeAlreadyExists)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserInfoPattern)
+
+	return nil
+}
+
+func (s *MenuService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.ListMenusRow], error) {
+	params := sqlc.ListMenusParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountMenus(ctx)
+
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListMenus(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.ListMenusRow]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *MenuService) ListAll(ctx context.Context) ([]sqlc.ListAllMenusRow, error) {
+	return s.store.ListAllMenus(ctx)
+}
+
+func (s *MenuService) Delete(ctx context.Context, id int32) error {
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 1. 根据菜单id, 找出对应的权限id
+		permissionID, err := q.GetPermissionIDBySysMenuID(ctx, id)
+		if err != nil {
+			return dberr.MapNoRows(err, errs.ErrMenuNotFound)
+		}
+		// 2. 根据权限id 删除角色权限关联
+		if err = q.DeleteRolePermissionByPermissionID(ctx, permissionID); err != nil {
+			return err
+		}
+		// 3. 根据菜单id 删除sys_menu_permission关联表数据
+		if err = q.DeleteMenuPermission(ctx, id); err != nil {
+			return err
+		}
+		// 4. 根据权限id删除权限表数据
+		if err = q.DeletePermission(ctx, permissionID); err != nil {
+			return err
+		}
+		// 5. 删除菜单
+		rows, err := q.DeleteMenu(ctx, id)
+		if err = dberr.MapRowsAffected(rows, err, errs.ErrMenuNotFound); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserInfoPattern)
+	return nil
+}

internal/service/admin/module.go

@@ -0,0 +1,19 @@
+package admin
+
+import (
+	"go.uber.org/fx"
+)
+
+var Module = fx.Module("sys-services",
+	fx.Provide(
+		NewUserService,
+		NewRoleService,
+		NewMenuService,
+		NewApiService,
+		NewFileService,
+		NewPostService,
+		NewAuthService,
+		NewTagService,
+		NewCategoryService,
+	),
+)

internal/service/admin/post.go

@@ -0,0 +1,168 @@
+package admin
+
+import (
+	"context"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type PostService struct {
+	store *db.Store
+}
+
+func NewPostService(store *db.Store) *PostService {
+	return &PostService{
+		store: store,
+	}
+}
+
+func (s *PostService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.ListPostsRow], error) {
+	params := sqlc.ListPostsParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountPosts(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListPosts(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.ListPostsRow]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *PostService) FindByID(ctx context.Context, id int32) (*sqlc.GetPostByIDRow, error) {
+	post, err := s.store.GetPostByID(ctx, id)
+	if err != nil {
+		return nil, dberr.MapNoRows(err, errs.ErrPostNotFound)
+	}
+
+	return &post, nil
+}
+
+func (s *PostService) Create(ctx context.Context, req request.CreatePostRequest) (int32, error) {
+	postID, err := db.WithTxResult(ctx, s.store, func(q *sqlc.Queries) (int32, error) {
+		params := sqlc.CreatePostParams{
+			Title:       req.Title,
+			CoverID:     &req.CoverID,
+			Slug:        req.Slug,
+			Content:     req.Content,
+			Summary:     req.Summary,
+			Status:      *req.Status,
+			Sort:        req.Sort,
+			PublishedAt: req.PublishedAt,
+		}
+
+		// 创建博客
+		postID, err := q.CreatePost(ctx, params)
+		if err != nil {
+			return 0, dberr.MapUniqueViolation(err, dberr.PostSlugKey, errs.ErrSlugAlreadyExists)
+		}
+
+		// 关联分类
+		if err = q.CreatePostCategory(ctx, sqlc.CreatePostCategoryParams{
+			PostID:     postID,
+			CategoryID: *req.CategoryID,
+		}); err != nil {
+			return 0, err
+		}
+
+		var tagsParams []sqlc.CreatePostTagParams
+		for _, tagID := range req.Tags {
+			tagsParams = append(tagsParams, sqlc.CreatePostTagParams{
+				PostID: postID,
+				TagID:  tagID,
+			})
+		}
+
+		if _, err = q.CreatePostTag(ctx, tagsParams); err != nil {
+			return 0, err
+		}
+
+		return postID, nil
+	})
+	if err != nil {
+		return 0, err
+	}
+
+	return postID, nil
+}
+
+func (s *PostService) Update(ctx context.Context, id int32, req request.UpdatePostRequest) error {
+	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		params := sqlc.UpdatePostParams{
+			Title:       req.Title,
+			CoverID:     req.CoverID,
+			Slug:        req.Slug,
+			Content:     req.Content,
+			Summary:     req.Summary,
+			Status:      req.Status,
+			Sort:        req.Sort,
+			PublishedAt: req.PublishedAt,
+			ID:          id,
+		}
+
+		rows, err := q.UpdatePost(ctx, params)
+		if err != nil {
+			return dberr.MapUniqueViolation(err, dberr.PostSlugKey, errs.ErrSlugAlreadyExists)
+		}
+
+		if err = dberr.MapRowsAffected(rows, nil, errs.ErrPostNotFound); err != nil {
+			return err
+		}
+
+		// 先删除分类
+		if err = q.DeletePostCategoryByPostID(ctx, id); err != nil {
+			return err
+		}
+
+		if err = q.CreatePostCategory(ctx, sqlc.CreatePostCategoryParams{
+			PostID:     id,
+			CategoryID: *req.CategoryID,
+		}); err != nil {
+			return err
+		}
+
+		// 先删除标签
+		if err = q.DeletePostTagByPostID(ctx, id); err != nil {
+			return err
+		}
+
+		var tagsParams []sqlc.CreatePostTagParams
+		for _, tagID := range req.Tags {
+			tagsParams = append(tagsParams, sqlc.CreatePostTagParams{
+				PostID: id,
+				TagID:  tagID,
+			})
+		}
+
+		if _, err = q.CreatePostTag(ctx, tagsParams); err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
+func (s *PostService) Delete(ctx context.Context, id int32) error {
+	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		err := q.DeletePostCategoryByPostID(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		rows, err := q.DeletePost(ctx, id)
+		return dberr.MapRowsAffected(rows, err, errs.ErrPostNotFound)
+	})
+}

internal/service/admin/role.go

@@ -0,0 +1,254 @@
+package admin
+
+import (
+	"context"
+	"errors"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/enum"
+	"server/internal/model/request"
+	"server/internal/pkg/cache"
+	"server/internal/pkg/cache/cachekey"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type RoleService struct {
+	store *db.Store
+	cache *cache.Caches
+}
+
+func NewRoleService(store *db.Store, cache *cache.Caches) *RoleService {
+	return &RoleService{
+		store: store,
+		cache: cache,
+	}
+}
+
+// clearCache 清理所有api权限和用户信息 禁用角色/删除角色需要清理
+func (s *RoleService) clearCache(ctx context.Context) error {
+	if err := s.cache.DelByPrefix(ctx, cachekey.UserApiPermissionsPattern); err != nil {
+		return err
+	}
+
+	if err := s.cache.DelByPrefix(ctx, cachekey.UserInfoPattern); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *RoleService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.SysRole], error) {
+	params := sqlc.ListRolesParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountRoles(ctx)
+
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListRoles(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.SysRole]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *RoleService) ListAll(ctx context.Context) ([]sqlc.SysRole, error) {
+	return s.store.ListAllRoles(ctx)
+}
+
+func (s *RoleService) ListRoleMenus(ctx context.Context, id int32) ([]sqlc.ListRoleMenusRow, error) {
+	_, err := s.store.GetRoleByID(ctx, id)
+	if err != nil {
+		return nil, dberr.MapNoRows(err, errs.ErrRoleNotFound)
+	}
+
+	return s.store.ListRoleMenus(ctx, id)
+}
+
+func (s *RoleService) ListRoleApis(ctx context.Context, id int32) ([]sqlc.ListRoleApisRow, error) {
+	_, err := s.store.GetRoleByID(ctx, id)
+	if err != nil {
+		return nil, dberr.MapNoRows(err, errs.ErrRoleNotFound)
+	}
+
+	return s.store.ListRoleApis(ctx, id)
+}
+
+func (s *RoleService) Create(ctx context.Context, req request.CreateRoleRequest) error {
+	params := sqlc.CreateRoleParams{
+		Name:   req.Name,
+		Code:   req.Code,
+		Status: *req.Status,
+	}
+
+	err := s.store.CreateRole(ctx, params)
+	if err != nil {
+		return dberr.MapUniqueViolation(err, dberr.SysRoleCodeKey, errs.ErrCodeAlreadyExists)
+	}
+	return nil
+}
+
+func (s *RoleService) Update(ctx context.Context, id int32, req request.UpdateRoleRequest) error {
+	params := sqlc.UpdateRoleParams{
+		ID:     id,
+		Name:   req.Name,
+		Status: req.Status,
+	}
+
+	rows, err := s.store.UpdateRole(ctx, params)
+	err = dberr.MapRowsAffected(rows, err, errs.ErrRoleNotFound)
+	if err != nil {
+		if errors.Is(err, errs.ErrRoleNotFound) {
+		}
+		return err
+	}
+
+	// 清理缓存 无论启用禁用 启用时也需要清理缓存以刷新权限
+	_ = s.clearCache(ctx)
+
+	return nil
+}
+
+func (s *RoleService) SetRoleMenus(ctx context.Context, roleID int32, req request.SetRoleMenusRequest) error {
+	// 先检查角色是否存在
+	_, err := s.store.GetRoleByID(ctx, roleID)
+	if err != nil {
+		return dberr.MapNoRows(err, errs.ErrRoleNotFound)
+	}
+
+	err = s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 1. 先删除所有关联表数据
+		if err = q.DeleteRolePermissionsByType(ctx, sqlc.DeleteRolePermissionsByTypeParams{
+			RoleID: roleID,
+			Type:   int16(enum.PermissionTypeMenu),
+		}); err != nil {
+			return err
+		}
+
+		// 2. 查出所有权限id并组装数据
+		permissionIds, err := q.ListPermissionIDsByMenuIDs(ctx, req.MenuIDs)
+		if err != nil {
+			return err
+		}
+
+		params := make([]sqlc.CreateRolePermissionParams, 0, len(permissionIds))
+		for _, id := range permissionIds {
+			params = append(params, sqlc.CreateRolePermissionParams{
+				RoleID:       roleID,
+				PermissionID: id,
+			})
+		}
+
+		// 批量插入
+		_, err = q.CreateRolePermission(ctx, params)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存 这里只用清理用户信息
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserInfoPattern)
+
+	return nil
+}
+
+func (s *RoleService) SetRoleApis(ctx context.Context, roleID int32, req request.SetRoleApisRequest) error {
+	_, err := s.store.GetRoleByID(ctx, roleID)
+	if err != nil {
+		return dberr.MapNoRows(err, errs.ErrRoleNotFound)
+	}
+
+	err = s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 先删除所有旧权限数据
+		if err = q.DeleteRolePermissionsByType(ctx, sqlc.DeleteRolePermissionsByTypeParams{
+			RoleID: roleID,
+			Type:   int16(enum.PermissionTypeApi),
+		}); err != nil {
+			return err
+		}
+
+		// 查出数据并组装
+		permissionIds, err := q.ListPermissionIDsByApiIDs(ctx, req.ApiIDs)
+		if err != nil {
+			return err
+		}
+
+		params := make([]sqlc.CreateRolePermissionParams, 0, len(permissionIds))
+		for _, id := range permissionIds {
+			params = append(params, sqlc.CreateRolePermissionParams{
+				RoleID:       roleID,
+				PermissionID: id,
+			})
+		}
+
+		// 批量插入
+		_, err = q.CreateRolePermission(ctx, params)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存 这里只用清理接口权限
+	_ = s.cache.DelByPrefix(ctx, cachekey.UserApiPermissionsPattern)
+
+	return nil
+}
+
+func (s *RoleService) Delete(ctx context.Context, id int32) error {
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 1.删除角色关联权限
+		err := q.DeleteRolePermissionsByRoleID(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		// 2. 根据角色id删除用户关联的角色
+		err = q.DeleteUserRoleByRoleID(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		// 3. 删除角色信息
+		rows, err := q.DeleteRole(ctx, id)
+		err = dberr.MapRowsAffected(rows, err, errs.ErrRoleNotFound)
+		if err != nil {
+			// 如果是数据库不存在这条数据 此时也执行清理
+			if errors.Is(err, errs.ErrRoleNotFound) {
+			}
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 清理缓存
+	_ = s.clearCache(ctx)
+
+	return nil
+}

internal/service/admin/tag.go

@@ -0,0 +1,90 @@
+package admin
+
+import (
+	"context"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+)
+
+type TagService struct {
+	store *db.Store
+}
+
+func NewTagService(store *db.Store) *TagService {
+	return &TagService{
+		store: store,
+	}
+}
+
+func (s *TagService) List(ctx context.Context, p *common.Pagination) (*common.PageResult[sqlc.Tag], error) {
+	params := sqlc.ListTagsParams{
+		Limit:  p.PageSize,
+		Offset: (p.Page - 1) * p.PageSize,
+	}
+
+	total, err := s.store.CountTags(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListTags(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.Tag]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *TagService) ListAll(ctx context.Context) ([]sqlc.Tag, error) {
+	return s.store.ListAllTags(ctx)
+}
+
+func (s *TagService) Create(ctx context.Context, req request.CreateTagRequest) error {
+	params := sqlc.CreateTagParams{
+		Name: req.Name,
+		Code: req.Code,
+		Sort: req.Sort,
+	}
+
+	err := s.store.CreateTag(ctx, params)
+	return dberr.MapUniqueViolation(err, dberr.TagCodeKey, errs.ErrTagCodeAlreadyExists)
+}
+
+func (s *TagService) Update(ctx context.Context, id int32, req request.UpdateTagRequest) error {
+	params := sqlc.UpdateTagParams{
+		ID:   id,
+		Name: req.Name,
+		Code: req.Code,
+		Sort: req.Sort,
+	}
+	rows, err := s.store.UpdateTag(ctx, params)
+	// 先判断数据条目是否存在
+	if err = dberr.MapRowsAffected(rows, err, errs.ErrTagNotFound); err != nil {
+		// 再判断code是否重复
+		return dberr.MapUniqueViolation(err, dberr.TagCodeKey, errs.ErrTagCodeAlreadyExists)
+	}
+
+	return nil
+}
+
+func (s *TagService) Delete(ctx context.Context, id int32) error {
+	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 删除中间表数据
+		err := s.store.DeletePostTagByTagID(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		// 删除标签数据
+		rows, err := s.store.DeleteTag(ctx, id)
+		return dberr.MapRowsAffected(rows, err, errs.ErrTagNotFound)
+	})
+
+}

internal/service/admin/user.go

@@ -0,0 +1,331 @@
+package admin
+
+import (
+	"context"
+	"errors"
+	"server/internal/db"
+	"server/internal/db/sqlc"
+	"server/internal/middleware"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/model/response"
+	"server/internal/pkg/cache"
+	"server/internal/pkg/cache/cachekey"
+	"server/internal/pkg/dberr"
+	"server/internal/pkg/errs"
+
+	"golang.org/x/sync/errgroup"
+)
+
+type UserService struct {
+	store *db.Store
+	jwt   *middleware.JWTMiddleware
+	cache *cache.Caches
+}
+
+func NewUserService(store *db.Store, jwt *middleware.JWTMiddleware, cache *cache.Caches) *UserService {
+	return &UserService{
+		store: store,
+		jwt:   jwt,
+		cache: cache,
+	}
+}
+
+// clearUserCache
+func (s *UserService) clearUserCache(ctx context.Context, id int32) error {
+	if err := s.cache.Del(ctx, cachekey.UserApiPermissions(id)); err != nil {
+		return err
+	}
+
+	if err := s.cache.Del(ctx, cachekey.UserInfo(id)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// clearRefreshToken
+func (s *UserService) clearRefreshToken(ctx context.Context, id int32) error {
+
+	keys, err := s.cache.SMembers(ctx, cachekey.AuthRefreshUser(id))
+	if err != nil {
+		return err
+	}
+
+	// 循环删除所有的token
+	for _, key := range keys {
+		if err = s.cache.Del(ctx, cachekey.AuthRefresh(key)); err != nil {
+			return err
+		}
+	}
+
+	// 删除反向索引
+	err = s.cache.DelSetMembers(ctx, cachekey.AuthRefreshUser(id))
+	return err
+}
+
+func (s *UserService) GetCurrentUser(ctx context.Context, id int32, isAdmin bool) (*response.UserInfo, error) {
+	return cache.GetOrSetJSON[*response.UserInfo](ctx, s.cache, cachekey.UserInfo(id), 0, func() (*response.UserInfo, error) {
+		g, ctx := errgroup.WithContext(ctx)
+
+		var (
+			user        sqlc.GetUserByIDRow
+			roles       []sqlc.SysRole
+			menus       []sqlc.SysMenu
+			permissions []*string
+		)
+
+		g.Go(func() error {
+			u, err := s.store.GetUserByID(ctx, id)
+			if err != nil {
+				return dberr.MapNoRows(err, errs.ErrUserNotFound)
+			}
+
+			user = u
+			return nil
+		})
+
+		g.Go(func() error {
+			r, err := s.store.ListUserRoles(ctx, id)
+			if err != nil {
+				return err
+			}
+			roles = r
+			return nil
+		})
+
+		g.Go(func() error {
+			var (
+				p   []*string
+				err error
+			)
+
+			if isAdmin {
+				p, err = s.store.ListAdminPermissionCodes(ctx)
+			} else {
+				p, err = s.store.ListUserPermissionCodes(ctx, id)
+			}
+
+			if err != nil {
+				return err
+			}
+
+			permissions = p
+
+			return nil
+		})
+
+		g.Go(func() error {
+			var (
+				m   []sqlc.SysMenu
+				err error
+			)
+			if isAdmin {
+				m, err = s.store.ListAdminMenus(ctx)
+			} else {
+				m, err = s.store.ListUserMenus(ctx, id)
+			}
+			if err != nil {
+				return err
+			}
+			menus = m
+			return nil
+		})
+
+		if err := g.Wait(); err != nil {
+			return nil, err
+		}
+
+		// 如果用户被禁用 返回错误 超管不用管状态
+		if user.ID != 1 && user.Status != 1 {
+			return nil, errs.ErrUserDisabled
+		}
+
+		// 处理角色
+		userInfo := response.NewUserInfo(user, roles, menus, permissions)
+
+		return userInfo, nil
+	})
+}
+
+func (s *UserService) List(ctx context.Context, p request.SearchUserParams) (*common.PageResult[sqlc.ListUsersRow], error) {
+	params := sqlc.ListUsersParams{
+		Limit:    p.PageSize,
+		Offset:   (p.Page - 1) * p.PageSize,
+		Username: p.Username,
+	}
+
+	total, err := s.store.CountUsers(ctx, p.Username)
+
+	if err != nil {
+		return nil, err
+	}
+
+	list, err := s.store.ListUsers(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &common.PageResult[sqlc.ListUsersRow]{
+		List:  list,
+		Total: total,
+	}, nil
+}
+
+func (s *UserService) ListRoles(ctx context.Context, id int32) ([]sqlc.SysRole, error) {
+	// 先查询用户是否存在
+	_, err := s.store.GetUserByID(ctx, id)
+	if err != nil {
+		return nil, dberr.MapNoRows(err, errs.ErrUserNotFound)
+	}
+
+	return s.store.ListUserRoles(ctx, id)
+}
+
+func (s *UserService) Create(ctx context.Context, req request.CreateUserRequest) error {
+	passwordHash, err := generatePasswordHash(req.Password)
+	if err != nil {
+		return err
+	}
+
+	user := sqlc.CreateUserParams{
+		Account:      req.Account,
+		Username:     req.Username,
+		PasswordHash: passwordHash,
+		AvatarID:     req.AvatarID,
+		Status:       *req.Status,
+	}
+
+	if err = s.store.CreateUser(ctx, user); err != nil {
+		return dberr.MapUniqueViolation(err, dberr.SysUserAccountKey, errs.ErrAccountAlreadyExists)
+	}
+
+	return nil
+}
+
+func (s *UserService) Update(ctx context.Context, id int32, req request.UpdateUserRequest) error {
+	user := sqlc.UpdateUserParams{
+		Username: req.Username,
+		ID:       id,
+		Status:   req.Status,
+	}
+
+	if req.AvatarID.Set {
+		user.UpdateAvatarID = true
+		if req.AvatarID.Valid {
+			user.AvatarID = &req.AvatarID.Value
+		}
+	}
+
+	rows, err := s.store.UpdateUser(ctx, user)
+	if err = dberr.MapRowsAffected(rows, err, errs.ErrUserNotFound); err != nil {
+		return err
+	}
+
+	// 清理缓存
+	_ = s.clearUserCache(ctx, id)
+
+	// 如果将用户的状态修改为0，则清除用户刷新令牌
+	if req.Status != nil && *req.Status == 0 {
+		_ = s.clearRefreshToken(ctx, id)
+	}
+
+	return nil
+}
+
+func (s *UserService) SetRoles(ctx context.Context, userID int32, req request.SetUserRolesRequest) error {
+	// 先查询用户是否存在
+	_, err := s.store.GetUserByID(ctx, userID)
+	if err != nil {
+		return dberr.MapNoRows(err, errs.ErrUserNotFound)
+	}
+
+	err = s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 1. 先删除关联数据
+		if err = q.ClearUserRoles(ctx, userID); err != nil {
+			return err
+		}
+
+		var params []sqlc.CreateUserRoleParams
+
+		for _, roleID := range req.RoleIDs {
+			params = append(params, sqlc.CreateUserRoleParams{
+				UserID: userID,
+				RoleID: roleID,
+			})
+		}
+
+		// 2. 关联用户角色数据
+		_, err = q.CreateUserRole(ctx, params)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	// 3. 清理缓存
+	_ = s.clearUserCache(ctx, userID)
+
+	return nil
+}
+
+func (s *UserService) UpdatePassword(ctx context.Context, id int32, req request.UpdateUserPassword) error {
+	passwordHash, err := generatePasswordHash(req.Password)
+	if err != nil {
+		return err
+	}
+
+	params := sqlc.UpdateUserPasswordParams{
+		ID:           id,
+		PasswordHash: passwordHash,
+	}
+
+	rows, err := s.store.UpdateUserPassword(ctx, params)
+	err = dberr.MapRowsAffected(rows, err, errs.ErrUserNotFound)
+	if err != nil {
+		return err
+	}
+
+	// 下线当前用户
+	_ = s.clearRefreshToken(ctx, id)
+
+	return nil
+}
+
+func (s *UserService) Delete(ctx context.Context, id int32) error {
+	isAdmin := middleware.UserIsAdmin(id)
+
+	if isAdmin {
+		return errs.ErrCannotDeleteSuperAdmin
+	}
+
+	err := s.store.WithTx(ctx, func(q *sqlc.Queries) error {
+		// 清理用户角色关联数据
+		err := q.ClearUserRoles(ctx, id)
+		if err != nil {
+			return err
+		}
+
+		// 删除用户
+		rows, err := q.DeleteUser(ctx, id)
+		return dberr.MapRowsAffected(rows, err, errs.ErrUserNotFound)
+	})
+
+	if err != nil {
+		if errors.Is(err, errs.ErrUserNotFound) {
+			// 用户不存在也执行清理缓存操作
+			_ = s.clearUserCache(ctx, id)
+		}
+		return err
+	}
+
+	// 事务执行成功后清理缓存
+	_ = s.clearUserCache(ctx, id)
+	_ = s.clearRefreshToken(ctx, id)
+	return nil
+}