批量优化

This commit is contained in:
hero920103 committed 2026-10-03 23:46:55 +08:00
1 parent e3db229f41
commit aa92ca40a2
79 files changed
+7495 -1104

No files matched your search

+416
View File
@@ -0,0 +1,416 @@
package controllers
import (
"errors"
"sort"
"strings"
"time"
"server/models"
"server/pkg/jwtutil"
"server/services"
beego "github.com/beego/beego/v2/server/web"
)
// =============================================================
// 移动端「工作台」聚合接口
//
// uniapp 首页改造成 ERP/OA/CRM/CMS 聚合平台后,首屏需要一次性拿到三组数据:
// 1. 应用模块卡片(yz_system_modules + 租户套餐开通状态)
// 2. 当前登录用户可见的菜单(yz_system_menu,按角色过滤 + 套餐锁定标记)
// 3. 首页 KPI(待办日程 / 逾期 / 笔记 / 站内信未读 / 报销在途)
//
// Web 端分别由 /backend/modules/getTenantList、/backend/menu/:id、各 dashboard
// 提供,但都要求 user_type=backend,移动端令牌调不到。这里复用同一套 service
// 逻辑,仅把 user_type 放宽到 app,并聚合成一次请求以减少移动端首屏往返。
//
// ID 口径(与既有 /app/* 接口保持一致,勿混用):
// - 业务表的 user_id = 令牌里的 identity_id(claims.UserID)
// - 老表 yz_system_tenant_user.uid = services.ResolveTenantUID(tid, claims.UserID)
// =============================================================
var (
errNotLogin = errors.New("未登录")
errAuthFormat = errors.New("认证信息格式错误")
errTokenInvalid = errors.New("无效的token")
errNoPermission = errors.New("无权访问")
)
// AppAggregateController 移动端工作台聚合
type AppAggregateController struct {
beego.Controller
}
// appMenuItem 菜单扁平项。
// 移动端要按 path 前缀把菜单归到各应用模块下(与套餐鉴权 ownerModuleCode 同源逻辑),
// 树形在前端分组不便,扁平 + parent_id 更适合「应用详情」页渲染二级列表。
type appMenuItem struct {
ID uint64 `json:"id"`
Pid int64 `json:"pid"`
Title string `json:"title"`
Path string `json:"path,omitempty"`
Icon string `json:"icon,omitempty"`
Type int8 `json:"type"`
Sort int64 `json:"sort"`
Module string `json:"module"` // 归属模块 code(crm/erp/oa/cms/ai),公共菜单为空
Locked bool `json:"locked"` // true = 不在租户套餐内,前端置灰并引导升级
Leaf bool `json:"leaf"` // true = 叶子菜单(无下级),可直接跳转
Docs int `json:"docs,omitempty"` // 该节点下可见的子菜单数量
}
func (c *AppAggregateController) serveJSON(data map[string]interface{}) {
c.Data["json"] = data
_ = c.ServeJSON()
}
func (c *AppAggregateController) fail(msg string) {
c.Ctx.Output.SetStatus(401)
c.serveJSON(map[string]interface{}{"code": 401, "msg": msg})
}
// appClaims 校验 Bearer 令牌,允许 backend / app 两种身份
func (c *AppAggregateController) appClaims() (*jwtutil.Claims, error) {
auth := c.Ctx.Request.Header.Get("Authorization")
if auth == "" {
return nil, errNotLogin
}
parts := strings.SplitN(auth, " ", 2)
if len(parts) != 2 || parts[0] != "Bearer" {
return nil, errAuthFormat
}
claims, err := jwtutil.ParseToken(parts[1])
if err != nil {
return nil, errTokenInvalid
}
if claims.UserType != "backend" && claims.UserType != "app" {
return nil, errNoPermission
}
return claims, nil
}
// appModuleItem 模块卡片:在模块基础信息上标注当前租户是否已开通
type appModuleItem struct {
models.SystemModules
Enabled bool `json:"enabled"`
Locked bool `json:"locked"`
Menus int `json:"menus"` // 该模块下当前用户可见的菜单数
}
// Home GET /app/home
//
// 一次返回工作台首屏所需的全部数据:
//
// { user:{...}, modules:[...], menus:[...], stats:{todo,overdue,note,message,reimburse} }
func (c *AppAggregateController) Home() {
claims, err := c.appClaims()
if err != nil {
c.fail(err.Error())
return
}
tid := uint64(claims.TenantId)
uid := services.ResolveTenantUID(tid, uint64(claims.UserID))
modules := c.appModules(tid)
menus := c.appMenus(uid, tid)
// 把每个模块下可见的菜单数回填到卡片上,端上决定是否显示「N 个功能」
menuCount := map[string]int{}
for _, m := range menus {
if m.Module != "" {
menuCount[m.Module]++
}
}
for i := range modules {
modules[i].Menus = menuCount[services.NormalizeModuleCode(modules[i].Code)]
}
c.serveJSON(map[string]interface{}{
"code": 200,
"msg": "success",
"data": map[string]interface{}{
"user": c.appUser(claims, uid, tid),
"modules": modules,
"menus": menus,
"stats": c.appStats(claims, tid),
},
})
}
// appUser 当前登录用户的展示信息(含企业名,供首页问候语使用)
func (c *AppAggregateController) appUser(claims *jwtutil.Claims, uid, tid uint64) map[string]interface{} {
out := map[string]interface{}{
"uid": uid,
"tid": tid,
"name": "用户",
"account": "",
"role_name": "",
"tenant": "",
"tenant_id": tid,
"avatar": "",
}
if claims.Username != "" {
out["name"] = claims.Username
}
var tu models.SystemTenantUser
if models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("uid", uid).Filter("tid", tid).One(&tu) == nil {
if tu.Name != nil && strings.TrimSpace(*tu.Name) != "" {
out["name"] = strings.TrimSpace(*tu.Name)
}
if tu.Account != nil && strings.TrimSpace(*tu.Account) != "" {
out["account"] = strings.TrimSpace(*tu.Account)
}
if tu.GroupID > 0 {
var role models.AdminRole
if models.Orm.QueryTable(new(models.AdminRole)).
Filter("id", tu.GroupID).Filter("cid", 2).One(&role) == nil {
if strings.TrimSpace(role.Name) != "" {
out["role_name"] = strings.TrimSpace(role.Name)
}
}
}
}
var tenant models.SystemTenant
if models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant) == nil {
if strings.TrimSpace(tenant.TenantName) != "" {
out["tenant"] = strings.TrimSpace(tenant.TenantName)
}
}
return out
}
// appModules 模块卡片列表(status=1 且 is_show=1),并标注套餐开通状态与可见菜单数
func (c *AppAggregateController) appModules(tid uint64) []appModuleItem {
var rows []models.SystemModules
if _, err := models.Orm.QueryTable(new(models.SystemModules)).
Filter("delete_time__isnull", true).
Filter("status", 1).
Filter("is_show", 1).
OrderBy("sort", "id").
All(&rows); err != nil {
return []appModuleItem{}
}
// 移动端只展示 app 可见的模块(未配置 platforms 视为全端)
rows = services.FilterModulesByPlatform(rows, models.PlatformApp)
allowed := services.GetTenantModuleCodes(tid)
out := make([]appModuleItem, 0, len(rows))
for _, m := range rows {
enabled := true
if len(allowed) > 0 {
enabled = allowed[services.NormalizeModuleCode(m.Code)]
}
out = append(out, appModuleItem{
SystemModules: m,
Enabled: enabled,
Locked: !enabled,
})
}
return out
}
// appMenus 当前用户可见的租户端菜单(扁平 + 模块归属 + 套餐锁定标记)
func (c *AppAggregateController) appMenus(uid, tid uint64) []appMenuItem {
var rows []models.SystemMenu
if _, err := models.Orm.QueryTable(new(models.SystemMenu)).
Filter("status", 1).All(&rows); err != nil {
return []appMenuItem{}
}
menus := filterMenusByView(rows, 2)
// 角色权限过滤:rights 为空视为全权限(与 Web 端口径一致)
if uid > 0 {
var tu models.SystemTenantUser
if models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("uid", uid).Filter("tid", tid).One(&tu) == nil && tu.GroupID > 0 {
var role models.AdminRole
if models.Orm.QueryTable(new(models.AdminRole)).
Filter("id", tu.GroupID).Filter("cid", 2).One(&role) == nil {
menus = filterMenusByRights(menus, role.Rights)
}
}
}
// 套餐未开通的菜单保留但标记 locked,前端置灰并引导升级
menus, lockedIDs := filterMenusByTenantPackageLocked("", menus, tid, true)
// 归属计算必须用「全部模块」而非仅启用的模块:
// 系统设置类模块(basicSettings/systemManager/moduleshop,type=2)默认不启用,
// 若只用启用模块,它们的菜单会全部落到"无归属"被误吸进协作工具区;
// 同理已停用模块的残留菜单也应当归属回自己的模块,由前端按 enabled 决定是否展示。
allModules := c.allModules()
// 第一遍:按展示端筛出本端可见菜单(is_visible=0 的也不下发)。
// 必须先筛再统计子节点,否则会出现「父节点非叶子但零个可见子项」的死路。
// 按展示端筛选:菜单自身未配置时继承所属模块
sortedModules := services.SortedModulesForScope(allModules)
visible := make([]models.SystemMenu, 0, len(menus))
for _, m := range menus {
if m.IsVisible != nil && *m.IsVisible == 0 {
continue
}
if !services.MenuVisibleOn(m, sortedModules, allModules, models.PlatformApp) {
continue
}
visible = append(visible, m)
}
// 第二遍:统计本端可见子节点数量,用于区分「目录」与「可跳转页面」
childCount := map[int64]int{}
for _, m := range visible {
if m.Pid != 0 {
childCount[m.Pid]++
}
}
out := make([]appMenuItem, 0, len(visible))
for _, m := range visible {
item := appMenuItem{
ID: m.ID,
Pid: m.Pid,
Type: m.Type,
Sort: m.Sort,
Title: strings.TrimSpace(m.Title),
}
if m.Path != nil {
item.Path = strings.TrimSpace(*m.Path)
}
if m.Icon != nil {
item.Icon = strings.TrimSpace(*m.Icon)
}
if lockedIDs != nil {
item.Locked = lockedIDs[m.ID]
}
item.Module = appModuleCodeOfPath(item.Path, allModules)
item.Leaf = childCount[int64(m.ID)] == 0
item.Docs = childCount[int64(m.ID)]
out = append(out, item)
}
sort.SliceStable(out, func(i, j int) bool { return out[i].Sort < out[j].Sort })
return out
}
// pathOf 取菜单路径(空指针安全)
func pathOf(m models.SystemMenu) string {
if m.Path == nil {
return ""
}
return strings.TrimSpace(*m.Path)
}
// appModuleCodeOfPath 判断菜单归属哪个功能模块。
// 与 services.ownerModuleCode 同规则(长路径优先,避免 /apps 吞掉 /apps/erp),
// 区别是自行排序以避免依赖 services 包的内部实现。
func appModuleCodeOfPath(path string, allModules []models.SystemModules) string {
p := strings.TrimSuffix(strings.TrimSpace(path), "/")
if p == "" {
return ""
}
sorted := make([]models.SystemModules, len(allModules))
copy(sorted, allModules)
sort.SliceStable(sorted, func(i, j int) bool {
return len(sorted[i].Path) > len(sorted[j].Path)
})
for _, m := range sorted {
mp := strings.TrimSuffix(strings.TrimSpace(m.Path), "/")
if mp == "" {
continue
}
if p == mp || strings.HasPrefix(p, mp+"/") {
return services.NormalizeModuleCode(m.Code)
}
}
return ""
}
// allModules 读取全部未删除模块(含停用 / type=2 系统设置),仅用于菜单归属计算。
func (c *AppAggregateController) allModules() []models.SystemModules {
var rows []models.SystemModules
if _, err := models.Orm.QueryTable(new(models.SystemModules)).
Filter("delete_time__isnull", true).
OrderBy("sort", "id").
All(&rows); err != nil {
return nil
}
return rows
}
// appStats 首页 KPI。任一子查询失败都降级为 0,不影响其它指标。
func (c *AppAggregateController) appStats(claims *jwtutil.Claims, tid uint64) map[string]interface{} {
uid := claims.UserID
now := time.Now()
today := now.Format("2006-01-02")
// 待办日程 / 逾期:日程是否完成由提醒任务的 remind_status 决定(与 /app/schedule/list 同口径)
todo, overdue := 0, 0
{
var rows []models.BackendSchedule
if _, err := models.Orm.QueryTable(new(models.BackendSchedule)).
Filter("user_id", uid).Filter("tid", claims.TenantId).
OrderBy("-id").Limit(500).All(&rows); err == nil {
for _, s := range rows {
var reminders []models.BackendScheduleReminder
if _, e := models.Orm.QueryTable(new(models.BackendScheduleReminder)).
Filter("schedule_id", s.ID).Filter("is_deleted", 0).
All(&reminders); e != nil {
continue
}
if len(reminders) == 0 {
todo++
if s.ScheduleTime.Format("2006-01-02") < today {
overdue++
}
continue
}
done := true
for _, r := range reminders {
if r.RemindStatus != 2 {
done = false
break
}
}
if !done {
todo++
if s.ScheduleTime.Format("2006-01-02") < today {
overdue++
}
}
}
}
}
// 笔记
note := 0
{
cnt, _ := models.Orm.QueryTable(new(models.BackendNotebook)).
Filter("user_id", uid).Filter("is_deleted", 0).Count()
note = int(cnt)
}
// 站内信未读(receiver_type=tenant,与 /backend/sitereminder/myList 同口径)
message := 0
{
cnt, _ := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("receiver_id", uid).Filter("receiver_type", "tenant").
Filter("is_read", 0).Filter("delete_time__isnull", true).Count()
message = int(cnt)
}
// 报销在途(status=1 审批中)
reimburse := 0
{
cnt, _ := models.Orm.QueryTable(new(models.BackendReimbursement)).
Filter("user_id", uid).Filter("tid", tid).
Filter("is_deleted", 0).Filter("status", 1).Count()
reimburse = int(cnt)
}
return map[string]interface{}{
"todo": todo,
"overdue": overdue,
"note": note,
"message": message,
"reimburse": reimburse,
}
}
+243
View File
@@ -0,0 +1,243 @@
package auth
import (
"encoding/json"
"fmt"
"io"
"strings"
"time"
"server/models"
"server/pkg/jwtutil"
authsvc "server/services/auth"
beego "github.com/beego/beego/v2/server/web"
)
// =============================================================
// 移动端免登录票据(把移动端登录态桥接到 Web 端)
//
// POST /auth/app-ticket 移动端带 Bearer 令牌 → 签发一次性票据
// POST /auth/app-ticket/exchange Web 端带票据 → 核销并换发 Web 端令牌
//
// 仅用于「移动端已登录 → 打开 Web 端功能页」这一条链路,
// 票据一次性 + 60 秒有效,泄露也无法二次使用。
// =============================================================
// AuthAppTicketController 移动端免登录票据
type AuthAppTicketController struct {
beego.Controller
}
func (c *AuthAppTicketController) serveJSON(data map[string]interface{}) {
c.Data["json"] = data
_ = c.ServeJSON()
}
func (c *AuthAppTicketController) fail(msg string) {
c.Ctx.Output.SetStatus(400)
c.serveJSON(map[string]interface{}{"code": 400, "msg": msg})
}
// ticketClaims 解析 Bearer 令牌;移动端是 user_type=app,Web 端是 backend
func (c *AuthAppTicketController) ticketClaims() (*jwtutil.Claims, error) {
header := c.Ctx.Request.Header.Get("Authorization")
if header == "" {
return nil, fmt.Errorf("未登录")
}
parts := strings.SplitN(header, " ", 2)
if len(parts) != 2 || parts[0] != "Bearer" {
return nil, fmt.Errorf("认证信息格式错误")
}
claims, err := jwtutil.ParseToken(parts[1])
if err != nil {
return nil, fmt.Errorf("无效的token")
}
if claims.UserType != "app" && claims.UserType != "backend" {
return nil, fmt.Errorf("无权访问")
}
return claims, nil
}
// Create POST /auth/app-ticket
// 移动端用当前登录态换取一次性票据,Web 端拿票据换自己的令牌。
func (c *AuthAppTicketController) Create() {
claims, err := c.ticketClaims()
if err != nil {
c.Ctx.Output.SetStatus(401)
c.serveJSON(map[string]interface{}{"code": 401, "msg": err.Error()})
return
}
var req struct {
ClientID string `json:"client_id"`
}
if body := c.Ctx.Input.RequestBody; len(body) > 0 {
_ = json.Unmarshal(body, &req)
}
// 票据是给 Web 端兑换用的,默认按 Web 端应用签发
clientID := strings.TrimSpace(req.ClientID)
if clientID == "" {
clientID = "yz-backend"
}
tid := uint64(0)
if claims.TenantId > 0 {
tid = uint64(claims.TenantId)
}
ticket, err := authsvc.CreateAppTicket(uint64(claims.UserID), tid, clientID)
if err != nil {
c.fail("签发票据失败:" + err.Error())
return
}
c.serveJSON(map[string]interface{}{
"code": 200,
"msg": "success",
"data": map[string]interface{}{
"ticket": ticket,
"expire_in": int(authsvc.AppTicketTTL / time.Second),
},
})
}
// Exchange POST /auth/app-ticket/exchange
// Web 端核销票据并换发本端令牌(无鉴权:票据本身即凭证,一次性 + 短时效)。
func (c *AuthAppTicketController) Exchange() {
body := c.Ctx.Input.RequestBody
if len(body) == 0 {
body, _ = io.ReadAll(c.Ctx.Request.Body)
}
var req struct {
Ticket string `json:"ticket"`
Token string `json:"token"` // 兼容 mp-login 的命名
ClientID string `json:"client_id"`
}
if err := json.Unmarshal(body, &req); err != nil {
c.fail("参数错误")
return
}
ticket := strings.TrimSpace(req.Ticket)
if ticket == "" {
ticket = strings.TrimSpace(req.Token)
}
row, err := authsvc.ConsumeAppTicket(ticket)
if err != nil {
c.fail(err.Error())
return
}
// 身份校验:禁用/锁定的账号不签发
var identity models.AuthIdentity
if err := models.Orm.QueryTable(new(models.AuthIdentity)).
Filter("id", row.IdentityID).
Filter("delete_time__isnull", true).
One(&identity); err != nil {
c.fail("账号不存在或已注销")
return
}
if identity.Status != models.AuthIdentityStatusEnabled {
c.fail("账号已被禁用或锁定,无法登录")
return
}
username := "云泽用户"
if identity.Nickname != nil && strings.TrimSpace(*identity.Nickname) != "" {
username = strings.TrimSpace(*identity.Nickname)
}
clientID := strings.TrimSpace(req.ClientID)
if clientID == "" {
clientID = row.ClientID
}
if clientID == "" {
clientID = "yz-backend"
}
// 未确定企业(多企业)时签发待选令牌,由 Web 端展示企业选择
tid := row.Tid
needChoose := false
if tid == 0 {
tenants, lerr := authsvc.ListTenantOptions(row.IdentityID)
if lerr != nil || len(tenants) == 0 {
c.fail("该账号未加入任何企业,无法登录")
return
}
if len(tenants) == 1 {
tid = tenants[0].Tid
} else {
tid = authsvc.PendingTenantID
needChoose = true
}
}
tokens, terr := c.issueTicketTokens(row.IdentityID, tid, clientID, username, needChoose)
if terr != nil {
c.fail(terr.Error())
return
}
data := map[string]interface{}{
"type": "backend",
"tokens": tokens,
"tid": tid,
}
if needChoose {
tenants, _ := authsvc.ListTenantOptions(row.IdentityID)
data["need_choose_tenant"] = true
data["tenants"] = tenants
}
c.serveJSON(map[string]interface{}{"code": 200, "msg": "登录成功", "data": data})
}
// issueTicketTokens 建会话 + 签发令牌 + 登录日志(失败不影响主流程)
func (c *AuthAppTicketController) issueTicketTokens(identityID, tid uint64, clientID, username string, needChoose bool) (*authsvc.TokenPair, error) {
accessTTL := 0
if needChoose {
accessTTL = 600 // 待选状态令牌只够用户完成企业选择
}
sess, serr := authsvc.CreateSession(authsvc.SessionInfo{
IdentityID: identityID,
Tid: tid,
ClientID: clientID,
IP: c.Ctx.Input.IP(),
UserAgent: c.Ctx.Request.UserAgent(),
LoginType: "app_ticket",
Amr: "app_ticket",
})
if serr != nil {
return nil, fmt.Errorf("登录失败:%s", serr.Error())
}
tokens, terr := authsvc.IssueTokens(authsvc.TokenIssue{
IdentityID: identityID,
Tid: tid,
ClientID: clientID,
Sid: sess.Sid,
Username: username,
UserType: "backend", // Web 端业务接口普遍要求 backend
Amr: "app_ticket",
AccessTTL: accessTTL,
})
if terr != nil {
return nil, fmt.Errorf("签发令牌失败:%s", terr.Error())
}
identityIDCopy := identityID
tidCopy := tid
amr := "app_ticket"
_, _ = models.Orm.Insert(&models.AuthLoginLog{
Tid: &tidCopy,
IdentityID: &identityIDCopy,
UserName: username,
ClientID: clientID,
LoginType: "app_ticket",
Amr: &amr,
Status: 1,
Message: "移动端票据免登录",
IP: c.Ctx.Input.IP(),
UserAgent: c.Ctx.Request.UserAgent(),
})
return tokens, nil
}
+11 -1
View File
@@ -132,11 +132,14 @@ func (c *AuthLoginController) LoginSubmit() {
setSessionCookieForCtx(c.Ctx, result.Tokens.Sid)
if result.NeedChooseTenant {
// 待选令牌必须一并下发:APP / 小程序等无 Cookie 环境的客户端
// 只能靠 Bearer 令牌调 /auth/switch-tenant,浏览器端则继续用 yz_sid Cookie。
c.serveJSON(map[string]interface{}{
"code": 200,
"msg": "请选择要进入的企业",
"need_choose_tenant": true,
"tenants": result.Tenants,
"tokens": result.Tokens,
"sid": result.Tokens.Sid,
})
return
@@ -170,12 +173,16 @@ func (c *AuthLoginController) Tenants() {
}
// SwitchTenant 免密切换企业
// POST /auth/switch-tenant { tid, client_id, redirect }
// POST /auth/switch-tenant { tid, client_id, redirect, sid }
//
// sid 来源优先级:yz_sid Cookie → Authorization Bearer 令牌中的 sid → 请求体 sid。
// 请求体 sid 供无 Cookie 能力(且尚未拿到 Bearer 令牌)的客户端兜底。
func (c *AuthLoginController) SwitchTenant() {
var req struct {
Tid uint64 `json:"tid"`
ClientID string `json:"client_id"`
Redirect string `json:"redirect"`
Sid string `json:"sid"`
}
body := c.Ctx.Input.RequestBody
if len(body) == 0 {
@@ -189,6 +196,9 @@ func (c *AuthLoginController) SwitchTenant() {
sid = claims.Sid
}
}
if sid == "" {
sid = strings.TrimSpace(req.Sid)
}
if sid == "" || req.Tid == 0 {
c.serveJSON(map[string]interface{}{"code": 400, "msg": "参数错误"})
return
+309
View File
@@ -0,0 +1,309 @@
package auth
import (
"encoding/json"
"io"
"strings"
"server/models"
authsvc "server/services/auth"
"server/services/wechatmini"
"github.com/beego/beego/v2/client/orm"
beego "github.com/beego/beego/v2/server/web"
"github.com/beego/beego/v2/core/logs"
)
// 小程序登录失败原因(前端按此分支给出不同引导)
const (
MiniReasonNotConfigured = "not_configured" // 服务端未配置小程序
MiniReasonIdentityNotFound = "identity_not_found" // 微信未匹配到云泽账号
MiniReasonNoTenant = "no_tenant" // 账号未加入任何企业
MiniReasonWechatAPI = "wechat_api_error" // 微信接口报错
)
// idPWechatMini 第三方身份源标识(写入 yz_auth_identity_third.provider)
const idPWechatMini = "wechat_mini"
// AuthWechatMiniController 微信小程序一键登录(统一认证中心)
//
// 与公众号确认链接登录(/api/wechat/mp/login)不同,小程序端由前端直接
// 携带 wx.login 的 code 与 getPhoneNumber 的动态 code 兑换登录态:
//
// POST /auth/wechat/miniapp/login
// { "code": "wx.login的code", "phone_code": "getPhoneNumber的动态code", "client_id": "yz-miniapp" }
//
// 返回结构与 POST /auth/login 完全一致(tokens / need_choose_tenant / tenants 均在顶层),
// 前端可复用同一套「写入令牌 → 选企业 → switch-tenant」流程。
type AuthWechatMiniController struct {
beego.Controller
}
func (c *AuthWechatMiniController) serveJSON(data map[string]interface{}) {
c.Data["json"] = data
_ = c.ServeJSON()
}
func (c *AuthWechatMiniController) fail(reason string, bizCode int, msg string) {
c.Ctx.Output.SetStatus(400)
c.serveJSON(map[string]interface{}{"code": bizCode, "msg": msg, "reason": reason})
}
// Config 小程序登录是否可用
// GET /auth/wechat/miniapp/config
func (c *AuthWechatMiniController) Config() {
cfg, err := wechatmini.LoadEnabledConfig()
if err != nil {
c.serveJSON(map[string]interface{}{
"code": 200,
"data": map[string]interface{}{"enabled": false, "auto_bind": false},
})
return
}
c.serveJSON(map[string]interface{}{
"code": 200,
"data": map[string]interface{}{"enabled": true, "auto_bind": cfg.AutoBind},
})
}
// Login 小程序一键登录
func (c *AuthWechatMiniController) Login() {
var req struct {
Code string `json:"code"`
PhoneCode string `json:"phone_code"`
ClientID string `json:"client_id"`
}
body := c.Ctx.Input.RequestBody
if len(body) == 0 {
body, _ = io.ReadAll(c.Ctx.Request.Body)
}
if err := json.Unmarshal(body, &req); err != nil {
c.fail("", 400, "参数错误")
return
}
req.Code = strings.TrimSpace(req.Code)
req.PhoneCode = strings.TrimSpace(req.PhoneCode)
req.ClientID = strings.TrimSpace(req.ClientID)
if req.ClientID == "" {
req.ClientID = "yz-miniapp"
}
if req.Code == "" {
c.fail("", 400, "缺少登录凭证,请重新进入小程序")
return
}
cfg, err := wechatmini.LoadEnabledConfig()
if err != nil {
c.fail(MiniReasonNotConfigured, 400, "小程序登录未开通,请使用账号密码登录")
return
}
// code → openid / unionid
session, err := wechatmini.Code2Session(cfg, req.Code)
if err != nil {
msg := err.Error()
if hint, ok := wechatmini.ExplainError(err); ok {
msg = hint
}
logs.Warn("[wechat-mini] code 换取 openid 失败: %v", err)
c.fail(MiniReasonWechatAPI, 400, msg)
return
}
// 定位云泽身份:手机号优先(已通过微信验证),其次查已绑定的小程序 openid
var mobile string
if req.PhoneCode != "" {
phone, perr := wechatmini.GetPhoneNumber(cfg, req.PhoneCode)
if perr != nil {
// 手机号能力未开通 / code 失效时不阻断:仍尝试按已绑定 openid 登录
logs.Warn("[wechat-mini] 获取手机号失败: %v", perr)
} else {
mobile = strings.TrimSpace(phone.PurePhoneNumber)
if mobile == "" {
mobile = strings.TrimSpace(phone.PhoneNumber)
}
}
}
identity, err := c.resolveIdentity(cfg, mobile, session)
if err != nil {
c.fail(MiniReasonIdentityNotFound, 404, "该微信未绑定云泽账号,请使用手机号一键登录或先注册")
return
}
if identity.Status != models.AuthIdentityStatusEnabled {
c.fail("", 403, "账号已被禁用或锁定,无法登录")
return
}
// 企业选择:单企业直接进入,多企业签发待选令牌由前端展示选择界面
tenants, lerr := authsvc.ListTenantOptions(identity.ID)
if lerr != nil || len(tenants) == 0 {
c.fail(MiniReasonNoTenant, 403, "该账号未加入任何企业,请联系管理员")
return
}
tid := uint64(0)
needChoose := false
if len(tenants) == 1 {
tid = tenants[0].Tid
} else {
tid = authsvc.PendingTenantID
needChoose = true
}
username := "微信用户"
if identity.Nickname != nil && strings.TrimSpace(*identity.Nickname) != "" {
username = strings.TrimSpace(*identity.Nickname)
} else if identity.Mobile != nil && *identity.Mobile != "" {
username = *identity.Mobile
}
tokens, terr := c.issueTokens(identity.ID, tid, req.ClientID, username, needChoose)
if terr != nil {
c.fail("", 400, terr.Error())
return
}
resp := map[string]interface{}{
"code": 200,
"msg": "登录成功",
"tokens": tokens,
"tenants": tenants,
"identity": map[string]interface{}{"id": identity.ID, "nickname": username, "mobile": mobileOr(identity)},
}
if needChoose {
resp["need_choose_tenant"] = true
resp["sid"] = tokens.Sid
}
c.serveJSON(resp)
}
// resolveIdentity 定位身份并维护小程序绑定关系。
// mobile 非空表示本次已通过微信手机号验证,是可信的强证据,优先采用。
func (c *AuthWechatMiniController) resolveIdentity(cfg *wechatmini.Config, mobile string, session *wechatmini.Session) (*models.AuthIdentity, error) {
// 1) 手机号命中身份(手机号已由微信验证,属于当前用户的强凭证)
if mobile != "" {
if identity, err := authsvc.FindIdentityByAccount(mobile); err == nil {
c.syncBinding(cfg, identity.ID, session, true)
return identity, nil
}
}
// 2) 已绑定过该小程序 openid / unionid
bind := findMiniBinding(session.OpenID, session.UnionID)
if bind == nil {
return nil, orm.ErrNoRows
}
var identity models.AuthIdentity
if err := models.Orm.QueryTable(new(models.AuthIdentity)).
Filter("id", bind.IdentityID).
Filter("delete_time__isnull", true).
One(&identity); err != nil {
return nil, err
}
return &identity, nil
}
// syncBinding 把当前小程序 openid 绑定到该身份。
// verified 表示本次带通过了微信手机号验证:此时手机号即身份凭证,
// 允许覆盖历史绑定(用户换绑手机号 / 换微信号场景);
// 未验证时只允许「新增绑定」,不抢占已绑定到其他身份的 openid。
func (c *AuthWechatMiniController) syncBinding(cfg *wechatmini.Config, identityID uint64, session *wechatmini.Session, verified bool) {
bind := findMiniBinding(session.OpenID, session.UnionID)
if bind != nil && bind.IdentityID == identityID {
return
}
if bind != nil {
if !verified {
return
}
_, _ = models.Orm.QueryTable(new(models.AuthIdentityThird)).Filter("id", bind.ID).Delete()
}
if !verified && !cfg.AutoBind {
return
}
item := &models.AuthIdentityThird{
IdentityID: identityID,
Provider: idPWechatMini,
OpenID: session.OpenID,
}
if session.UnionID != "" {
uid := session.UnionID
item.UnionID = &uid
}
_, _ = models.Orm.Insert(item)
}
// findMiniBinding 按 openid 查绑定,其次按 unionid 查
func findMiniBinding(openID, unionID string) *models.AuthIdentityThird {
qs := models.Orm.QueryTable(new(models.AuthIdentityThird)).Filter("provider", idPWechatMini)
if openID != "" {
var bind models.AuthIdentityThird
if err := qs.Filter("open_id", openID).One(&bind); err == nil {
return &bind
}
}
if unionID != "" {
var bind models.AuthIdentityThird
if err := qs.Filter("union_id", unionID).One(&bind); err == nil {
return &bind
}
}
return nil
}
// issueTokens 建会话并签发 UAC 令牌(含登录日志,失败不影响主流程)
func (c *AuthWechatMiniController) issueTokens(identityID, tid uint64, clientID, username string, needChoose bool) (*authsvc.TokenPair, error) {
accessTTL := 0
if needChoose {
accessTTL = 600 // 待选状态令牌只够用户完成企业选择
}
sess, serr := authsvc.CreateSession(authsvc.SessionInfo{
IdentityID: identityID,
Tid: tid,
ClientID: clientID,
IP: c.Ctx.Input.IP(),
UserAgent: c.Ctx.Request.UserAgent(),
LoginType: "wechat_mini",
Amr: "wechat_mini",
})
if serr != nil {
return nil, serr
}
tokens, terr := authsvc.IssueTokens(authsvc.TokenIssue{
IdentityID: identityID,
Tid: tid,
ClientID: clientID,
Sid: sess.Sid,
Username: username,
UserType: "app",
Amr: "wechat_mini",
AccessTTL: accessTTL,
})
if terr != nil {
return nil, terr
}
identityIDCopy := identityID
tidCopy := tid
amr := "wechat_mini"
_, _ = models.Orm.Insert(&models.AuthLoginLog{
Tid: &tidCopy,
IdentityID: &identityIDCopy,
UserName: username,
ClientID: clientID,
LoginType: "wechat_mini",
Amr: &amr,
Status: 1,
Message: "微信小程序一键登录成功",
IP: c.Ctx.Input.IP(),
UserAgent: c.Ctx.Request.UserAgent(),
})
return tokens, nil
}
func mobileOr(identity *models.AuthIdentity) string {
if identity != nil && identity.Mobile != nil {
return *identity.Mobile
}
return ""
}
+21 -12
View File
@@ -18,17 +18,18 @@ type BackendMenuController struct {
type AdminMenuController = BackendMenuController
type menuPayload struct {
Pid *int64 `json:"pid"`
Title *string `json:"title"`
Path *string `json:"path"`
ComponentPath *string `json:"component_path"`
Icon *string `json:"icon"`
Sort *int64 `json:"sort"`
Status *int8 `json:"status"`
IsVisible *int8 `json:"is_visible"`
Views []int `json:"views"`
Type *int8 `json:"type"`
Permission *string `json:"permission"`
Pid *int64 `json:"pid"`
Title *string `json:"title"`
Path *string `json:"path"`
ComponentPath *string `json:"component_path"`
Icon *string `json:"icon"`
Sort *int64 `json:"sort"`
Status *int8 `json:"status"`
IsVisible *int8 `json:"is_visible"`
Views []int `json:"views"`
Platforms []string `json:"platforms"` // 展示端:["web"] ["app"] ["web","app"];空=继承所属模块
Type *int8 `json:"type"`
Permission *string `json:"permission"`
}
func parseViews(raw *string) []int {
@@ -86,7 +87,10 @@ func (c *BackendMenuController) GetBackendMenu() {
_ = c.ServeJSON()
return
}
backendMenus := filterMenusByView(menus, 2)
// 先按 views 过滤租户端,再按展示端过滤出 Web 端可见菜单。
// 菜单未单独配置 platforms 时继承所属模块,因此要传入全部模块。
allModules, _ := services.ListAllModulesForScope()
backendMenus := services.FilterMenusByPlatformWithModules(filterMenusByView(menus, 2), allModules, models.PlatformWeb)
// 按当前登录用户角色过滤可见功能菜单:
// 角色 rights 为空(或未分配角色)→ 全权限,返回全部后端菜单;
@@ -375,6 +379,7 @@ type menuNode struct {
Status int8 `json:"status"`
IsVisible *int8 `json:"is_visible,omitempty"`
Views []int `json:"views,omitempty"`
Platforms []string `json:"platforms,omitempty"` // 展示端,空=继承所属模块
Type int8 `json:"type"`
Permission string `json:"permission,omitempty"`
Locked bool `json:"locked,omitempty"`
@@ -393,6 +398,7 @@ func buildMenuTree(menus []models.SystemMenu, pid int64) []*menuNode {
Status: m.Status,
IsVisible: m.IsVisible,
Views: parseViews(m.Views),
Platforms: services.ParsePlatforms(m.Platforms),
Type: m.Type,
}
if m.Path != nil {
@@ -469,6 +475,8 @@ func (c *BackendMenuController) CreateMenu() {
ComponentPath: ptrString(valueString(payload.ComponentPath, "")),
Icon: ptrString(valueString(payload.Icon, "")),
Permission: ptrString(valueString(payload.Permission, "")),
// 空串表示「继承所属模块的展示端」(模块也未配置则全端)
Platforms: ptrString(services.NormalizePlatforms(payload.Platforms)),
}
id, err := models.Orm.Insert(&menu)
@@ -510,6 +518,7 @@ func (c *BackendMenuController) UpdateMenu() {
"status": valueInt8(payload.Status, 1),
"is_visible": valueInt8(payload.IsVisible, 1),
"views": string(viewsBytes),
"platforms": services.NormalizePlatforms(payload.Platforms),
"type": valueInt8(payload.Type, 1),
"permission": valueString(payload.Permission, ""),
}
+2
View File
@@ -75,6 +75,8 @@ func (c *BackendModulesController) GetTenantList() {
c.jsonErr(500, 500, "获取失败:"+err.Error())
return
}
// 租户后台是 Web 端:只保留 web 可见的模块(未配置视为全端)
rows = services.FilterModulesByPlatform(rows, models.PlatformWeb)
// 查询当前租户已开通的模块 code 集合(套餐模块 + 已开通产品订单关联模块,编码已规范化)
tid := uint64(claims.TenantId)
+74 -12
View File
@@ -10,10 +10,39 @@ import (
"server/models"
"server/pkg/jwtutil"
"server/services"
beego "github.com/beego/beego/v2/server/web"
)
// validatePlatforms 校验展示端取值,返回空串表示合法。
// 只允许 web / app,避免出现拼错的值导致菜单在某端永远不可见。
func validatePlatforms(list []string) string {
for _, s := range list {
switch strings.ToLower(strings.TrimSpace(s)) {
case models.PlatformWeb, models.PlatformApp:
default:
if strings.TrimSpace(s) == "" {
continue
}
return "展示端取值非法,仅支持 web(Web端)与 app(移动端)"
}
}
return ""
}
// platformList 把模块展示端配置输出给管理端:统一返回数组,空配置回落为全端
func platformList(m *models.SystemModules) []string {
if m == nil {
return []string{models.PlatformWeb, models.PlatformApp}
}
list := services.ParsePlatforms(m.Platforms)
if len(list) == 0 {
return []string{models.PlatformWeb, models.PlatformApp}
}
return list
}
// PlatformModulesController 模块管理(yz_system_modules)
type PlatformModulesController struct {
beego.Controller
@@ -70,12 +99,30 @@ func (c *PlatformModulesController) GetList() {
c.jsonErr(500, 500, "获取失败:"+err.Error())
return
}
// 展示端统一以数组形式下发(空配置回落为全端),方便管理端回填多选框
list := make([]map[string]interface{}, 0, len(rows))
for i := range rows {
list = append(list, map[string]interface{}{
"id": rows[i].ID,
"mid": rows[i].Mid,
"name": rows[i].Name,
"code": rows[i].Code,
"path": rows[i].Path,
"icon": rows[i].Icon,
"description": rows[i].Description,
"type": rows[i].Type,
"sort": rows[i].Sort,
"status": rows[i].Status,
"is_show": rows[i].IsShow,
"platforms": platformList(&rows[i]),
})
}
c.Data["json"] = map[string]interface{}{
"code": 200,
"msg": "获取成功",
"data": map[string]interface{}{
"list": rows,
"total": len(rows),
"list": list,
"total": len(list),
},
}
_ = c.ServeJSON()
@@ -136,16 +183,17 @@ func (c *PlatformModulesController) GetDetail() {
}
type modulePayload struct {
Mid *uint64 `json:"mid"`
Name string `json:"name"`
Code string `json:"code"`
Path string `json:"path"`
Icon string `json:"icon"`
Description string `json:"description"`
Type int `json:"type"`
Sort int `json:"sort"`
Status int8 `json:"status"`
IsShow int8 `json:"is_show"`
Mid *uint64 `json:"mid"`
Name string `json:"name"`
Code string `json:"code"`
Path string `json:"path"`
Icon string `json:"icon"`
Description string `json:"description"`
Type int `json:"type"`
Sort int `json:"sort"`
Status int8 `json:"status"`
IsShow int8 `json:"is_show"`
Platforms []string `json:"platforms"` // 展示端:["web"] ["app"] ["web","app"];空=全端
}
// Add POST /platform/modules
@@ -164,6 +212,10 @@ func (c *PlatformModulesController) Add() {
c.jsonErr(400, 400, "参数错误")
return
}
if errMsg := validatePlatforms(p.Platforms); errMsg != "" {
c.jsonErr(400, 400, errMsg)
return
}
p.Name = strings.TrimSpace(p.Name)
p.Code = strings.TrimSpace(p.Code)
if p.Name == "" || p.Code == "" {
@@ -180,6 +232,7 @@ func (c *PlatformModulesController) Add() {
return
}
now := time.Now()
platforms := services.NormalizePlatforms(p.Platforms)
row := &models.SystemModules{
Mid: p.Mid,
Name: p.Name,
@@ -194,6 +247,9 @@ func (c *PlatformModulesController) Add() {
CreateTime: &now,
UpdateTime: &now,
}
if platforms != "" {
row.Platforms = &platforms
}
id, err := models.Orm.Insert(row)
if err != nil {
c.jsonErr(500, 500, "添加失败:"+err.Error())
@@ -231,6 +287,10 @@ func (c *PlatformModulesController) Edit() {
c.jsonErr(400, 400, "模块名称和编码不能为空")
return
}
if errMsg := validatePlatforms(p.Platforms); errMsg != "" {
c.jsonErr(400, 400, errMsg)
return
}
// code 唯一(排除自身与软删)
cnt, _ := models.Orm.QueryTable(new(models.SystemModules)).
Filter("code", p.Code).
@@ -242,6 +302,7 @@ func (c *PlatformModulesController) Edit() {
return
}
now := time.Now()
// 展示端为空串表示「全端」,需显式落库以覆盖历史值
up := map[string]interface{}{
"mid": p.Mid,
"name": p.Name,
@@ -253,6 +314,7 @@ func (c *PlatformModulesController) Edit() {
"sort": p.Sort,
"status": p.Status,
"is_show": p.IsShow,
"platforms": services.NormalizePlatforms(p.Platforms),
"update_time": now,
}
n, err := models.Orm.QueryTable(new(models.SystemModules)).
+131
View File
@@ -0,0 +1,131 @@
package controllers
import (
"encoding/json"
"fmt"
"io"
"strings"
"server/pkg/jwtutil"
"server/services/wechatmp"
"server/services/wechatmini"
beego "github.com/beego/beego/v2/server/web"
)
// =============================================================
// 平台端「微信小程序」配置:AppID / AppSecret / 启用开关 / 自动绑定
//
// 配置就绪后,uniapp 小程序端的登录页才会展示「微信手机号一键登录」入口
// (GET /auth/wechat/miniapp/config 返回 enabled)。
// AppSecret 掩码回显,提交空串或掩码表示不修改。
// =============================================================
// PlatformWechatMiniController 平台端微信小程序配置
type PlatformWechatMiniController struct {
beego.Controller
}
func (c *PlatformWechatMiniController) claims() (*jwtutil.Claims, error) {
auth := c.Ctx.Request.Header.Get("Authorization")
if auth == "" {
return nil, fmt.Errorf("未登录")
}
parts := strings.SplitN(auth, " ", 2)
if len(parts) != 2 || parts[0] != "Bearer" {
return nil, fmt.Errorf("认证信息格式错误")
}
claims, err := jwtutil.ParseToken(parts[1])
if err != nil {
return nil, fmt.Errorf("无效的token")
}
if claims.UserType != "platform" {
return nil, fmt.Errorf("无权访问")
}
return claims, nil
}
func (c *PlatformWechatMiniController) jsonErr(httpStatus, bizCode int, msg string) {
c.Ctx.Output.SetStatus(httpStatus)
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
_ = c.ServeJSON()
}
func (c *PlatformWechatMiniController) ok(data interface{}, msg string) {
if msg == "" {
msg = "success"
}
resp := map[string]interface{}{"code": 200, "msg": msg}
if data != nil {
resp["data"] = data
}
c.Data["json"] = resp
_ = c.ServeJSON()
}
// GetConfig GET /platform/wechatMini/config
func (c *PlatformWechatMiniController) GetConfig() {
if _, err := c.claims(); err != nil {
c.jsonErr(401, 401, err.Error())
return
}
data := map[string]interface{}{
"app_id": "",
"app_secret": "",
"enabled": 0,
"auto_bind": 1,
"remark": "",
"configured": false,
}
if cfg, err := wechatmini.LoadConfig(); err == nil {
data["app_id"] = cfg.AppID
data["app_secret"] = wechatmp.MaskSecret(cfg.AppSecret)
data["remark"] = cfg.Remark
data["configured"] = cfg.AppID != "" && cfg.AppSecret != ""
if cfg.Enabled {
data["enabled"] = 1
}
if cfg.AutoBind {
data["auto_bind"] = 1
} else {
data["auto_bind"] = 0
}
}
c.ok(data, "获取成功")
}
// SaveConfig POST /platform/wechatMini/config
func (c *PlatformWechatMiniController) SaveConfig() {
if _, err := c.claims(); err != nil {
c.jsonErr(401, 401, err.Error())
return
}
var p struct {
AppID string `json:"app_id"`
AppSecret string `json:"app_secret"`
Enabled int `json:"enabled"`
AutoBind int `json:"auto_bind"`
Remark string `json:"remark"`
}
raw, err := io.ReadAll(c.Ctx.Request.Body)
if err != nil {
c.jsonErr(400, 400, "参数错误")
return
}
if err := json.Unmarshal(raw, &p); err != nil {
c.jsonErr(400, 400, "参数错误")
return
}
if err := wechatmini.SaveConfig(wechatmini.SaveInput{
AppID: p.AppID,
AppSecret: p.AppSecret,
Enabled: p.Enabled == 1,
AutoBind: p.AutoBind == 1,
Remark: p.Remark,
}); err != nil {
c.jsonErr(400, 400, err.Error())
return
}
c.ok(nil, "保存成功")
}