projectx/internal/router/manage/system/sys_user.go

package system

import (
	"net/http"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/middleware/manage/auth"
	"management/internal/pkg/crypto"
	"management/internal/pkg/rand"
	"management/internal/router/manage/util"
	systemservice "management/internal/service/system"
	"management/internal/tpl"

	"github.com/google/uuid"
)

type SysUserHandler struct{}

func NewSysUserHandler() *SysUserHandler {
	return &SysUserHandler{}
}

func (h *SysUserHandler) List(w http.ResponseWriter, r *http.Request) {
	tpl.HTML(w, r, "user/list.tmpl", nil)
}

func (h *SysUserHandler) PostList(w http.ResponseWriter, r *http.Request) {
	var q dto.SearchDto
	q.SearchStatus = util.ConvertInt(r.PostFormValue("SearchStatus"), 9999)
	q.SearchName = r.PostFormValue("SearchName")
	q.SearchKey = r.PostFormValue("SearchKey")
	q.Page = util.ConvertInt(r.PostFormValue("page"), 1)
	q.Rows = util.ConvertInt(r.PostFormValue("rows"), 10)
	ctx := r.Context()
	res, count, err := systemservice.ListSysUserCondition(ctx, q)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	data := tpl.ResponseList{
		Code:    0,
		Message: "ok",
		Count:   count,
		Data:    res,
	}
	tpl.JSON(w, data)
}

func (h *SysUserHandler) Add(w http.ResponseWriter, r *http.Request) {
	tpl.HTML(w, r, "user/edit.tmpl", map[string]any{
		"Item": &db.SysUser{
			HashedPassword: nil,
		},
	})
}

func (h *SysUserHandler) Edit(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	id := util.DefaultInt(vars, "id", 0)
	sysUser := &db.SysUser{}
	if id > 0 {
		ctx := r.Context()
		if user, err := systemservice.GetSysUser(ctx, int32(id)); err == nil {
			user.HashedPassword = nil
			sysUser = user
		}
	}
	tpl.HTML(w, r, "user/edit.tmpl", map[string]any{
		"Item": sysUser,
	})
}

func (h *SysUserHandler) Profile(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	user := auth.AuthUser(ctx)
	vm, _ := systemservice.GetSysUser(ctx, user.ID)
	tpl.HTML(w, r, "user/profile.tmpl", map[string]any{
		"Item": vm,
	})
}

func (h *SysUserHandler) Save(w http.ResponseWriter, r *http.Request) {
	id := util.ConvertInt(r.PostFormValue("ID"), 0)
	email := r.PostFormValue("Email")
	username := r.PostFormValue("Username")
	password := r.PostFormValue("Password")
	changePassword := r.PostFormValue("ChangePassword")
	gender := util.ConvertInt(r.PostFormValue("Gender"), 0)
	avatar := r.PostFormValue("File")
	status := util.ConvertInt(r.PostFormValue("Status"), 9999)

	ctx := r.Context()
	departmentID := util.ConvertInt(r.PostFormValue("DepartmentID"), 0)
	var department *db.SysDepartment
	var err error
	if departmentID > 0 {
		department, err = systemservice.GetSysDepartment(ctx, int32(departmentID))
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: "部门数据错误"})
			return
		}
	}
	var role *db.SysRole
	roleID := util.ConvertInt(r.PostFormValue("RoleID"), 0)
	if roleID > 0 {
		role, err = systemservice.GetSysRole(ctx, int32(roleID))
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: "角色数据错误"})
			return
		}
	}

	if id == 0 {
		salt, err := rand.String(10)
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		hashedPassword, err := crypto.BcryptHashPassword(password + salt)
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		initTime, err := time.ParseInLocation(time.DateTime, "0001-01-01 00:00:00", time.Local)
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}
		arg := &db.CreateSysUserParams{
			Uuid:             uuid.Must(uuid.NewV7()),
			Email:            email,
			Username:         username,
			HashedPassword:   hashedPassword,
			Salt:             salt,
			Avatar:           avatar,
			Gender:           int32(gender),
			DepartmentID:     department.ID,
			RoleID:           role.ID,
			Status:           int32(status),
			ChangePasswordAt: initTime,
			CreatedAt:        time.Now(),
			UpdatedAt:        time.Now(),
		}
		_, err = systemservice.CreateSysUser(ctx, arg)
		if err != nil {
			if db.IsUniqueViolation(err) {
				tpl.JSON(w, tpl.Response{Success: false, Message: "数据已存在"})
				return
			}
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		tpl.JSON(w, tpl.Response{Success: true, Message: "添加成功"})
	} else {
		res, err := systemservice.GetSysUser(ctx, int32(id))
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		arg := &db.UpdateSysUserParams{
			ID:               res.ID,
			Username:         username,
			HashedPassword:   res.HashedPassword,
			Avatar:           avatar,
			Gender:           int32(gender),
			DepartmentID:     department.ID,
			RoleID:           role.ID,
			Status:           int32(status),
			ChangePasswordAt: res.ChangePasswordAt,
			UpdatedAt:        time.Now(),
		}
		if changePassword == "on" {
			hashedPassword, err := crypto.BcryptHashPassword(password + res.Salt)
			if err != nil {
				tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
				return
			}
			arg.HashedPassword = hashedPassword
			arg.ChangePasswordAt = time.Now()
		}
		_, err = systemservice.UpdateSysUser(ctx, arg)
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		tpl.JSON(w, tpl.Response{Success: true, Message: "更新成功"})
	}
}

func (h *SysUserHandler) XmSelect(w http.ResponseWriter, r *http.Request) {
	all, err := db.Engine.ListSysUser(r.Context())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	var res []*dto.XmSelectInt32Dto
	for _, v := range all {
		res = append(res, &dto.XmSelectInt32Dto{
			Name:  v.Username,
			Value: v.ID,
		})
	}
	tpl.JSON(w, res)
}