first commit

internal/service/aliyunoss/aliyunoss.go

@@ -0,0 +1,82 @@
+package aliyunoss
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"time"
+
+	"management/internal/config"
+
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+	"github.com/h2non/filetype"
+	gonanoid "github.com/matoous/go-nanoid/v2"
+)
+
+var engine *oss.Client
+
+var AllowImageMaxSize int64 = 10485760
+
+func Init() error {
+	var err error
+	engine, err = oss.New(config.File.AliyunUpload.Endpoint, config.File.AliyunUpload.AccessKeyID, config.File.AliyunUpload.AccessKeySecret, oss.Timeout(10, 120))
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func UploadImage(file *multipart.FileHeader) (string, error) {
+	if file.Size > AllowImageMaxSize {
+		return "", errors.New("failed to receive image too large")
+	}
+
+	fileOpen, err := file.Open()
+	if err != nil {
+		return "", errors.New("failed to image open")
+	}
+	defer func(fileOpen multipart.File) {
+		_ = fileOpen.Close()
+	}(fileOpen)
+
+	fileBytes, err := io.ReadAll(fileOpen)
+	if err != nil {
+		return "", errors.New("failed to read image")
+	}
+
+	if !filetype.IsImage(fileBytes) {
+		return "", errors.New("failed to no image type")
+	}
+
+	kind, err := filetype.Match(fileBytes)
+	if err != nil || kind == filetype.Unknown {
+		return "", errors.New("failed to get image type")
+	}
+
+	imgPath := GenerateFilename(kind.Extension)
+	err = PutObject(imgPath, fileBytes)
+	if err != nil {
+		return "", err
+	}
+	return imgPath, nil
+}
+
+func GenerateFilename(extension string) string {
+	id, _ := gonanoid.New()
+	return fmt.Sprintf("upload/%s/%s/%s/%s.%s", time.Now().Format("2006"), time.Now().Format("01"), time.Now().Format("02"), id, extension)
+}
+
+func PutObject(path string, stream []byte) error {
+	bucket, err := engine.Bucket(config.File.AliyunUpload.Bucket)
+	if err != nil {
+		return errors.New("failed to get bucket")
+	}
+
+	err = bucket.PutObject(path, bytes.NewReader(stream))
+	if err != nil {
+		return errors.New("failed to upload to oss")
+	}
+	return nil
+}

internal/service/applet/applet.go

@@ -0,0 +1,81 @@
+package applet
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"management/internal/config"
+	"management/internal/pkg/fetcher"
+	"management/internal/pkg/redis"
+)
+
+// var appletLoginErrs = map[int]string{
+// 	-1:    "系统繁忙",
+// 	40029: "js_code无效",
+// 	45011: "API调用太频繁,请稍候再试",
+// 	40226: "高风险等级用户,小程序登录拦截",
+// }
+
+type AppletLoginResponse struct {
+	OpenID     string `json:"openid"`
+	SessionKey string `json:"session_key"`
+	UnionID    string `json:"unionid"`
+	ErrCode    int    `json:"errcode"`
+	ErrMsg     string `json:"errmsg"`
+}
+
+func AppletLogin(code string) (*AppletLoginResponse, error) {
+	url := fmt.Sprintf("https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code",
+		config.File.Applet.AppID, config.File.Applet.AppSecret, code)
+	response, status, err := fetcher.Get(url, time.Second*3)
+	if err != nil {
+		return nil, err
+	}
+
+	if status != 200 {
+		return nil, errors.New("请求失败")
+	}
+
+	var res AppletLoginResponse
+	err = json.Unmarshal(response, &res)
+	if err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type accessTokenResponse struct {
+	AccessToken string `json:"access_token"`
+	ExpiresIn   int    `json:"expires_in"`
+}
+
+func GetAccessToken(ctx context.Context) (string, error) {
+	key := "token:" + config.File.Applet.AppID
+	token, err := redis.Get(ctx, key)
+	if err == nil && len(token) > 0 {
+		return token, nil
+	}
+
+	url := fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s",
+		config.File.Applet.AppID, config.File.Applet.AppSecret)
+	response, status, err := fetcher.Get(url, time.Second*3)
+	if err != nil {
+		return "", err
+	}
+
+	if status != 200 {
+		return "", errors.New("获取access token失败")
+	}
+
+	var res accessTokenResponse
+	err = json.Unmarshal(response, &res)
+	if err != nil {
+		return "", err
+	}
+
+	redis.Set(ctx, key, res.AccessToken, time.Duration(res.ExpiresIn-100)*time.Second)
+	return res.AccessToken, nil
+}

internal/service/budget/budget.go

@@ -0,0 +1,31 @@
+package budget
+
+import (
+	"context"
+	"strconv"
+
+	db "management/internal/db/sqlc"
+	"management/internal/global"
+)
+
+func AllBudgets(ctx context.Context, projectId int64) []*global.DataDict {
+	pp, err := db.Engine.ListBudgets(ctx, projectId)
+	if err != nil || len(pp) == 0 {
+		return nil
+	}
+
+	var res []*global.DataDict
+	res = append(res, &global.DataDict{
+		Name:  "请选择",
+		Value: "0",
+	})
+	for _, v := range pp {
+		item := global.DataDict{
+			Name:  v.Name,
+			Value: strconv.Itoa(int(v.ID)),
+		}
+		res = append(res, &item)
+	}
+
+	return res
+}

internal/service/captcha/captcha.go

@@ -0,0 +1,18 @@
+package captcha
+
+import "github.com/mojocn/base64Captcha"
+
+var captchaStore base64Captcha.Store = base64Captcha.DefaultMemStore
+
+func Generate(height int, width int, length int, maxSkew float64, dotCount int) (id, b64s, answer string, err error) {
+	driver := base64Captcha.NewDriverDigit(height, width, length, maxSkew, dotCount)
+	// driver := base64Captcha.NewDriverString(config.File.Captcha.ImgHeight,
+	// 	config.File.Captcha.ImgWidth,
+	// 	6, 1, keyLong, source, nil, nil, nil)
+	cp := base64Captcha.NewCaptcha(driver, captchaStore)
+	return cp.Generate()
+}
+
+func Verify(id, answer string, clear bool) bool {
+	return captchaStore.Verify(id, answer, clear)
+}

internal/service/category/category.go

@@ -0,0 +1,323 @@
+package category
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func ListCategoriesCondition(ctx context.Context, q dto.SearchDto) ([]*db.Category, int64, error) {
+	countArg := &db.CountCategoriesConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int16(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+	}
+
+	dataArg := &db.ListCategoriesConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int16(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
+		Size:       int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "id":
+			id, err := strconv.Atoi(q.SearchKey)
+			if err == nil {
+				countArg.IsID = true
+				countArg.ID = int32(id)
+
+				dataArg.IsID = true
+				dataArg.ID = int32(id)
+			}
+		case "name":
+			countArg.Name = q.SearchKey
+			dataArg.Name = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountCategoriesCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	categories, err := db.Engine.ListCategoriesCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return categories, count, nil
+}
+
+func DTreeCategory(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
+	all, err := db.Engine.AllCategories(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDtree(id, all), nil
+}
+
+func GetParentCategorySelectLetter(ctx context.Context, letter string) ([]*global.DataDict, error) {
+	all := AllCategories(ctx)
+	if len(all) == 0 {
+		return nil, errors.New("请刷新类别缓存")
+	}
+
+	var current *db.Category
+	for _, v := range all {
+		if v.Letter == letter {
+			current = v
+			break
+		}
+	}
+	if current == nil {
+		return nil, errors.New("未找到当前类别")
+	}
+
+	var res []*global.DataDict
+	res = append(res, &global.DataDict{
+		Name:  "请选择",
+		Value: "0",
+	})
+	for _, v := range all {
+		if v.ParentID == current.ID {
+			item := global.DataDict{
+				Name:  v.Name,
+				Value: strconv.Itoa(int(v.ID)),
+			}
+			res = append(res, &item)
+		}
+	}
+
+	return res, nil
+}
+
+func ListByParentID(ctx context.Context, parentID int32) ([]*db.Category, error) {
+	all := AllCategories(ctx)
+	if len(all) == 0 {
+		return nil, errors.New("请刷新类别缓存")
+	}
+	var res []*db.Category
+	for _, v := range all {
+		if v.ParentID == parentID {
+			res = append(res, v)
+		}
+	}
+	return res, nil
+}
+
+func ListByLetter(ctx context.Context, letter string) ([]*db.Category, error) {
+	all := AllCategories(ctx)
+	if len(all) == 0 {
+		return nil, errors.New("请刷新类别缓存")
+	}
+	var current *db.Category
+	for _, v := range all {
+		if v.Letter == letter {
+			current = v
+			break
+		}
+	}
+	if current == nil {
+		return nil, errors.New("未找到当前类别")
+	}
+
+	var res []*db.Category
+	for _, v := range all {
+		if v.ParentID == current.ID {
+			res = append(res, v)
+		}
+	}
+	return res, nil
+}
+
+func GetParentCategorySelect(ctx context.Context, id int32) ([]*global.DataDict, error) {
+	all := AllCategories(ctx)
+	if len(all) == 0 {
+		return nil, errors.New("请刷新类别缓存")
+	}
+
+	var res []*global.DataDict
+	res = append(res, &global.DataDict{
+		Name:  "请选择",
+		Value: "0",
+	})
+	for _, v := range all {
+		if v.ParentID == id {
+			item := global.DataDict{
+				Name:  v.Name,
+				Value: strconv.Itoa(int(v.ID)),
+			}
+			res = append(res, &item)
+		}
+	}
+
+	return res, nil
+}
+
+func toDtree(parentId int32, data []*db.Category) []*dto.DTreeDto {
+	var res []*dto.DTreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.DTreeDto{}
+			item.ID = strconv.FormatInt(int64(v.ID), 10)
+			item.Title = v.Name
+			item.Last = !hasChildren(v.ID, data)
+			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
+			item.Children = toDtree(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func hasChildren(parentId int32, data []*db.Category) bool {
+	if len(data) > 0 {
+		for _, v := range data {
+			if v.ParentID == parentId {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func RefreshCategory(ctx context.Context) error {
+	all, err := db.Engine.AllCategories(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	redis.Del(ctx, keys.GetManageKey(ctx, keys.AllCategorySimple))
+	key := keys.GetManageKey(ctx, keys.AllCategories)
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func AllCategories(ctx context.Context) []*db.Category {
+	var res []*db.Category
+	key := keys.GetManageKey(ctx, keys.AllCategories)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res
+		}
+	}
+
+	res, err = db.Engine.AllCategories(ctx)
+	if err == nil {
+		if b, err = json.Marshal(res); err == nil {
+			redis.Set(ctx, key, b, time.Hour*6)
+		}
+	}
+
+	return res
+}
+
+type CategorySet struct {
+	Title string          `json:"title"`
+	Data  []*CategoryItem `json:"data"`
+}
+
+type CategoryItem struct {
+	ID          int32  `json:"id"`
+	Name        string `json:"name"`
+	Icon        string `json:"icon"`
+	Description string `json:"description"`
+	Url         string `json:"url"`
+}
+
+func AllCategoriesItem(ctx context.Context) []*CategoryItem {
+	var res []*CategoryItem
+	key := keys.GetManageKey(ctx, keys.AllCategorySimple)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		if err = json.Unmarshal(b, &res); err == nil {
+			return res
+		}
+	}
+	all, err := db.Engine.AllCategories(ctx)
+	if err != nil {
+		return nil
+	}
+	for _, v := range all {
+		res = append(res, &CategoryItem{
+			ID:   v.ID,
+			Name: v.Name,
+		})
+	}
+	b, err = json.Marshal(res)
+	if err == nil {
+		redis.Set(ctx, key, b, time.Hour*6)
+	}
+	return res
+}
+
+func ListCategoriesByParentID(ctx context.Context, parentID int) ([]*CategorySet, error) {
+	var res []*CategorySet
+	key := keys.GetManageKey(ctx, keys.ListCategoriesByParentID, parentID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		if err = json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	all, err := db.Engine.ListCategoriesByPath(ctx, "%,"+strconv.Itoa(parentID)+",%")
+	if err != nil {
+		return nil, err
+	}
+
+	root := findCategoryItem(parentID, all)
+	for _, v := range root {
+		children := findCategoryItem(int(v.ID), all)
+		if len(children) > 0 {
+			res = append(res, &CategorySet{
+				Title: v.Name,
+				Data:  children,
+			})
+		}
+	}
+
+	b, err = json.Marshal(res)
+	if err == nil {
+		redis.Set(ctx, key, b, time.Hour*6)
+	}
+
+	return res, nil
+}
+
+func findCategoryItem(parentID int, all []*db.Category) []*CategoryItem {
+	var res []*CategoryItem
+	for _, v := range all {
+		if v.ParentID == int32(parentID) {
+			item := CategoryItem{}
+			item.ID = v.ID
+			item.Name = v.Name
+			item.Icon = v.Icon
+			item.Description = v.Description
+			res = append(res, &item)
+		}
+	}
+	return res
+}

internal/service/project/project.go

@@ -0,0 +1,72 @@
+package project
+
+import (
+	"context"
+	"strconv"
+
+	db "management/internal/db/sqlc"
+	"management/internal/global"
+)
+
+func CreateProject(ctx context.Context, p *db.CreateProjectParams, pf []*db.CreateProjectFileParams) error {
+	return db.Engine.ExecTx(ctx, func(q *db.Queries) error {
+		_, err := q.CreateProject(ctx, p)
+		if err != nil {
+			return err
+		}
+
+		for _, item := range pf {
+			_, err = q.CreateProjectFile(ctx, item)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func UpdateProject(ctx context.Context, p *db.UpdateProjectParams, pf []*db.CreateProjectFileParams) error {
+	return db.Engine.ExecTx(ctx, func(q *db.Queries) error {
+		_, err := q.UpdateProject(ctx, p)
+		if err != nil {
+			return err
+		}
+
+		err = q.DeleteProjectFile(ctx, p.ID)
+		if err != nil {
+			return err
+		}
+
+		for _, item := range pf {
+			_, err = q.CreateProjectFile(ctx, item)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func AllProjects(ctx context.Context) []*global.DataDict {
+	pp, err := db.Engine.AllProjects(ctx)
+	if err != nil || len(pp) == 0 {
+		return nil
+	}
+
+	var res []*global.DataDict
+	res = append(res, &global.DataDict{
+		Name:  "请选择",
+		Value: "0",
+	})
+	for _, v := range pp {
+		item := global.DataDict{
+			Name:  v.Name,
+			Value: strconv.Itoa(int(v.ID)),
+		}
+		res = append(res, &item)
+	}
+
+	return res
+}

internal/service/system/auth.go

@@ -0,0 +1 @@
+package system

internal/service/system/sys_audit_log.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysAuditLog(ctx context.Context, arg *db.CreateSysAuditLogParams) error {
+	return db.Engine.CreateSysAuditLog(ctx, arg)
+}
+
+func ListSysAuditLog(ctx context.Context, q dto.SearchDto) ([]*db.SysAuditLog, int64, error) {
+	start, err := time.ParseInLocation(time.DateTime, q.SearchTimeBegin, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+	end, err := time.ParseInLocation(time.DateTime, q.SearchTimeEnd, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	countArg := &db.CountSysAuditLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+	}
+
+	dataArg := &db.ListSysAuditLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+		Skip:    (int32(q.Page) - 1) * int32(q.Rows),
+		Size:    int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "email":
+			countArg.Email = q.SearchKey
+			dataArg.Email = q.SearchKey
+		case "username":
+			countArg.Username = q.SearchKey
+			dataArg.Username = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysAuditLogCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	audits, err := db.Engine.ListSysAuditLogCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return audits, count, nil
+}

internal/service/system/sys_config.go

@@ -0,0 +1,72 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/global/pearadmin"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysConfig(ctx context.Context, arg *db.CreateSysConfigParams) error {
+	return db.Engine.CreateSysConfig(ctx, arg)
+}
+
+func UpdateSysConfigByKey(ctx context.Context, arg *db.UpdateSysConfigByKeyParams) error {
+	return db.Engine.UpdateSysConfigByKey(ctx, arg)
+}
+
+func GetSysConfig(ctx context.Context, id int32) (*db.SysConfig, error) {
+	return db.Engine.GetSysConfig(ctx, id)
+}
+
+func GetSysConfigByKey(ctx context.Context, key string) (*db.SysConfig, error) {
+	return db.Engine.GetSysConfigByKey(ctx, key)
+}
+
+func PearConfig(ctx context.Context) (*dto.PearConfig, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.PearAdmin)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res *dto.PearConfig
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	conf, err := db.Engine.GetSysConfigByKey(ctx, pearadmin.PearKey)
+	if err != nil {
+		return nil, err
+	}
+
+	var pear dto.PearConfig
+	if err := json.Unmarshal(conf.Value, &pear); err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, conf.Value, time.Hour*6)
+	return &pear, nil
+}
+
+func ListSysConfigCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysConfig, int64, error) {
+	count, err := db.Engine.CountSysConfigCondition(ctx, q.SearchKey)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	configs, err := db.Engine.ListSysConfigCondition(ctx, &db.ListSysConfigConditionParams{
+		Key:  q.SearchKey,
+		Skip: (int32(q.Page) - 1) * int32(q.Rows),
+		Size: int32(q.Rows),
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return configs, count, nil
+}

internal/service/system/sys_department.go

@@ -0,0 +1,232 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysDepartment(ctx context.Context, arg *db.CreateSysDepartmentParams) (*db.SysDepartment, error) {
+	return db.Engine.CreateSysDepartment(ctx, arg)
+}
+
+func UpdateSysDepartment(ctx context.Context, arg *db.UpdateSysDepartmentParams) (*db.SysDepartment, error) {
+	return db.Engine.UpdateSysDepartment(ctx, arg)
+}
+
+func GetSysDepartment(ctx context.Context, id int32) (*db.SysDepartment, error) {
+	return db.Engine.GetSysDepartment(ctx, id)
+}
+
+func AllCache(ctx context.Context) ([]*db.SysDepartment, error) {
+	key := keys.GetManageKey(ctx, keys.AllDepartments)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysDepartment
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err = json.Marshal(all)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return all, nil
+}
+
+func ListSysDepartmentCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysDepartment, int64, error) {
+	countArg := &db.CountSysDepartmentConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+	}
+
+	dataArg := &db.ListSysDepartmentConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
+		Size:       int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "id":
+			id, err := strconv.Atoi(q.SearchKey)
+			if err == nil {
+				countArg.IsID = true
+				countArg.ID = int32(id)
+
+				dataArg.IsID = true
+				dataArg.ID = int32(id)
+			}
+		case "name":
+			countArg.Name = q.SearchKey
+			dataArg.Name = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysDepartmentCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	departs, err := db.Engine.ListSysDepartmentCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return departs, count, nil
+}
+
+func ListTreeSysDepartment(ctx context.Context) ([]*db.SysDepartmentDto, error) {
+	all, err := db.Engine.ListSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return ToDtoTreeSysDepartment(0, all), nil
+}
+
+func DTreeSysDepartment(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDtree(id, all), nil
+}
+
+func RebuildSysDepartmentParentPath(ctx context.Context) error {
+	return db.Engine.SysDepartmentRebuildPath(ctx)
+}
+
+func toDtree(parentId int32, data []*db.SysDepartment) []*dto.DTreeDto {
+	var res []*dto.DTreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.DTreeDto{}
+			item.ID = strconv.FormatInt(int64(v.ID), 10)
+			item.Title = v.Name
+			item.Last = !hasChildren(v.ID, data)
+			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
+			item.Children = toDtree(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func hasChildren(parentId int32, data []*db.SysDepartment) bool {
+	if len(data) > 0 {
+		for _, v := range data {
+			if v.ParentID == parentId {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func ToTreeSysDepartment(ctx context.Context, id int, isRoot bool) ([]*dto.TreeDto, error) {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if isRoot {
+		root := getSysDepartmentRootParentId(int32(id), all)
+		if root == nil {
+			root = &dto.TreeDto{
+				ID:    0,
+				Title: "根节点",
+			}
+		}
+
+		root.Children = toDtoTreeSysDepartment(int32(id), all)
+		return []*dto.TreeDto{root}, nil
+	}
+
+	return toDtoTreeSysDepartment(int32(id), all), nil
+}
+
+func RefreshSysDepartment(ctx context.Context) error {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AllDepartments)
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func getSysDepartmentRootParentId(parentId int32, data []*db.SysDepartment) *dto.TreeDto {
+	for _, v := range data {
+		if v.ID == parentId {
+			return &dto.TreeDto{
+				ID:    int(v.ID),
+				Title: v.Name,
+			}
+		}
+	}
+	return nil
+}
+
+func ToDtoTreeSysDepartment(parentId int32, data []*db.SysDepartment) []*db.SysDepartmentDto {
+	var res []*db.SysDepartmentDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := db.SysDepartmentDto{}
+			item.ID = v.ID
+			item.Name = v.Name
+			item.ParentID = v.ParentID
+			item.ParentPath = v.ParentPath
+			item.Status = v.Status
+			item.CreatedAt = v.CreatedAt
+			item.UpdatedAt = v.UpdatedAt
+			item.Children = ToDtoTreeSysDepartment(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func toDtoTreeSysDepartment(parentId int32, data []*db.SysDepartment) []*dto.TreeDto {
+	var res []*dto.TreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.TreeDto{}
+			item.ID = int(v.ID)
+			item.Title = v.Name
+			item.Children = toDtoTreeSysDepartment(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}

internal/service/system/sys_menu.go

@@ -0,0 +1,567 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysMenu(ctx context.Context, arg *db.CreateSysMenuParams) (*db.SysMenu, error) {
+	return db.Engine.CreateSysMenu(ctx, arg)
+}
+
+func UpdateSysMenu(ctx context.Context, arg *db.UpdateSysMenuParams) (*db.SysMenu, error) {
+	return db.Engine.UpdateSysMenu(ctx, arg)
+}
+
+func GetSysMenu(ctx context.Context, id int32) (*db.SysMenu, error) {
+	return db.Engine.GetSysMenu(ctx, id)
+}
+
+func GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error) {
+	return db.Engine.GetSysMenuByUrl(ctx, url)
+}
+
+func ListSysMenuByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
+	return db.Engine.ListSysMenuByRoleID(ctx, roleID)
+}
+
+func AllMenusCache(ctx context.Context) ([]*db.SysMenu, error) {
+	key := keys.GetManageKey(ctx, keys.AllMenus)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysMenu
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	all, err := db.Engine.AllSysMenu(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err = json.Marshal(all)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return all, nil
+}
+
+func ListMenuTree(ctx context.Context) ([]*db.SysMenuDto, error) {
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toTreeSysMenu(0, all), nil
+}
+
+func ListMenuByRoles(ctx context.Context, roles []*db.SysRole) ([]*db.SysMenu, error) {
+	// 判断角色是否有vip
+	var vip bool
+	for _, item := range roles {
+		if item.Vip {
+			vip = true
+			break
+		}
+	}
+
+	var err error
+	var userMenus []*db.SysMenu
+	if vip {
+		userMenus, err = AllMenusCache(ctx)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		for _, item := range roles {
+			ums, err := db.Engine.ListSysMenuByRoleID(ctx, item.ID)
+			if err != nil {
+				return nil, err
+			}
+			userMenus = append(userMenus, ums...)
+		}
+	}
+
+	return userMenus, nil
+}
+
+func IListMenuByUserID(ctx context.Context, userID int32) ([]*db.SysMenu, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.AdminMenus, userID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysMenu
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetListMenuByUserID(ctx, userID)
+}
+
+func SetListMenuByUserID(ctx context.Context, userID int32) ([]*db.SysMenu, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRoleByUserID(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	var e error
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		menus, e = db.Engine.AllSysMenu(ctx)
+		if e != nil {
+			return nil, err
+		}
+
+	} else {
+		// not vip
+		menus, e = db.Engine.AllSysMenu(ctx) // db.Engine.ListSysMenuByUserID(ctx, userID)
+		if e != nil {
+			return nil, err
+		}
+	}
+
+	b, err := json.Marshal(menus)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AdminMenus, userID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return menus, nil
+}
+
+func MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res map[string]*dto.OwnerMenuDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetOwnerMapMenuByRoleID(ctx, roleID)
+}
+
+func ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*dto.OwnerMenuDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetOwnerListMenuByRoleID(ctx, roleID)
+}
+
+func ownerMenusByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRole(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var e error
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		menus, e = db.Engine.AllSysMenu(ctx)
+		if e != nil {
+			return nil, err
+		}
+
+	} else {
+		// not vip
+		menus, e = db.Engine.ListSysMenuByRoleID(ctx, roleID)
+		if e != nil {
+			return nil, err
+		}
+	}
+
+	return menus, nil
+}
+
+func SetOwnerListMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
+	menus, err := ownerMenusByRoleID(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []*dto.OwnerMenuDto
+	for _, menu := range menus {
+		res = append(res, &dto.OwnerMenuDto{
+			ID:          menu.ID,
+			DisplayName: menu.DisplayName,
+			Url:         menu.Url,
+			ParentID:    menu.ParentID,
+			Avatar:      menu.Avatar,
+			Style:       menu.Style,
+			IsList:      menu.IsList,
+		})
+	}
+
+	b, err := json.Marshal(res)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return res, nil
+}
+
+func SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
+	result := make(map[string]*dto.OwnerMenuDto)
+	menus, err := ownerMenusByRoleID(ctx, roleID)
+	if err != nil {
+		return result, err
+	}
+
+	for _, menu := range menus {
+		result[menu.Url] = &dto.OwnerMenuDto{
+			ID:          menu.ID,
+			DisplayName: menu.DisplayName,
+			Url:         menu.Url,
+			ParentID:    menu.ParentID,
+			Avatar:      menu.Avatar,
+			Style:       menu.Style,
+			IsList:      menu.IsList,
+		}
+	}
+
+	b, err := json.Marshal(result)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return result, nil
+}
+
+// RecursiveSysMenus 递归查询菜单 (pear layui 展示菜单的格式)
+func RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*dto.MenuUIDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetRecursiveSysMenus(ctx, roleID)
+}
+
+func SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRole(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		all, err := db.Engine.RecursiveSysMenus(ctx)
+		if err != nil {
+			return nil, err
+		}
+		menus = convertToMenuUIDto(all)
+
+	} else {
+		// not vip
+		all, err := db.Engine.RecursiveSysMenusByRoleID(ctx, roleID)
+		if err != nil {
+			return nil, err
+		}
+		menus = convertToMenuUIDto2(all)
+	}
+	menuList := uniqueSysMenus(menus)
+	if len(menuList) == 0 {
+		return nil, nil
+	}
+
+	tree := convertToUITree(menuList, 0)
+	b, err := json.Marshal(tree)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return tree, nil
+}
+
+func convertToMenuUIDto(data []*db.RecursiveSysMenusRow) []*db.SysMenu {
+	var res []*db.SysMenu
+
+	for _, item := range data {
+		temp := &db.SysMenu{
+			ID:          item.ID,
+			Name:        item.Name,
+			DisplayName: item.DisplayName,
+			Url:         item.Url,
+			Type:        item.Type,
+			ParentID:    item.ParentID,
+			ParentPath:  item.ParentPath,
+			Avatar:      item.Avatar,
+			Style:       item.Style,
+			Visible:     item.Visible,
+			IsList:      item.IsList,
+			Status:      item.Status,
+			Sort:        item.Sort,
+			CreatedAt:   item.CreatedAt,
+			UpdatedAt:   item.UpdatedAt,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func convertToMenuUIDto2(data []*db.RecursiveSysMenusByRoleIDRow) []*db.SysMenu {
+	var res []*db.SysMenu
+
+	for _, item := range data {
+		temp := &db.SysMenu{
+			ID:          item.ID,
+			Name:        item.Name,
+			DisplayName: item.DisplayName,
+			Url:         item.Url,
+			Type:        item.Type,
+			ParentID:    item.ParentID,
+			ParentPath:  item.ParentPath,
+			Avatar:      item.Avatar,
+			Style:       item.Style,
+			Visible:     item.Visible,
+			IsList:      item.IsList,
+			Status:      item.Status,
+			Sort:        item.Sort,
+			CreatedAt:   item.CreatedAt,
+			UpdatedAt:   item.UpdatedAt,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func convertToUITree(data []*db.SysMenu, parentID int32) []*dto.MenuUIDto {
+	var root []*dto.MenuUIDto
+	for _, item := range data {
+		if item.ParentID == parentID {
+			if item.IsList {
+				temp := &dto.MenuUIDto{
+					ID:       strings.ToLower(item.Url),
+					Title:    item.DisplayName,
+					Icon:     item.Avatar,
+					Type:     1,
+					OpenType: "_iframe",
+					Href:     item.Url,
+				}
+				root = append(root, temp)
+			} else {
+				temp := &dto.MenuUIDto{
+					ID:    strconv.Itoa(int(item.ID)),
+					Title: item.DisplayName,
+					Icon:  item.Avatar,
+					Type:  0,
+				}
+				temp.Children = convertToUITree(data, item.ID)
+				root = append(root, temp)
+			}
+		}
+	}
+	return root
+}
+
+func uniqueSysMenus(sm []*db.SysMenu) []*db.SysMenu {
+	res := make([]*db.SysMenu, 0) // 返回的新切片
+	m1 := make(map[int32]byte)    // 用来去重的临时map
+	for _, v := range sm {
+		if _, ok := m1[v.ID]; !ok {
+			m1[v.ID] = 1
+			res = append(res, v)
+		}
+	}
+	return res
+}
+
+func ToTreeMenu(ctx context.Context, id int, hasRoot bool) ([]*dto.TreeDto, error) {
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if hasRoot {
+		root := getSysMenuRootParentId(int32(id), all)
+		if root == nil {
+			root = &dto.TreeDto{
+				ID:    0,
+				Title: "根节点",
+			}
+		}
+
+		root.Children = toDtoTreeSysMenu(int32(id), all)
+		return []*dto.TreeDto{root}, nil
+	}
+
+	return toDtoTreeSysMenu(int32(id), all), nil
+}
+
+func RefreshMenus(ctx context.Context) error {
+	key := keys.GetManageKey(ctx, keys.AllMenus)
+	all, err := db.Engine.AllSysMenu(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func getSysMenuRootParentId(parentId int32, data []*db.SysMenu) *dto.TreeDto {
+	for _, v := range data {
+		if v.ID == parentId {
+			return &dto.TreeDto{
+				ID:    int(v.ID),
+				Title: v.Name,
+			}
+		}
+	}
+	return nil
+}
+
+func toTreeSysMenu(parentId int32, data []*db.SysMenu) []*db.SysMenuDto {
+	var res []*db.SysMenuDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := db.SysMenuDto{}
+			item.ID = v.ID
+			item.Name = v.Name
+			item.DisplayName = v.DisplayName
+			item.Url = v.Url
+			item.Type = v.Type
+			item.ParentID = v.ParentID
+			item.ParentPath = v.ParentPath
+			item.Avatar = v.Avatar
+			item.Style = v.Style
+			item.Visible = v.Visible
+			item.IsList = v.IsList
+			item.Status = v.Status
+			item.Sort = v.Sort
+			item.CreatedAt = v.CreatedAt
+			item.UpdatedAt = v.UpdatedAt
+			item.Children = toTreeSysMenu(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func toDtoTreeSysMenu(parentId int32, data []*db.SysMenu) []*dto.TreeDto {
+	var res []*dto.TreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.TreeDto{}
+			item.ID = int(v.ID)
+			item.Title = v.Name
+			item.Children = toDtoTreeSysMenu(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func SetMenuViewData(ctx context.Context, roleID int32) ([]*dto.SetMenuDto, error) {
+	// 获取该用户已经有的权限
+	hs, err := db.Engine.ListSysMenuIDByRoleID(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toSetMenuTree(all, hs, 0), nil
+}
+
+func toSetMenuTree(data []*db.SysMenu, ids []int32, parentID int32) []*dto.SetMenuDto {
+	var res []*dto.SetMenuDto
+	for _, v := range data {
+		if v.ParentID == parentID {
+			isSelect := hasValueInArray(ids, v.ID)
+			if v.IsList {
+				item := dto.SetMenuDto{
+					ID:       v.ID,
+					Name:     v.DisplayName,
+					Link:     v.Type,
+					IsList:   v.IsList,
+					IsSelect: isSelect,
+				}
+				item.Items = []*dto.SetMenuDto{
+					{
+						ID:       v.ID,
+						Name:     "列表",
+						Link:     "btn",
+						IsList:   false,
+						IsSelect: isSelect,
+						Items:    toSetMenuTree(data, ids, v.ID),
+					},
+				}
+				item.Items = append(item.Items, toSetMenuTree(data, ids, v.ID)...)
+				res = append(res, &item)
+			} else {
+				item := dto.SetMenuDto{
+					ID:       v.ID,
+					Name:     v.DisplayName,
+					Link:     v.Type,
+					IsList:   v.IsList,
+					IsSelect: isSelect,
+					Items:    toSetMenuTree(data, ids, v.ID),
+				}
+				res = append(res, &item)
+			}
+		}
+	}
+
+	return res
+}
+
+func hasValueInArray(data []int32, id int32) bool {
+	for _, v := range data {
+		if id == v {
+			return true
+		}
+	}
+	return false
+}

internal/service/system/sys_role.go

@@ -0,0 +1,165 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysRole(ctx context.Context, arg *db.CreateSysRoleParams) (*db.SysRole, error) {
+	return db.Engine.CreateSysRole(ctx, arg)
+}
+
+func UpdateSysRole(ctx context.Context, arg *db.UpdateSysRoleParams) (*db.SysRole, error) {
+	return db.Engine.UpdateSysRole(ctx, arg)
+}
+
+func GetSysRole(ctx context.Context, id int32) (*db.SysRole, error) {
+	return db.Engine.GetSysRole(ctx, id)
+}
+
+func ListSysRoleCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysRole, int64, error) {
+	countArg := &db.CountSysRoleConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+	}
+
+	dataArg := &db.ListSysRoleConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
+		Size:       int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "id":
+			id, err := strconv.Atoi(q.SearchKey)
+			if err == nil {
+				countArg.IsID = true
+				countArg.ID = int32(id)
+
+				dataArg.IsID = true
+				dataArg.ID = int32(id)
+			}
+		case "name":
+			countArg.DisplayName = q.SearchKey
+			dataArg.DisplayName = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysRoleCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	roles, err := db.Engine.ListSysRoleCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return roles, count, nil
+}
+
+func XmSelectSysRole(ctx context.Context) ([]*dto.XmSelectDto, error) {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []*dto.XmSelectDto
+	for _, item := range all {
+		res = append(res, &dto.XmSelectDto{Name: item.DisplayName, Value: int(item.ID)})
+	}
+
+	return res, nil
+}
+
+func SetMenu(ctx context.Context, roleID int32, menus []*db.SysMenu) error {
+	return db.Engine.ExecTx(ctx, func(q *db.Queries) error {
+		err := db.Engine.DeleteRoleMneuByRoleID(ctx, roleID)
+		if err != nil {
+			return err
+		}
+
+		for _, m := range menus {
+			err := db.Engine.CreateRoleMenu(ctx, &db.CreateRoleMenuParams{
+				RoleID: roleID,
+				MenuID: m.ID,
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func DTreeSysRole(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDtreeSysRole(id, all), nil
+}
+
+func RefreshSysRole(ctx context.Context) error {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AllRoles)
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func RebuildSysRoleParentPath(ctx context.Context) error {
+	return db.Engine.SysRoleRebuildPath(ctx)
+}
+
+func toDtreeSysRole(parentId int32, data []*db.SysRole) []*dto.DTreeDto {
+	var res []*dto.DTreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.DTreeDto{}
+			item.ID = strconv.FormatInt(int64(v.ID), 10)
+			item.Title = v.DisplayName
+			item.Last = !hasSysRoleChildren(v.ID, data)
+			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
+			item.Children = toDtreeSysRole(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func hasSysRoleChildren(parentId int32, data []*db.SysRole) bool {
+	if len(data) > 0 {
+		for _, v := range data {
+			if v.ParentID == parentId {
+				return true
+			}
+		}
+	}
+
+	return false
+}

internal/service/system/sys_user.go

@@ -0,0 +1,48 @@
+package system
+
+import (
+	"context"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysUser(ctx context.Context, arg *db.CreateSysUserParams) (*db.SysUser, error) {
+	return db.Engine.CreateSysUser(ctx, arg)
+}
+
+func UpdateSysUser(ctx context.Context, arg *db.UpdateSysUserParams) (*db.SysUser, error) {
+	return db.Engine.UpdateSysUser(ctx, arg)
+}
+
+func GetSysUser(ctx context.Context, id int32) (*db.SysUser, error) {
+	return db.Engine.GetSysUser(ctx, id)
+}
+
+func GetSysUserByEmail(ctx context.Context, email string) (*db.SysUser, error) {
+	return db.Engine.GetSysUserByEmail(ctx, email)
+}
+
+func ListSysUserCondition(ctx context.Context, q dto.SearchDto) ([]*db.ListSysUserConditionRow, int64, error) {
+	count, err := db.Engine.CountSysUserCondition(ctx, &db.CountSysUserConditionParams{
+		IsStatus: q.SearchStatus != 9999,
+		Status:   int32(q.SearchStatus),
+		Username: q.SearchKey,
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	users, err := db.Engine.ListSysUserCondition(ctx, &db.ListSysUserConditionParams{
+		IsStatus: q.SearchStatus != 9999,
+		Status:   int32(q.SearchStatus),
+		Username: q.SearchKey,
+		Skip:     (int32(q.Page) - 1) * int32(q.Rows),
+		Size:     int32(q.Rows),
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return users, count, nil
+}

internal/service/system/sys_user_login_log.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysUserLoginLog(ctx context.Context, arg *db.CreateSysUserLoginLogParams) error {
+	return db.Engine.CreateSysUserLoginLog(ctx, arg)
+}
+
+func ListSysUserLoginLog(ctx context.Context, q dto.SearchDto) ([]*db.SysUserLoginLog, int64, error) {
+	start, err := time.ParseInLocation(time.DateTime, q.SearchTimeBegin, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+	end, err := time.ParseInLocation(time.DateTime, q.SearchTimeEnd, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	countArg := &db.CountSysUserLoginLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+	}
+
+	dataArg := &db.ListSysUserLoginLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+		Skip:    (int32(q.Page) - 1) * int32(q.Rows),
+		Size:    int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "email":
+			countArg.Email = q.SearchKey
+			dataArg.Email = q.SearchKey
+		case "username":
+			countArg.Username = q.SearchKey
+			dataArg.Username = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysUserLoginLogCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	logs, err := db.Engine.ListSysUserLoginLogCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return logs, count, nil
+}

internal/service/tencentoss/tencentoss.go

@@ -0,0 +1,162 @@
+package tencentoss
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+
+	"management/internal/config"
+	fileutil "management/internal/pkg/file"
+
+	"github.com/h2non/filetype"
+	"github.com/tencentyun/cos-go-sdk-v5"
+)
+
+var engine *cos.Client
+
+func Init() error {
+	u, err := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", config.File.TencentUpload.Bucket, config.File.TencentUpload.Region))
+	if err != nil {
+		return err
+	}
+
+	b := &cos.BaseURL{BucketURL: u}
+	engine = cos.NewClient(b, &http.Client{
+		Transport: &cos.AuthorizationTransport{
+			// 通过环境变量获取密钥
+			// 环境变量 SECRETID 表示用户的 SecretId，登录访问管理控制台查看密钥，https://console.cloud.tencent.com/cam/capi
+			SecretID: config.File.TencentUpload.AccessKeyID, // 用户的 SecretId，建议使用子账号密钥，授权遵循最小权限指引，降低使用风险。子账号密钥获取可参见 https://cloud.tencent.com/document/product/598/37140
+			// 环境变量 SECRETKEY 表示用户的 SecretKey，登录访问管理控制台查看密钥，https://console.cloud.tencent.com/cam/capi
+			SecretKey: config.File.TencentUpload.AccessKeySecret, // 用户的 SecretKey，建议使用子账号密钥，授权遵循最小权限指引，降低使用风险。子账号密钥获取可参见 https://cloud.tencent.com/document/product/598/37140
+		},
+	})
+
+	return nil
+}
+
+func UploadFile(ctx context.Context, file *multipart.FileHeader, t fileutil.FileType) (string, error) {
+	if file.Size > config.File.TencentUpload.AllowFileMaxSize {
+		return "", errors.New("failed to receive file too large")
+	}
+
+	fileOpen, err := file.Open()
+	if err != nil {
+		return "", errors.New("failed to file open")
+	}
+	defer func(fileOpen multipart.File) {
+		_ = fileOpen.Close()
+	}(fileOpen)
+
+	fileBytes, err := io.ReadAll(fileOpen)
+	if err != nil {
+		return "", errors.New("failed to read file")
+	}
+
+	if t == fileutil.IMG {
+		// 判断是不是图片
+		if !filetype.IsImage(fileBytes) {
+			return "", fileutil.ErrUnsupported
+		}
+	}
+
+	kind, err := filetype.Match(fileBytes)
+	if err != nil || kind == filetype.Unknown {
+		return "", errors.New("failed to get file type")
+	}
+
+	filename := fileutil.GenFilename(kind.Extension)
+	imgPath := path.Join(fileutil.GetPath(), filename)
+	_, err = engine.Object.Put(ctx, imgPath, bytes.NewReader(fileBytes), nil)
+	if err != nil {
+		return "", err
+	}
+
+	return imgPath, nil
+}
+
+func UploadFileOther(ctx context.Context, p string, t fileutil.FileType) (string, error) {
+	file, err := os.Open(p)
+	if err != nil {
+		return "", err
+	}
+	defer func(file *os.File) {
+		_ = file.Close()
+	}(file)
+
+	fileBytes, err := io.ReadAll(file)
+	if err != nil {
+		return "", errors.New("failed to read file")
+	}
+
+	if t == fileutil.IMG {
+		// 判断是不是图片
+		if !filetype.IsImage(fileBytes) {
+			return "", fileutil.ErrUnsupported
+		}
+	}
+
+	kind, err := filetype.Match(fileBytes)
+	if err != nil || kind == filetype.Unknown {
+		return "", errors.New("failed to get file type")
+	}
+
+	filename := fileutil.GenFilename(kind.Extension)
+	imgPath := path.Join(fileutil.GetPath(), filename)
+	_, err = engine.Object.Put(ctx, imgPath, bytes.NewReader(fileBytes), nil)
+	if err != nil {
+		return "", err
+	}
+
+	return imgPath, nil
+}
+
+func UploadFileByFS(ctx context.Context, file fs.File, t fileutil.FileType) (string, error) {
+	fileBytes, err := io.ReadAll(file)
+	if err != nil {
+		return "", errors.New("failed to read file")
+	}
+
+	if t == fileutil.IMG {
+		// 判断是不是图片
+		if !filetype.IsImage(fileBytes) {
+			return "", fileutil.ErrUnsupported
+		}
+	}
+
+	kind, err := filetype.Match(fileBytes)
+	if err != nil || kind == filetype.Unknown {
+		return "", errors.New("failed to get file type")
+	}
+
+	filename := fileutil.GenFilename(kind.Extension)
+	imgPath := path.Join(fileutil.GetPath(), filename)
+	_, err = engine.Object.Put(ctx, imgPath, bytes.NewReader(fileBytes), nil)
+	if err != nil {
+		return "", err
+	}
+
+	return imgPath, nil
+}
+
+func DownloadFile(ctx context.Context, name string) ([]byte, error) {
+	resp, err := engine.Object.Get(ctx, name, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	bs, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return bs, nil
+}