790 lines
19 KiB
Go
790 lines
19 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"server/models"
|
|
"server/pkg/identity"
|
|
"server/pkg/passwordutil"
|
|
"server/services"
|
|
authsvc "server/services/auth"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
type BackendAdminUserController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
type backendUserInfoDTO struct {
|
|
ID uint64 `json:"id"`
|
|
Tid uint64 `json:"tid"`
|
|
Uid uint64 `json:"uid"`
|
|
GroupID uint64 `json:"group_id"`
|
|
Account *string `json:"account"`
|
|
Name *string `json:"name"`
|
|
Phone *string `json:"phone"`
|
|
Email *string `json:"email"`
|
|
Avatar *string `json:"avatar"`
|
|
Sex uint8 `json:"sex"`
|
|
Birth *string `json:"birth"`
|
|
IsDefault int8 `json:"is_default"`
|
|
Status int8 `json:"status"`
|
|
Remark *string `json:"remark"`
|
|
CreateTime string `json:"create_time"`
|
|
UpdateTime *string `json:"update_time"`
|
|
TenantName string `json:"tenant_name"`
|
|
TenantCode string `json:"tenant_code"`
|
|
}
|
|
|
|
type backendTenantUserPayload struct {
|
|
Tid uint64 `json:"tid"`
|
|
Uid uint64 `json:"uid"`
|
|
GroupID *uint64 `json:"group_id"`
|
|
Account *string `json:"account"`
|
|
Name *string `json:"name"`
|
|
Phone *string `json:"phone"`
|
|
Email *string `json:"email"`
|
|
Sex *uint8 `json:"sex"`
|
|
Birth *string `json:"birth"`
|
|
Password *string `json:"password"`
|
|
IsDefault *int8 `json:"is_default"`
|
|
Status *int8 `json:"status"`
|
|
Remark *string `json:"remark"`
|
|
IdentityID uint64 `json:"identity_id"`
|
|
VerifyPassword string `json:"verify_password"`
|
|
}
|
|
|
|
type backendChangePasswordPayload struct {
|
|
ID uint64 `json:"id"`
|
|
Password string `json:"password"`
|
|
By string `json:"by"`
|
|
}
|
|
|
|
func formatBackendBirth(birth *string) *string {
|
|
if birth == nil {
|
|
return nil
|
|
}
|
|
|
|
s := strings.TrimSpace(*birth)
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
|
|
if len(s) >= 10 {
|
|
date := s[:10]
|
|
return &date
|
|
}
|
|
|
|
return &s
|
|
}
|
|
|
|
func toBackendUserInfoDTO(u models.SystemTenantUser) backendUserInfoDTO {
|
|
var updateTime *string
|
|
if u.UpdateTime != nil {
|
|
s := u.UpdateTime.Format("2006-01-02 15:04:05")
|
|
updateTime = &s
|
|
}
|
|
|
|
tenantName := "未知租户"
|
|
tenantCode := ""
|
|
|
|
tenant, err := services.GetTenantByID(u.Tid)
|
|
if err == nil && tenant != nil {
|
|
tenantName = tenant.TenantName
|
|
tenantCode = tenant.TenantCode
|
|
}
|
|
|
|
var avatar *string
|
|
if a := services.GetIdentityAvatar(u.Uid); a != "" {
|
|
avatar = &a
|
|
}
|
|
|
|
return backendUserInfoDTO{
|
|
ID: u.ID,
|
|
Tid: u.Tid,
|
|
Uid: u.Uid,
|
|
GroupID: u.GroupID,
|
|
Account: u.Account,
|
|
Name: u.Name,
|
|
Phone: u.Phone,
|
|
Email: u.Email,
|
|
Avatar: avatar,
|
|
Sex: u.Sex,
|
|
Birth: formatBackendBirth(u.Birth),
|
|
IsDefault: u.IsDefault,
|
|
Status: u.Status,
|
|
Remark: u.Remark,
|
|
CreateTime: u.CreateTime.Format("2006-01-02 15:04:05"),
|
|
UpdateTime: updateTime,
|
|
TenantName: tenantName,
|
|
TenantCode: tenantCode,
|
|
}
|
|
}
|
|
|
|
func (c *BackendAdminUserController) requireBackendIdentity() (uint64, uint64, bool) {
|
|
claims, err := identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndBackend)
|
|
if err != nil {
|
|
code := identity.Status(err)
|
|
c.Data["json"] = map[string]interface{}{"code": code, "msg": err.Error()}
|
|
_ = c.ServeJSON()
|
|
return 0, 0, false
|
|
}
|
|
if claims.TenantId <= 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 403, "msg": "登录态未绑定企业"}
|
|
_ = c.ServeJSON()
|
|
return 0, 0, false
|
|
}
|
|
return uint64(claims.UserID), uint64(claims.TenantId), true
|
|
}
|
|
|
|
func (c *BackendAdminUserController) parseTenantUserPayload() (backendTenantUserPayload, bool) {
|
|
var p backendTenantUserPayload
|
|
|
|
raw, _ := io.ReadAll(c.Ctx.Request.Body)
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "参数错误"}
|
|
_ = c.ServeJSON()
|
|
return backendTenantUserPayload{}, false
|
|
}
|
|
|
|
return p, true
|
|
}
|
|
|
|
func findBackendTenantUser(idOrUid uint64, jwtTid uint64, byID bool) (*models.SystemTenantUser, error) {
|
|
if idOrUid == 0 {
|
|
return nil, errors.New("用户ID不能为空")
|
|
}
|
|
|
|
base := func() orm.QuerySeter {
|
|
qs := models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("delete_time__isnull", true)
|
|
if jwtTid > 0 {
|
|
qs = qs.Filter("tid", jwtTid)
|
|
}
|
|
return qs
|
|
}
|
|
|
|
if byID {
|
|
var row models.SystemTenantUser
|
|
if err := base().Filter("id", idOrUid).One(&row); err != nil {
|
|
return nil, err
|
|
}
|
|
return &row, nil
|
|
}
|
|
|
|
var row models.SystemTenantUser
|
|
if uid := services.ResolveTenantUID(jwtTid, idOrUid); uid > 0 {
|
|
if err := base().Filter("uid", uid).One(&row); err == nil {
|
|
return &row, nil
|
|
}
|
|
}
|
|
|
|
if err := base().Filter("id", idOrUid).One(&row); err == nil {
|
|
return &row, nil
|
|
}
|
|
|
|
err := base().Filter("uid", idOrUid).One(&row)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &row, nil
|
|
}
|
|
|
|
func (c *BackendAdminUserController) SyncTenantUsersToEmployees() {
|
|
_, tid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
if tid == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 403, "msg": "登录态未绑定企业"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
var request struct {
|
|
UserIDs []uint64 `json:"user_ids"`
|
|
}
|
|
body := c.Ctx.Input.RequestBody
|
|
if len(body) == 0 {
|
|
var readErr error
|
|
body, readErr = io.ReadAll(c.Ctx.Request.Body)
|
|
if readErr != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "读取同步请求失败"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
}
|
|
if err := json.Unmarshal(body, &request); err != nil || len(request.UserIDs) == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "请先选择要同步的用户"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
if len(request.UserIDs) > 500 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "单次最多同步500个用户"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
result, err := services.SyncSelectedTenantUsersToEmployees(tid, request.UserIDs)
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "同步失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": result}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) GetAllUsers() {
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
tid := jwtTid
|
|
if tid == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 403, "msg": "登录态未绑定企业"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
cond := orm.NewCondition().And("delete_time__isnull", true).And("tid", tid)
|
|
|
|
if keyword != "" {
|
|
kwCond := orm.NewCondition().
|
|
Or("name__icontains", keyword).
|
|
Or("phone__icontains", keyword).
|
|
Or("email__icontains", keyword).
|
|
Or("account__icontains", keyword)
|
|
cond = cond.AndCond(kwCond)
|
|
}
|
|
|
|
var rows []models.SystemTenantUser
|
|
_, err := models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
SetCond(cond).
|
|
OrderBy("-is_default", "-id").
|
|
All(&rows)
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "查询失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
list := make([]backendUserInfoDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
list = append(list, toBackendUserInfoDTO(row))
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "success",
|
|
"data": map[string]interface{}{
|
|
"list": list,
|
|
"total": len(list),
|
|
},
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) GetTenantUsers() {
|
|
tidStr := c.Ctx.Input.Param(":tid")
|
|
tid, _ := strconv.ParseUint(tidStr, 10, 64)
|
|
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
if jwtTid > 0 {
|
|
tid = jwtTid
|
|
}
|
|
|
|
if tid == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "tid 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
var rows []models.SystemTenantUser
|
|
_, err := models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true).
|
|
OrderBy("-is_default", "-id").
|
|
All(&rows)
|
|
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "查询失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
list := make([]backendUserInfoDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
list = append(list, toBackendUserInfoDTO(row))
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "success",
|
|
"data": map[string]interface{}{
|
|
"list": list,
|
|
"total": len(list),
|
|
},
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) GetUserInfo() {
|
|
jwtUid, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
|
|
byID := c.GetString("by") == "id"
|
|
|
|
if id == 0 && !byID {
|
|
id = jwtUid
|
|
}
|
|
|
|
if id == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 401, "msg": "未登录或非法请求"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
u, err := findBackendTenantUser(id, jwtTid, byID)
|
|
if err != nil || u == nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 404, "msg": "后台用户信息不存在"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "success",
|
|
"data": toBackendUserInfoDTO(*u),
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) AddUser() {
|
|
p, ok := c.parseTenantUserPayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
if jwtTid > 0 {
|
|
p.Tid = jwtTid
|
|
}
|
|
|
|
if p.Tid == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "tid 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if p.Account == nil || strings.TrimSpace(*p.Account) == "" {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "account 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if p.Password == nil || strings.TrimSpace(*p.Password) == "" {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "password 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
account := strings.TrimSpace(*p.Account)
|
|
p.Account = &account
|
|
|
|
if p.IdentityID > 0 {
|
|
if strings.TrimSpace(p.VerifyPassword) == "" {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "请输入该账号在原企业的登录密码以验证身份"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
ident, err := authsvc.GetIdentityByID(p.IdentityID)
|
|
if err != nil || ident == nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 404, "msg": "认证身份不存在"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
if !authsvc.VerifyIdentityPassword(ident, strings.TrimSpace(p.VerifyPassword)) {
|
|
c.Data["json"] = map[string]interface{}{"code": 401, "msg": "密码不正确,无法确认是同一账号"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
p.Uid = ident.ID
|
|
if ident.PasswordHash != nil && *ident.PasswordHash != "" {
|
|
h := *ident.PasswordHash
|
|
p.Password = &h
|
|
} else {
|
|
hashed, hErr := passwordutil.Hash(strings.TrimSpace(*p.Password))
|
|
if hErr != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": hErr.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
p.Password = &hashed
|
|
}
|
|
} else if p.Uid == 0 {
|
|
if existed, hit := authsvc.LocateIdentityByKey(account, strOrEmpty(p.Phone), strOrEmpty(p.Email)); hit {
|
|
hints := make([]map[string]interface{}, 0)
|
|
if tenants, err := authsvc.ListTenantOptions(existed.ID); err == nil {
|
|
for _, t := range tenants {
|
|
hints = append(hints, map[string]interface{}{"tid": t.Tid, "tenant_name": t.TenantName})
|
|
}
|
|
}
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 409,
|
|
"msg": "该账号已在其他企业存在,请输入原企业登录密码验证身份后绑定本企业",
|
|
"data": map[string]interface{}{
|
|
"need_verify": true,
|
|
"identity_id": existed.ID,
|
|
"tenants": hints,
|
|
},
|
|
}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
hashed, err := passwordutil.Hash(strings.TrimSpace(*p.Password))
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
p.Password = &hashed
|
|
|
|
uid, err := ensureTenantUIDForNewUser(
|
|
p.Tid,
|
|
strOrEmpty(p.Account),
|
|
strOrEmpty(p.Name),
|
|
strOrEmpty(p.Phone),
|
|
strOrEmpty(p.Email),
|
|
strOrEmpty(p.Password),
|
|
)
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "生成用户ID失败"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
p.Uid = uid
|
|
}
|
|
|
|
isDefault := int8(0)
|
|
if p.IsDefault != nil {
|
|
isDefault = *p.IsDefault
|
|
}
|
|
|
|
status := int8(1)
|
|
if p.Status != nil {
|
|
status = *p.Status
|
|
}
|
|
|
|
if check, err := services.CheckTenantUserQuota(p.Tid, p.Uid); err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "用户数校验失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
} else if !check.Allowed {
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 400,
|
|
"msg": fmt.Sprintf("当前租户用户数已达上限(%d/%d),请联系平台管理员增购用户数", check.Used, check.Quota),
|
|
}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
id, err := services.BindTenantUser(
|
|
p.Tid,
|
|
p.Uid,
|
|
p.Account,
|
|
p.Name,
|
|
p.Phone,
|
|
p.Email,
|
|
p.Sex,
|
|
p.Birth,
|
|
p.Password,
|
|
isDefault,
|
|
status,
|
|
p.Remark,
|
|
)
|
|
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "添加失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if isDefault == 1 {
|
|
_ = services.SetDefaultTenant(p.Uid, p.Tid)
|
|
}
|
|
|
|
if p.GroupID != nil && *p.GroupID > 0 {
|
|
_, _ = models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("id", id).
|
|
Update(map[string]interface{}{"group_id": *p.GroupID})
|
|
} else if isDefault == 1 {
|
|
if adminRoleID, err := models.GetTenantAdminRole(); err == nil && adminRoleID > 0 {
|
|
_, _ = models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("id", id).
|
|
Update(map[string]interface{}{"group_id": adminRoleID})
|
|
}
|
|
}
|
|
|
|
var created models.SystemTenantUser
|
|
if e := models.Orm.QueryTable(new(models.SystemTenantUser)).Filter("id", id).One(&created); e == nil {
|
|
syncTenantUserToAuth(&created, false)
|
|
}
|
|
_, _, _ = services.EnsureEmployeeForTenantUser(&created)
|
|
|
|
c.Data["json"] = map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "success",
|
|
"data": map[string]interface{}{"id": id},
|
|
}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) EditUser() {
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
|
|
if id == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "id 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
p, ok := c.parseTenantUserPayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
row, err := findBackendTenantUser(id, jwtTid, c.GetString("by") == "id")
|
|
if err != nil || row == nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 404, "msg": "用户不存在"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
update := map[string]interface{}{}
|
|
|
|
if p.Tid > 0 && jwtTid == 0 {
|
|
update["tid"] = p.Tid
|
|
}
|
|
|
|
if p.Uid > 0 {
|
|
update["uid"] = p.Uid
|
|
}
|
|
|
|
if p.Account != nil {
|
|
account := strings.TrimSpace(*p.Account)
|
|
if account != "" {
|
|
update["account"] = account
|
|
}
|
|
}
|
|
|
|
if p.Name != nil {
|
|
update["name"] = *p.Name
|
|
}
|
|
|
|
if p.Phone != nil {
|
|
update["phone"] = *p.Phone
|
|
}
|
|
|
|
if p.Email != nil {
|
|
update["email"] = *p.Email
|
|
}
|
|
|
|
if p.Sex != nil {
|
|
update["sex"] = *p.Sex
|
|
}
|
|
|
|
if p.Birth != nil {
|
|
birth := strings.TrimSpace(*p.Birth)
|
|
if birth == "" {
|
|
update["birth"] = nil
|
|
} else {
|
|
update["birth"] = birth
|
|
}
|
|
}
|
|
|
|
if p.Password != nil && strings.TrimSpace(*p.Password) != "" {
|
|
hashed, err := passwordutil.Hash(strings.TrimSpace(*p.Password))
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
update["password"] = hashed
|
|
}
|
|
|
|
if p.IsDefault != nil {
|
|
update["is_default"] = *p.IsDefault
|
|
}
|
|
|
|
if p.Status != nil {
|
|
update["status"] = *p.Status
|
|
}
|
|
|
|
if p.Remark != nil {
|
|
update["remark"] = *p.Remark
|
|
}
|
|
|
|
if p.GroupID != nil {
|
|
update["group_id"] = *p.GroupID
|
|
}
|
|
|
|
if len(update) == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "无更新字段"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
_, err = models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("id", row.ID).
|
|
Update(update)
|
|
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "编辑失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if p.IsDefault != nil && *p.IsDefault == 1 {
|
|
_ = services.SetDefaultTenant(row.Uid, row.Tid)
|
|
}
|
|
|
|
var edited models.SystemTenantUser
|
|
if e := models.Orm.QueryTable(new(models.SystemTenantUser)).Filter("id", row.ID).One(&edited); e == nil {
|
|
syncTenantUserToAuth(&edited, false)
|
|
oldAccount := ""
|
|
if row.Account != nil {
|
|
oldAccount = *row.Account
|
|
}
|
|
_ = services.SyncEmployeeOnUserUpdate(row.Tid, oldAccount, &edited)
|
|
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success"}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) DeleteUser() {
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
|
|
if id == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "id 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
row, err := findBackendTenantUser(id, jwtTid, c.GetString("by") == "id")
|
|
if err != nil || row == nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 404, "msg": "用户不存在"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if err := services.UnbindTenantUser(row.ID); err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "删除失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if row.Account != nil {
|
|
_ = services.SyncEmployeeOnUserDelete(row.Tid, *row.Account)
|
|
}
|
|
|
|
removeTenantUserFromAuth(row)
|
|
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success"}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendAdminUserController) ChangePassword() {
|
|
var p backendChangePasswordPayload
|
|
|
|
raw, _ := io.ReadAll(c.Ctx.Request.Body)
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "参数错误"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if p.ID == 0 {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "id 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
if strings.TrimSpace(p.Password) == "" {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": "password 不能为空"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
_, jwtTid, ok := c.requireBackendIdentity()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
row, err := findBackendTenantUser(p.ID, jwtTid, p.By == "id")
|
|
if err != nil || row == nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 404, "msg": "用户不存在"}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
hashed, err := passwordutil.Hash(strings.TrimSpace(p.Password))
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 400, "msg": err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
|
|
_, err = models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("id", row.ID).
|
|
Update(map[string]interface{}{
|
|
"password": hashed,
|
|
})
|
|
|
|
if err != nil {
|
|
c.Data["json"] = map[string]interface{}{"code": 500, "msg": "修改失败: " + err.Error()}
|
|
_ = c.ServeJSON()
|
|
return
|
|
}
|
|
var updated models.SystemTenantUser
|
|
if e := models.Orm.QueryTable(new(models.SystemTenantUser)).Filter("id", row.ID).One(&updated); e == nil {
|
|
syncTenantUserToAuth(&updated, true)
|
|
}
|
|
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "修改成功"}
|
|
_ = c.ServeJSON()
|
|
}
|