pro/olons_admin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add Go backend

Browse Source
This commit is contained in:
richjohnrambo
2026-10-10 20:56:17 +08:00
parent 50fcfd2d3d
commit f6024f0964
1040 changed files with 107169 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/logic/admin/cash.go
+285
View File
@@ -0,0 +1,285 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/ghttp"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/text/gstr"
"github.com/gogf/gf/v2/util/gconv"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm/hook"
"hotgo/internal/library/location"
"hotgo/internal/model"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
)
type sAdminCash struct{}
func NewAdminCash() *sAdminCash {
return &sAdminCash{}
}
func init() {
service.RegisterAdminCash(NewAdminCash())
}
// View 获取指定提现信息
func (s *sAdminCash) View(ctx context.Context, in *adminin.CashViewInp) (res *adminin.CashViewModel, err error) {
// 这里做了强制限制非超管不允许访问，如果你想通过菜单权限控制，请注释掉以下验证
if !service.AdminMember().VerifySuperId(ctx, contexts.GetUserId(ctx)) {
err = gerror.New("没有访问权限")
return
}
if err = dao.AdminCash.Ctx(ctx).Where(dao.AdminCash.Columns().Id, in.Id).Scan(&res); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if res == nil {
err = gerror.New("提现信息获取失败")
return
}
var mem *entity.AdminMember
err = dao.AdminMember.Ctx(ctx).Where(dao.AdminMember.Columns().Id, res.MemberId).Scan(&mem)
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if !mem.Cash.IsNil() {
if err = mem.Cash.Scan(&res.MemberCash); err != nil {
return
}
}
return
}
// List 获取列表
func (s *sAdminCash) List(ctx context.Context, in *adminin.CashListInp) (list []*adminin.CashListModel, totalCount int, err error) {
var (
mod = dao.AdminCash.Ctx(ctx)
opMemberId = contexts.GetUserId(ctx)
isSuper = service.AdminMember().VerifySuperId(ctx, opMemberId)
)
if in.MemberId > 0 {
mod = mod.Where(dao.AdminCash.Columns().MemberId, in.MemberId)
}
// 用户筛选
if len(in.ComplexMemberId) == 2 && len(in.ComplexMemberId[0]) > 0 {
memberIds, err := service.AdminMember().GetComplexMemberIds(ctx, in.ComplexMemberId[0], in.ComplexMemberId[1])
if err != nil {
return nil, 0, err
}
if len(memberIds) == 0 {
return nil, 0, nil
}
mod = mod.WhereIn(dao.AdminCash.Columns().MemberId, memberIds)
}
if len(in.CreatedAt) == 2 {
mod = mod.WhereBetween(dao.AdminCash.Columns().CreatedAt, gtime.New(in.CreatedAt[0]), gtime.New(in.CreatedAt[1]))
}
// 请求方式
if in.Status > 0 {
mod = mod.Where(dao.AdminCash.Columns().Status, in.Status)
}
if !isSuper {
mod = mod.Where(dao.AdminCash.Columns().MemberId, opMemberId)
}
// 申请人摘要信息
mod = mod.Hook(hook.MemberSummary)
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if totalCount == 0 {
return
}
if err = mod.Page(in.Page, in.PerPage).Order(dao.AdminCash.Columns().Id + " DESC").Scan(&list); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
return
}
// Apply 申请提现
func (s *sAdminCash) Apply(ctx context.Context, in *adminin.CashApplyInp) (err error) {
var (
config *model.CashConfig
member *entity.AdminMember
)
if in.Money <= 0 {
err = gerror.New("请输入提现金额")
return
}
if in.Money != float64(int(in.Money)) {
err = gerror.New("提现金额必须是正整数")
return
}
count, err := dao.AdminCash.Ctx(ctx).
Where(dao.AdminCash.Columns().MemberId, in.MemberId).
Where(dao.AdminCash.Columns().Status, consts.StatusEnabled).
Count()
if err != nil {
return
}
if count > 0 {
err = gerror.New("存在正在处理中的提现，请耐心等待处理后再试！")
return
}
if err = dao.AdminMember.Ctx(ctx).Where(dao.AdminMember.Columns().Id, in.MemberId).Scan(&member); err != nil {
err = gerror.Newf("获取用户信息失败:%+v", err.Error())
return
}
if member == nil {
err = gerror.Newf("获取用户信息失败")
return
}
if member.Balance < in.Money {
err = gerror.Newf("余额不足")
return
}
// 提现信息
var cash adminin.MemberCash
if member.Cash.IsNil() {
err = gerror.Newf("请先设置提现账户！")
return
}
if err = gconv.Scan(member.Cash, &cash); err != nil {
return
}
if cash.Name == "" || cash.Account == "" || cash.PayeeCode == "" {
err = gerror.New("请设置完整的提现账户信息！")
return
}
conf, err := service.SysConfig().GetConfigByGroup(ctx, &sysin.GetConfigInp{Group: "cash"})
if err != nil {
return
}
if err = gconv.Struct(conf.List, &config); err != nil {
return err
}
if !config.Switch {
err = gerror.New("提现通道正在升级维护中，请稍后再试！")
return
}
if in.Money < config.MinMoney {
err = gerror.Newf("单次提现金额不能低于 %v 元", config.MinMoney)
return
}
fee := in.Money * config.MinFeeRatio
if fee < config.MinFee {
fee = config.MinFee
}
lastMoney := in.Money - fee
if lastMoney <= 1 {
err = gerror.Newf("提现金额过少，请增加提现金额！")
return
}
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
// 添加提现记录
lastInsertId, err := dao.AdminCash.Ctx(ctx).Data(g.Map{
dao.AdminCash.Columns().MemberId: in.MemberId,
dao.AdminCash.Columns().Money: in.Money,
dao.AdminCash.Columns().Fee: fee,
dao.AdminCash.Columns().LastMoney: lastMoney,
dao.AdminCash.Columns().CreatedAt: gtime.Now(),
dao.AdminCash.Columns().Status: consts.CashStatusWait,
dao.AdminCash.Columns().Msg: "",
dao.AdminCash.Columns().Ip: location.GetClientIp(ghttp.RequestFromCtx(ctx)),
}).OmitEmptyData().InsertAndGetId()
if err != nil {
return
}
// 更新余额
_, err = service.AdminCreditsLog().SaveBalance(ctx, &adminin.CreditsLogSaveBalanceInp{
MemberId: in.MemberId,
AppId: contexts.GetModule(ctx),
AddonsName: contexts.GetAddonName(ctx),
CreditGroup: consts.CreditGroupApplyCash,
Num: -in.Money,
MapId: lastInsertId,
Remark: "后台申请提现",
})
return
})
if err != nil {
err = gerror.Newf("申请提现失败, %+v", err)
return
}
return
}
// Payment 提现打款处理
func (s *sAdminCash) Payment(ctx context.Context, in *adminin.CashPaymentInp) (err error) {
if !service.AdminMember().VerifySuperId(ctx, contexts.GetUserId(ctx)) {
err = gerror.New("没有访问权限")
return
}
var models *entity.AdminCash
if err = dao.AdminCash.Ctx(ctx).Where(dao.AdminCash.Columns().Id, in.Id).Scan(&models); err != nil {
return
}
if models == nil {
err = gerror.New("未找到提现信息")
return
}
if models.Status == consts.CashStatusOk {
err = gerror.New("该提现已处理成功，不能再次操作！")
return
}
_, err = dao.AdminCash.Ctx(ctx).Where(dao.AdminCash.Columns().Id, models.Id).Data(g.Map{
dao.AdminCash.Columns().HandleAt: gtime.Now(),
dao.AdminCash.Columns().Status: in.Status,
dao.AdminCash.Columns().Msg: gstr.Trim(in.Msg, " "),
}).Update()
return
}
server/internal/logic/admin/credits_log.go
+266
View File
@@ -0,0 +1,266 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.5.3
// @AutoGenerate Date 2023-04-15 15:59:58
package admin
import (
"context"
"fmt"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/library/hgorm/hook"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
"hotgo/utility/convert"
"hotgo/utility/excel"
"hotgo/utility/validate"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/util/gconv"
)
type sAdminCreditsLog struct{}
func NewAdminCreditsLog() *sAdminCreditsLog {
return &sAdminCreditsLog{}
}
func init() {
service.RegisterAdminCreditsLog(NewAdminCreditsLog())
}
// Model 资产变动ORM模型
func (s *sAdminCreditsLog) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
return handler.Model(dao.AdminCreditsLog.Ctx(ctx), option...)
}
// SaveBalance 更新余额
func (s *sAdminCreditsLog) SaveBalance(ctx context.Context, in *adminin.CreditsLogSaveBalanceInp) (res *adminin.CreditsLogSaveBalanceModel, err error) {
if err = validate.PreFilter(ctx, in); err != nil {
return
}
var (
mb *entity.AdminMember
daoMember = dao.AdminMember.Ctx(ctx).Where(dao.AdminMember.Columns().Id, in.MemberId)
data = new(entity.AdminCreditsLog)
)
err = dao.AdminMember.Ctx(ctx).
Fields(dao.AdminMember.Columns().Balance).
Where(dao.AdminMember.Columns().Id, in.MemberId).
Scan(&mb)
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if mb == nil {
err = gerror.New("用户不存在！")
return
}
if in.Num > 0 {
if _, err = daoMember.Increment(dao.AdminMember.Columns().Balance, in.Num); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
} else {
num := in.Num * -1
if mb.Balance < num {
err = gerror.Newf("余额不足，当前余额为：%v，需要扣除的余额为：%v", mb.Balance, num)
return
}
if _, err = daoMember.Decrement(dao.AdminMember.Columns().Balance, num); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
}
data.MemberId = in.MemberId
data.AppId = in.AppId
data.AddonsName = in.AddonsName
data.CreditType = consts.CreditTypeBalance
data.CreditGroup = in.CreditGroup
data.BeforeNum = mb.Balance
data.Num = in.Num
data.AfterNum = mb.Balance + in.Num
data.Remark = in.Remark
data.Ip = in.Ip
data.MapId = in.MapId
_, err = dao.AdminCreditsLog.Ctx(ctx).Data(data).OmitEmptyData().Insert()
return
}
// SaveIntegral 更新积分
func (s *sAdminCreditsLog) SaveIntegral(ctx context.Context, in *adminin.CreditsLogSaveIntegralInp) (res *adminin.CreditsLogSaveIntegralModel, err error) {
if err = validate.PreFilter(ctx, in); err != nil {
return
}
var (
mb *entity.AdminMember
daoMember = dao.AdminMember.Ctx(ctx).Where(dao.AdminMember.Columns().Id, in.MemberId)
data = new(entity.AdminCreditsLog)
)
err = dao.AdminMember.Ctx(ctx).
Fields(dao.AdminMember.Columns().Integral).
Where(dao.AdminMember.Columns().Id, in.MemberId).
Scan(&mb)
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if mb == nil {
err = gerror.New("用户不存在！")
return
}
if in.Num > 0 {
if _, err = daoMember.Increment(dao.AdminMember.Columns().Integral, in.Num); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
} else {
num := in.Num * -1
if mb.Integral < num {
err = gerror.Newf("积分不足，当前积分为：%v，需要扣除的积分为：%v", mb.Integral, num)
return
}
if _, err = daoMember.Decrement(dao.AdminMember.Columns().Integral, num); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
}
data.MemberId = in.MemberId
data.AppId = in.AppId
data.AddonsName = in.AddonsName
data.CreditType = consts.CreditTypeIntegral
data.CreditGroup = in.CreditGroup
data.BeforeNum = mb.Integral
data.Num = in.Num
data.AfterNum = mb.Integral + in.Num
data.Remark = in.Remark
data.Ip = in.Ip
data.MapId = in.MapId
_, err = dao.AdminCreditsLog.Ctx(ctx).Data(data).OmitEmptyData().Insert()
return
}
// List 获取资产变动列表
func (s *sAdminCreditsLog) List(ctx context.Context, in *adminin.CreditsLogListInp) (list []*adminin.CreditsLogListModel, totalCount int, err error) {
mod := s.Model(ctx)
// 查询变动ID
if in.Id > 0 {
mod = mod.Where(dao.AdminCreditsLog.Columns().Id, in.Id)
}
// 查询管理员ID
if in.MemberId > 0 {
mod = mod.Where(dao.AdminCreditsLog.Columns().MemberId, in.MemberId)
}
// 用户筛选
if len(in.ComplexMemberId) == 2 && len(in.ComplexMemberId[0]) > 0 {
memberIds, err := service.AdminMember().GetComplexMemberIds(ctx, in.ComplexMemberId[0], in.ComplexMemberId[1])
if err != nil {
return nil, 0, err
}
if len(memberIds) == 0 {
return nil, 0, nil
}
mod = mod.WhereIn(dao.AdminCreditsLog.Columns().MemberId, memberIds)
}
// 查询应用id
if in.AppId != "" {
mod = mod.WhereLike(dao.AdminCreditsLog.Columns().AppId, in.AppId)
}
// 查询变动类型
if in.CreditType != "" {
mod = mod.WhereLike(dao.AdminCreditsLog.Columns().CreditType, in.CreditType)
}
// 查询变动的组别
if in.CreditGroup != "" {
mod = mod.WhereLike(dao.AdminCreditsLog.Columns().CreditGroup, in.CreditGroup)
}
// 查询备注
if in.Remark != "" {
mod = mod.WhereLike(dao.AdminCreditsLog.Columns().Remark, "%"+in.Remark+"%")
}
// 查询操作人IP
if in.Ip != "" {
mod = mod.WhereLike(dao.AdminCreditsLog.Columns().Ip, in.Ip)
}
// 查询状态
if in.Status > 0 {
mod = mod.Where(dao.AdminCreditsLog.Columns().Status, in.Status)
}
// 查询创建时间
if len(in.CreatedAt) == 2 {
mod = mod.WhereBetween(dao.AdminCreditsLog.Columns().CreatedAt, in.CreatedAt[0], in.CreatedAt[1])
}
// 操作人摘要信息
mod = mod.Hook(hook.MemberSummary)
totalCount, err = mod.Clone().Count()
if err != nil {
return
}
if totalCount == 0 {
return
}
err = mod.Fields(adminin.CreditsLogListModel{}).Page(in.Page, in.PerPage).OrderDesc(dao.AdminCreditsLog.Columns().Id).Scan(&list)
return
}
// Export 导出资产变动
func (s *sAdminCreditsLog) Export(ctx context.Context, in *adminin.CreditsLogListInp) (err error) {
list, totalCount, err := s.List(ctx, in)
if err != nil {
return
}
// 字段的排序是依据tags的字段顺序，如果你不想使用默认的排序方式，可以直接定义 tags = []string{"字段名称", "字段名称2", ...}
tags, err := convert.GetEntityDescTags(adminin.CreditsLogExportModel{})
if err != nil {
return
}
var (
fileName = "导出资产变动-" + gctx.CtxId(ctx)
sheetName = fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, form.CalPageCount(totalCount, in.PerPage), in.Page, len(list))
exports []adminin.CreditsLogExportModel
)
if err = gconv.Scan(list, &exports); err != nil {
return
}
err = excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
return
}
server/internal/logic/admin/dept.go
+349
View File
@@ -0,0 +1,349 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
"hotgo/utility/convert"
"hotgo/utility/tree"
"hotgo/utility/validate"
)
type sAdminDept struct{}
func NewAdminDept() *sAdminDept {
return &sAdminDept{}
}
func init() {
service.RegisterAdminDept(NewAdminDept())
}
// Model 部门ORM模型
func (s *sAdminDept) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
return handler.Model(dao.AdminDept.Ctx(ctx), option...)
}
// Delete 删除
func (s *sAdminDept) Delete(ctx context.Context, in *adminin.DeptDeleteInp) (err error) {
var models *entity.AdminDept
if err = s.Model(ctx).WherePri(in.Id).Scan(&models); err != nil {
return err
}
if models == nil {
return gerror.New("数据不存在或已删除！")
}
pidExist, err := s.Model(ctx).Where(dao.AdminDept.Columns().Pid, models.Id).One()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
if !pidExist.IsEmpty() {
return gerror.New("请先删除该部门下得所有子级！")
}
_, err = s.Model(ctx).WherePri(in.Id).Delete()
return
}
// VerifyUnique 验证部门唯一属性
func (s *sAdminDept) VerifyUnique(ctx context.Context, in *adminin.VerifyUniqueInp) (err error) {
if in.Where == nil {
return
}
cols := dao.AdminDept.Columns()
msgMap := g.MapStrStr{
cols.Name: "部门名称已存在，请换一个",
cols.Code: "部门编码已存在，请换一个",
}
for k, v := range in.Where {
if v == "" {
continue
}
message, ok := msgMap[k]
if !ok {
err = gerror.Newf("字段 [ %v ] 未配置唯一属性验证", k)
return
}
if err = hgorm.IsUnique(ctx, &dao.AdminDept, g.Map{k: v}, message, in.Id); err != nil {
return
}
}
return
}
// Edit 修改/新增
func (s *sAdminDept) Edit(ctx context.Context, in *adminin.DeptEditInp) (err error) {
where := g.Map{
dao.AdminDept.Columns().Name: in.Name,
dao.AdminDept.Columns().Code: in.Code,
}
// 验证唯一性
err = s.VerifyUnique(ctx, &adminin.VerifyUniqueInp{Id: in.Id, Where: where})
if err != nil {
return
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
in.Pid, in.Level, in.Tree, err = hgorm.AutoUpdateTree(ctx, &dao.AdminDept, in.Id, in.Pid)
if err != nil {
return err
}
// 修改
if in.Id > 0 {
if _, err = s.Model(ctx).WherePri(in.Id).Data(in).Update(); err != nil {
err = gerror.Wrap(err, "修改部门管理失败，请稍后重试！")
}
return
}
// 新增
if _, err = s.Model(ctx, &handler.Option{FilterAuth: false}).Data(in).OmitEmptyData().Insert(); err != nil {
err = gerror.Wrap(err, "新增部门管理失败，请稍后重试！")
}
return
})
}
// MaxSort 最大排序
func (s *sAdminDept) MaxSort(ctx context.Context, in *adminin.DeptMaxSortInp) (res *adminin.DeptMaxSortModel, err error) {
if in.Id > 0 {
if err = dao.AdminDept.Ctx(ctx).WherePri(in.Id).OrderDesc(dao.AdminDept.Columns().Sort).Scan(&res); err != nil {
err = gerror.Wrap(err, "获取部门数据异常！")
return
}
}
if res == nil {
res = new(adminin.DeptMaxSortModel)
}
res.Sort = form.DefaultMaxSort(res.Sort)
return
}
// View 获取指定部门信息
func (s *sAdminDept) View(ctx context.Context, in *adminin.DeptViewInp) (res *adminin.DeptViewModel, err error) {
if err = dao.AdminDept.Ctx(ctx).WherePri(in.Id).Scan(&res); err != nil {
err = gerror.Wrap(err, "获取部门信息失败！")
}
return
}
// List 获取列表
func (s *sAdminDept) List(ctx context.Context, in *adminin.DeptListInp) (res *adminin.DeptListModel, err error) {
res = new(adminin.DeptListModel)
var (
mod = dao.AdminDept.Ctx(ctx)
cols = dao.AdminDept.Columns()
)
// 部门名称
if in.Name != "" {
columns, err := dao.AdminDept.Ctx(ctx).Fields(cols.Id).WhereLike(cols.Name, "%"+in.Name+"%").Array()
if err != nil {
err = gerror.Wrap(err, "查询部门名称失败！")
return nil, err
}
if len(columns) == 0 {
return nil, nil
}
res.Ids = append(res.Ids, g.NewVar(columns).Int64s()...)
}
// 部门编码
if in.Code != "" {
columns, err := dao.AdminDept.Ctx(ctx).Fields(cols.Id).WhereLike(cols.Code, "%"+in.Code+"%").Array()
if err != nil {
err = gerror.Wrap(err, "查询部门编码失败！")
return nil, err
}
if len(columns) == 0 {
return nil, nil
}
res.Ids = append(res.Ids, g.NewVar(columns).Int64s()...)
}
// 负责人
if in.Leader != "" {
columns, err := dao.AdminDept.Ctx(ctx).Fields(cols.Id).Where(cols.Leader, in.Leader).Array()
if err != nil {
err = gerror.Wrap(err, "查询负责人失败！")
return nil, err
}
if len(columns) == 0 {
return nil, nil
}
res.Ids = append(res.Ids, g.NewVar(columns).Int64s()...)
}
// 创建时间
if len(in.CreatedAt) == 2 {
columns, err := dao.AdminDept.Ctx(ctx).Fields(cols.Id).WhereBetween(cols.CreatedAt, in.CreatedAt[0], in.CreatedAt[1]).Array()
if err != nil {
err = gerror.Wrap(err, "查询创建时间失败！")
return nil, err
}
if len(columns) == 0 {
return nil, nil
}
res.Ids = append(res.Ids, g.NewVar(columns).Int64s()...)
}
res.Ids = convert.UniqueSlice(res.Ids)
if len(res.Ids) > 0 {
// 找到匹配到的完整上级部门
columns, err := dao.AdminDept.Ctx(ctx).Fields(cols.Tree).WhereIn(cols.Id, res.Ids).Array()
if err != nil {
err = gerror.Wrap(err, "查询部门失败，请稍后重试！")
return nil, err
}
var pids []int64
for _, tr := range g.NewVar(columns).Strings() {
pids = append(pids, tree.GetIds(tr)...)
}
mod = mod.WhereIn(cols.Id, append(res.Ids, convert.UniqueSlice(pids)...))
}
if err = mod.Order("pid asc,sort asc").Scan(&res.List); err != nil {
err = gerror.Wrap(err, "获取部门列表失败！")
return
}
return
}
// GetName 获取部门名称
func (s *sAdminDept) GetName(ctx context.Context, id int64) (name string, err error) {
var data *entity.AdminDept
if err = dao.AdminDept.Ctx(ctx).Where(dao.AdminDept.Columns().Id, id).Fields(dao.AdminDept.Columns().Name).Scan(&data); err != nil {
err = gerror.Wrap(err, "获取部门名称失败！")
return
}
if data == nil {
err = gerror.Wrap(err, "部门不存在！")
return
}
return data.Name, nil
}
// VerifyDeptId 验证部门ID
func (s *sAdminDept) VerifyDeptId(ctx context.Context, id int64) (err error) {
var (
pid int64 = 0
mb = contexts.GetUser(ctx)
mod = dao.AdminDept.Ctx(ctx).Fields(dao.AdminDept.Columns().Id)
)
if mb == nil {
err = gerror.New("用户信息获取失败！")
return
}
// 非超管只获取下级
if !service.AdminMember().VerifySuperId(ctx, mb.Id) {
pid = mb.DeptId
mod = mod.WhereNot(dao.AdminDept.Columns().Id, pid).WhereLike(dao.AdminDept.Columns().Tree, "%"+tree.GetIdLabel(pid)+"%")
}
columns, err := mod.Array()
if err != nil {
return err
}
if !validate.InSlice(g.NewVar(columns).Int64s(), id) {
err = gerror.New("部门ID是无效的")
return
}
return
}
// Option 获取当前登录用户可选的部门选项
func (s *sAdminDept) Option(ctx context.Context, in *adminin.DeptOptionInp) (res *adminin.DeptOptionModel, totalCount int, err error) {
var (
mod = dao.AdminDept.Ctx(ctx)
models []*entity.AdminDept
pid int64 = 0
)
// 非超管只获取下级
if !service.AdminMember().VerifySuperId(ctx, contexts.GetUserId(ctx)) {
pid = contexts.GetUser(ctx).DeptId
mod = mod.WhereLike(dao.AdminDept.Columns().Tree, "%"+tree.GetIdLabel(pid)+"%")
}
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, "获取部门数据行失败！")
return
}
if err = mod.Page(in.Page, in.PerPage).Order("sort asc,id asc").Scan(&models); err != nil {
err = gerror.Wrap(err, "获取部门数据失败！")
return
}
res = new(adminin.DeptOptionModel)
if models != nil {
res.List = s.treeList(pid, models)
}
return
}
// treeList 树状列表
func (s *sAdminDept) treeList(pid int64, nodes []*entity.AdminDept) (list []*adminin.DeptTree) {
list = make([]*adminin.DeptTree, 0)
for _, v := range nodes {
if v.Pid == pid {
item := new(adminin.DeptTree)
item.AdminDept = *v
item.Label = v.Name
item.Value = v.Id
child := s.treeList(v.Id, nodes)
if len(child) > 0 {
item.Children = child
}
list = append(list, item)
}
}
return
}
// TreeOption 获取部门关系树选项
func (s *sAdminDept) TreeOption(ctx context.Context) (nodes []tree.Node, err error) {
var models []*adminin.DeptTreeOption
if err = s.Model(ctx).Fields(adminin.DeptTreeOption{}).OrderAsc(dao.AdminDept.Columns().Pid).OrderAsc(dao.AdminDept.Columns().Sort).OrderDesc(dao.AdminDept.Columns().Id).Scan(&models); err != nil {
err = gerror.Wrap(err, "获取部门关系树选项失败！")
return
}
nodes = make([]tree.Node, len(models))
for i, v := range models {
nodes[i] = v
}
return tree.ListToTree(0, nodes)
}
server/internal/logic/admin/member.go
+914
View File
@@ -0,0 +1,914 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"fmt"
"github.com/gogf/gf/v2/container/gvar"
"github.com/gogf/gf/v2/crypto/gmd5"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/database/gredis"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/text/gstr"
"github.com/gogf/gf/v2/util/gconv"
"github.com/gogf/gf/v2/util/grand"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/global"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/library/hgorm/hook"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
"hotgo/utility/convert"
"hotgo/utility/tree"
"hotgo/utility/validate"
"sync"
)
// SuperAdmin 超级管理员用户
type SuperAdmin struct {
sync.RWMutex
RoleId int64 // 超管角色ID
MemberIds map[int64]struct{} // 超管用户ID
}
type sAdminMember struct {
superAdmin *SuperAdmin
}
func NewAdminMember() *sAdminMember {
return &sAdminMember{
superAdmin: new(SuperAdmin),
}
}
func init() {
service.RegisterAdminMember(NewAdminMember())
}
// AddBalance 增加余额
func (s *sAdminMember) AddBalance(ctx context.Context, in *adminin.MemberAddBalanceInp) (err error) {
var (
mb *entity.AdminMember
memberId = contexts.GetUserId(ctx)
)
if err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
// 更新我的余额
_, err = service.AdminCreditsLog().SaveBalance(ctx, &adminin.CreditsLogSaveBalanceInp{
MemberId: memberId,
AppId: in.AppId,
AddonsName: in.AddonsName,
CreditGroup: in.SelfCreditGroup,
Num: in.SelfNum,
Remark: fmt.Sprintf("为后台用户:%v 操作%v", mb.Id, in.Remark),
})
if err != nil {
return
}
// 更新对方余额
_, err = service.AdminCreditsLog().SaveBalance(ctx, &adminin.CreditsLogSaveBalanceInp{
MemberId: mb.Id,
AppId: in.AppId,
AddonsName: in.AddonsName,
CreditGroup: in.OtherCreditGroup,
Num: in.OtherNum,
Remark: fmt.Sprintf("后台用户:%v 为你操作%v", memberId, in.Remark),
})
return
})
}
// AddIntegral 增加积分
func (s *sAdminMember) AddIntegral(ctx context.Context, in *adminin.MemberAddIntegralInp) (err error) {
var (
mb *entity.AdminMember
memberId = contexts.GetUserId(ctx)
)
if err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
// 更新我的余额
_, err = service.AdminCreditsLog().SaveIntegral(ctx, &adminin.CreditsLogSaveIntegralInp{
MemberId: memberId,
AppId: in.AppId,
AddonsName: in.AddonsName,
CreditGroup: in.SelfCreditGroup,
Num: in.SelfNum,
Remark: fmt.Sprintf("为后台用户:%v 操作%v", mb.Id, in.Remark),
})
if err != nil {
return
}
// 更新对方余额
_, err = service.AdminCreditsLog().SaveIntegral(ctx, &adminin.CreditsLogSaveIntegralInp{
MemberId: mb.Id,
AppId: in.AppId,
AddonsName: in.AddonsName,
CreditGroup: in.OtherCreditGroup,
Num: in.OtherNum,
Remark: fmt.Sprintf("后台用户:%v 为你操作%v", memberId, in.Remark),
})
return
})
}
// UpdateCash 修改提现信息
func (s *sAdminMember) UpdateCash(ctx context.Context, in *adminin.MemberUpdateCashInp) (err error) {
memberId := contexts.Get(ctx).User.Id
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
var mb entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if gmd5.MustEncryptString(in.Password+mb.Salt) != mb.PasswordHash {
err = gerror.New("登录密码不正确")
return
}
_, err = dao.AdminMember.Ctx(ctx).WherePri(memberId).
Data(g.Map{
dao.AdminMember.Columns().Cash: adminin.MemberCash{
Name: in.Name,
Account: in.Account,
PayeeCode: in.PayeeCode,
},
}).
Update()
if err != nil {
err = gerror.New("修改提现信息失败！")
return
}
return
}
// UpdateEmail 换绑邮箱
func (s *sAdminMember) UpdateEmail(ctx context.Context, in *adminin.MemberUpdateEmailInp) (err error) {
memberId := contexts.Get(ctx).User.Id
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
if mb.Email == in.Email {
err = gerror.New("新旧邮箱不能一样")
return
}
if !validate.IsEmail(in.Email) {
err = gerror.New("邮箱地址不正确")
return
}
// 存在原绑定号码，需要进行验证
if mb.Email != "" {
err = service.SysEmsLog().VerifyCode(ctx, &sysin.VerifyEmsCodeInp{
Event: consts.EmsTemplateBind,
Email: mb.Email,
Code: in.Code,
})
if err != nil {
return
}
}
update := g.Map{
dao.AdminMember.Columns().Email: in.Email,
}
if _, err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Data(update).Update(); err != nil {
err = gerror.Wrap(err, "换绑邮箱失败，请稍后重试！")
return
}
return
}
// UpdateMobile 换绑手机号
func (s *sAdminMember) UpdateMobile(ctx context.Context, in *adminin.MemberUpdateMobileInp) (err error) {
memberId := contexts.Get(ctx).User.Id
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
if mb.Mobile == in.Mobile {
err = gerror.New("新旧手机号不能一样")
return
}
if !validate.IsMobile(in.Mobile) {
err = gerror.New("手机号码不正确")
return
}
// 存在原绑定号码，需要进行验证
if mb.Mobile != "" {
err = service.SysSmsLog().VerifyCode(ctx, &sysin.VerifyCodeInp{
Event: consts.SmsTemplateBind,
Mobile: mb.Mobile,
Code: in.Code,
})
if err != nil {
return
}
}
update := g.Map{
dao.AdminMember.Columns().Mobile: in.Mobile,
}
if _, err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Data(update).Update(); err != nil {
err = gerror.Wrap(err, "换绑手机号失败，请稍后重试！")
return
}
return
}
// UpdateProfile 更新用户资料
func (s *sAdminMember) UpdateProfile(ctx context.Context, in *adminin.MemberUpdateProfileInp) (err error) {
memberId := contexts.Get(ctx).User.Id
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
cols := dao.AdminMember.Columns()
update := g.Map{
cols.Avatar: in.Avatar,
cols.RealName: in.RealName,
cols.Qq: in.Qq,
cols.Birthday: in.Birthday,
cols.Sex: in.Sex,
cols.CityId: in.CityId,
cols.Address: in.Address,
}
if _, err = dao.AdminMember.Ctx(ctx).WherePri(memberId).Data(update).Update(); err != nil {
err = gerror.Wrap(err, "更新资料失败，请稍后重试！")
return
}
return
}
// UpdatePwd 修改登录密码
func (s *sAdminMember) UpdatePwd(ctx context.Context, in *adminin.MemberUpdatePwdInp) (err error) {
var mb entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(in.Id).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if gmd5.MustEncryptString(in.OldPassword+mb.Salt) != mb.PasswordHash {
err = gerror.New("原密码不正确")
return
}
update := g.Map{
dao.AdminMember.Columns().PasswordHash: gmd5.MustEncryptString(in.NewPassword + mb.Salt),
}
if _, err = dao.AdminMember.Ctx(ctx).WherePri(in.Id).Data(update).Update(); err != nil {
err = gerror.Wrap(err, "更新登录密码失败，请稍后重试！")
return
}
return
}
// ResetPwd 重置密码
func (s *sAdminMember) ResetPwd(ctx context.Context, in *adminin.MemberResetPwdInp) (err error) {
var (
mb *entity.AdminMember
memberId = contexts.GetUserId(ctx)
)
if err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.New("用户信息不存在")
return
}
update := g.Map{
dao.AdminMember.Columns().PasswordHash: gmd5.MustEncryptString(in.Password + mb.Salt),
}
if _, err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Data(update).Update(); err != nil {
err = gerror.Wrap(err, "用户密码重置失败，请稍后重试！")
return
}
return
}
// VerifyUnique 验证管理员唯一属性
func (s *sAdminMember) VerifyUnique(ctx context.Context, in *adminin.VerifyUniqueInp) (err error) {
if in.Where == nil {
return
}
cols := dao.AdminMember.Columns()
msgMap := g.MapStrStr{
cols.Username: "用户名已存在，请换一个",
cols.Email: "邮箱已存在，请换一个",
cols.Mobile: "手机号已存在，请换一个",
cols.InviteCode: "邀请码已存在，请换一个",
}
for k, v := range in.Where {
if v == "" {
continue
}
message, ok := msgMap[k]
if !ok {
err = gerror.Newf("字段 [ %v ] 未配置唯一属性验证", k)
return
}
if err = hgorm.IsUnique(ctx, &dao.AdminMember, g.Map{k: v}, message, in.Id); err != nil {
return
}
}
return
}
// Delete 删除用户
func (s *sAdminMember) Delete(ctx context.Context, in *adminin.MemberDeleteInp) (err error) {
memberId := contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
var list []*entity.AdminMember
if err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Scan(&list); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if len(list) == 0 {
err = gerror.New("需要删除的用户不存在或已删除！")
return
}
for _, v := range list {
if s.VerifySuperId(ctx, v.Id) {
err = gerror.New("超管账号禁止删除！")
return
}
count, err := dao.AdminMember.Ctx(ctx).Where(dao.AdminMember.Columns().Pid, v.Id).Count()
if err != nil {
err = gerror.Wrap(err, "删除用户检查失败，请稍后重试！")
return err
}
if count > 0 {
err = gerror.Newf("用户[%v]存在下级，请先删除TA的下级用户！", v.Id)
return err
}
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
if _, err = s.FilterAuthModel(ctx, memberId).WherePri(in.Id).Delete(); err != nil {
err = gerror.Wrap(err, "删除用户失败，请稍后重试！")
return
}
if _, err = dao.AdminMemberPost.Ctx(ctx).Where(dao.AdminMemberPost.Columns().MemberId, in.Id).Delete(); err != nil {
err = gerror.Wrap(err, "删除用户岗位失败，请稍后重试！")
}
// 这里如果需要，可以加入更多删除用户的相关处理
// ...
return
})
}
// Edit 修改/新增用户
func (s *sAdminMember) Edit(ctx context.Context, in *adminin.MemberEditInp) (err error) {
opMemberId := contexts.GetUserId(ctx)
if opMemberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
if in.Username == "" {
err = gerror.New("帐号不能为空")
return
}
cols := dao.AdminMember.Columns()
err = s.VerifyUnique(ctx, &adminin.VerifyUniqueInp{
Id: in.Id,
Where: g.Map{
cols.Username: in.Username,
cols.Mobile: in.Mobile,
cols.Email: in.Email,
},
})
if err != nil {
return
}
// 验证角色ID
if err = service.AdminRole().VerifyRoleId(ctx, in.RoleId); err != nil {
return
}
// 验证部门ID
if err = service.AdminDept().VerifyDeptId(ctx, in.DeptId); err != nil {
return
}
config, err := service.SysConfig().GetLogin(ctx)
if err != nil {
return
}
needLoadSuperAdmin := false
defer func() {
if needLoadSuperAdmin {
// 本地先更新
s.LoadSuperAdmin(ctx)
// 推送消息让所有集群再同步一次
global.PublishClusterSync(ctx, consts.ClusterSyncSysSuperAdmin, nil)
}
}()
// 修改
if in.Id > 0 {
if s.VerifySuperId(ctx, in.Id) {
err = gerror.New("超管账号禁止编辑！")
return
}
mod := s.FilterAuthModel(ctx, opMemberId)
if in.Password != "" {
// 修改密码，需要获取到密码盐
salt, err := s.FilterAuthModel(ctx, opMemberId).Fields(cols.Salt).WherePri(in.Id).Value()
if err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return err
}
if salt.IsEmpty() {
err = gerror.New("该用户没有设置密码盐，请联系管理员！")
return err
}
in.PasswordHash = gmd5.MustEncryptString(in.Password + salt.String())
} else {
mod = mod.FieldsEx(cols.PasswordHash)
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
if _, err = mod.WherePri(in.Id).Data(in).Update(); err != nil {
err = gerror.Wrap(err, "修改用户信息失败，请稍后重试！")
return
}
// 更新岗位
if err = service.AdminMemberPost().UpdatePostIds(ctx, in.Id, in.PostIds); err != nil {
err = gerror.Wrap(err, "更新用户岗位失败，请稍后重试！")
}
needLoadSuperAdmin = in.RoleId == s.superAdmin.RoleId
return
})
}
// 新增用户时的额外属性
var data adminin.MemberAddInp
data.MemberEditInp = in
data.Salt = grand.S(6)
data.InviteCode = grand.S(12)
data.PasswordHash = gmd5.MustEncryptString(data.Password + data.Salt)
// 关系树
data.Pid = opMemberId
data.Level, data.Tree, err = s.GenTree(ctx, opMemberId)
if err != nil {
return
}
// 默认头像
if data.Avatar == "" {
data.Avatar = config.Avatar
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
id, err := dao.AdminMember.Ctx(ctx).Data(data).OmitEmptyData().InsertAndGetId()
if err != nil {
err = gerror.Wrap(err, "新增用户失败，请稍后重试！")
return
}
// 更新岗位
if err = service.AdminMemberPost().UpdatePostIds(ctx, id, in.PostIds); err != nil {
err = gerror.Wrap(err, "新增用户岗位失败，请稍后重试！")
}
needLoadSuperAdmin = in.RoleId == s.superAdmin.RoleId
return
})
}
// View 获取用户信息
func (s *sAdminMember) View(ctx context.Context, in *adminin.MemberViewInp) (res *adminin.MemberViewModel, err error) {
if err = s.FilterAuthModel(ctx, contexts.GetUserId(ctx)).Hook(hook.MemberInfo).WherePri(in.Id).Scan(&res); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
}
return
}
// List 获取用户列表
func (s *sAdminMember) List(ctx context.Context, in *adminin.MemberListInp) (list []*adminin.MemberListModel, totalCount int, err error) {
mod := s.FilterAuthModel(ctx, contexts.GetUserId(ctx))
cols := dao.AdminMember.Columns()
if in.RealName != "" {
mod = mod.WhereLike(cols.RealName, "%"+in.RealName+"%")
}
if in.Username != "" {
mod = mod.WhereLike(cols.Username, "%"+in.Username+"%")
}
if in.Mobile > 0 {
mod = mod.Where(cols.Mobile, in.Mobile)
}
if in.Status > 0 {
mod = mod.Where(cols.Status, in.Status)
}
if in.DeptId > 0 {
mod = mod.Where(cols.DeptId, in.DeptId)
}
if in.RoleId > 0 {
mod = mod.Where(cols.RoleId, in.RoleId)
}
if in.Id > 0 {
mod = mod.Where(cols.Id, in.Id)
}
if in.Pid > 0 {
mod = mod.Where(cols.Pid, in.Pid)
}
if len(in.CreatedAt) == 2 {
mod = mod.WhereBetween(cols.CreatedAt, gtime.New(in.CreatedAt[0]), gtime.New(in.CreatedAt[1]))
}
if err = mod.Hook(hook.MemberInfo).Page(in.Page, in.PerPage).OrderDesc(cols.Id).ScanAndCount(&list, &totalCount, true); err != nil {
err = gerror.Wrap(err, "获取用户列表失败！")
return
}
for _, v := range list {
columns, err := dao.AdminMemberPost.Ctx(ctx).Fields(dao.AdminMemberPost.Columns().PostId).Where(dao.AdminMemberPost.Columns().MemberId, v.Id).Array()
if err != nil {
err = gerror.Wrap(err, "获取用户岗位数据失败！")
return nil, 0, err
}
v.PostIds = g.NewVar(columns).Int64s()
}
return
}
// Status 更新状态
func (s *sAdminMember) Status(ctx context.Context, in *adminin.MemberStatusInp) (err error) {
if s.VerifySuperId(ctx, in.Id) {
err = gerror.New("超管账号不能更改状态")
return
}
if _, err = s.FilterAuthModel(ctx, contexts.GetUserId(ctx)).WherePri(in.Id).Data(dao.AdminMember.Columns().Status, in.Status).Update(); err != nil {
err = gerror.Wrap(err, "更新用户状态失败，请稍后重试！")
}
return
}
// GenTree 生成关系树
func (s *sAdminMember) GenTree(ctx context.Context, pid int64) (level int, newTree string, err error) {
var pmb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(pid).Scan(&pmb); err != nil {
return
}
if pmb == nil {
err = gerror.New("上级信息不存在")
return
}
level = pmb.Level + 1
newTree = tree.GenLabel(pmb.Tree, pmb.Id)
return
}
// LoginMemberInfo 获取登录用户信息
func (s *sAdminMember) LoginMemberInfo(ctx context.Context) (res *adminin.LoginMemberInfoModel, err error) {
var memberId = contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("用户身份异常，请重新登录！")
return
}
if err = dao.AdminMember.Ctx(ctx).Hook(hook.MemberInfo).WherePri(memberId).Scan(&res); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if res == nil {
err = gerror.New("用户不存在！")
return
}
// 细粒度权限
permissions, err := service.AdminMenu().LoginPermissions(ctx, memberId)
if err != nil {
return
}
res.Permissions = permissions
// 登录统计
stat, err := s.MemberLoginStat(ctx, &adminin.MemberLoginStatInp{MemberId: memberId})
if err != nil {
return
}
res.MemberLoginStatModel = stat
res.Mobile = gstr.HideStr(res.Mobile, 40, `*`)
res.Email = gstr.HideStr(res.Email, 40, `*`)
res.OpenId, _ = service.CommonWechat().GetOpenId(ctx)
res.DeptType = contexts.GetDeptType(ctx)
return
}
// MemberLoginStat 用户登录统计
func (s *sAdminMember) MemberLoginStat(ctx context.Context, in *adminin.MemberLoginStatInp) (res *adminin.MemberLoginStatModel, err error) {
var (
models *entity.SysLoginLog
cols = dao.SysLoginLog.Columns()
)
err = dao.SysLoginLog.Ctx(ctx).Fields(cols.LoginAt, cols.LoginIp).
Where(cols.MemberId, in.MemberId).
Where(cols.Status, consts.StatusEnabled).
OrderDesc(cols.Id).
Scan(&models)
if err != nil {
return
}
res = new(adminin.MemberLoginStatModel)
if models == nil {
return
}
res.LastLoginAt = models.LoginAt
res.LastLoginIp = models.LoginIp
res.LoginCount, err = dao.SysLoginLog.Ctx(ctx).
Where(cols.MemberId, in.MemberId).
Where(cols.Status, consts.StatusEnabled).
Count()
return
}
// GetIdByCode 通过邀请码获取用户ID
func (s *sAdminMember) GetIdByCode(ctx context.Context, in *adminin.GetIdByCodeInp) (res *adminin.GetIdByCodeModel, err error) {
if err = dao.AdminMember.Ctx(ctx).Fields(adminin.GetIdByCodeModel{}).Where(dao.AdminMember.Columns().InviteCode, in.Code).Scan(&res); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
}
return
}
// Select 获取可选的用户选项
func (s *sAdminMember) Select(ctx context.Context, in *adminin.MemberSelectInp) (res []*adminin.MemberSelectModel, err error) {
fields := fmt.Sprintf("%s as value,%s as label,%s,%s", dao.AdminMember.Columns().Id, dao.AdminMember.Columns().RealName, dao.AdminMember.Columns().Username, dao.AdminMember.Columns().Avatar)
err = dao.AdminMember.Ctx(ctx).Fields(fields).
Handler(handler.FilterAuthWithField("id")).
Scan(&res)
if err != nil {
err = gerror.Wrap(err, "获取可选用户选项失败，请稍后重试！")
}
return
}
// GetLowerIds 获取指定用户的所有下级ID集合
func (s *sAdminMember) GetLowerIds(ctx context.Context, memberId int64) (ids []int64, err error) {
array, err := dao.AdminMember.Ctx(ctx).
Fields(dao.AdminMember.Columns().Id).
WhereLike(dao.AdminMember.Columns().Tree, "%"+tree.GenLabel("", memberId)+"%").
Array()
if err != nil {
return nil, err
}
for _, v := range array {
ids = append(ids, v.Int64())
}
return
}
// GetComplexMemberIds 组合查找符合条件的用户ID
func (s *sAdminMember) GetComplexMemberIds(ctx context.Context, memberIdx, opt string) (ids []int64, err error) {
memberId := gconv.Int64(memberIdx)
count, err := s.FilterAuthModel(ctx, contexts.GetUserId(ctx)).WherePri(memberId).Count()
if err != nil {
return nil, err
}
if count == 0 {
return
}
switch opt {
case "1": // 仅查自己
ids = append(ids, memberId)
case "2": // 仅查下级
ids, err = s.GetLowerIds(ctx, memberId)
if err != nil {
return nil, err
}
default: // 查全部
ids, err = s.GetLowerIds(ctx, memberId)
if err != nil {
return nil, err
}
ids = append(ids, memberId)
}
ids = convert.UniqueSlice(ids)
return
}
// GetIdsByKeyword 根据关键词查找符合条件的用户ID
func (s *sAdminMember) GetIdsByKeyword(ctx context.Context, ks string) (res []int64, err error) {
ks = gstr.Trim(ks)
if len(ks) == 0 {
return
}
cols := dao.AdminMember.Columns()
array, err := dao.AdminMember.Ctx(ctx).Fields(cols.Id).
Where(
g.Model().Builder().
WhereOr(cols.Id, ks).
WhereOr(cols.RealName, ks).
WhereOr(cols.Username, ks).
WhereOr(cols.Mobile, ks),
).
Array()
if err != nil {
err = gerror.Wrap(err, "根据关键词获取用户ID失败，请稍后重试！")
}
res = gvar.New(array).Int64s()
return
}
// VerifySuperId 验证是否为超管
func (s *sAdminMember) VerifySuperId(ctx context.Context, verifyId int64) bool {
s.superAdmin.RLock()
defer s.superAdmin.RUnlock()
if s.superAdmin == nil || s.superAdmin.MemberIds == nil {
g.Log().Error(ctx, "superAdmin is not initialized.")
return false
}
_, ok := s.superAdmin.MemberIds[verifyId]
return ok
}
// LoadSuperAdmin 加载超管数据
func (s *sAdminMember) LoadSuperAdmin(ctx context.Context) {
value, err := dao.AdminRole.Ctx(ctx).Fields(dao.AdminRole.Columns().Id).Where(dao.AdminRole.Columns().Key, consts.SuperRoleKey).Value()
if err != nil {
g.Log().Errorf(ctx, "LoadSuperAdmin AdminRole err:%+v", err)
return
}
if value.IsEmpty() || value.IsNil() {
g.Log().Error(ctx, "the superAdmin role must be configured.")
return
}
array, err := dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().Id).Where(dao.AdminMember.Columns().RoleId, value).Array()
if err != nil {
g.Log().Errorf(ctx, "LoadSuperAdmin AdminMember err:%+v", err)
return
}
s.superAdmin.Lock()
defer s.superAdmin.Unlock()
s.superAdmin.MemberIds = make(map[int64]struct{}, len(array))
for _, v := range array {
s.superAdmin.MemberIds[v.Int64()] = struct{}{}
}
s.superAdmin.RoleId = value.Int64()
}
// ClusterSyncSuperAdmin 集群同步
func (s *sAdminMember) ClusterSyncSuperAdmin(ctx context.Context, message *gredis.Message) {
s.LoadSuperAdmin(ctx)
}
// FilterAuthModel 过滤用户操作权限
// 非超管用户只能操作自己的下级角色用户，并且需要满足自身角色的数据权限设置
func (s *sAdminMember) FilterAuthModel(ctx context.Context, memberId int64) *gdb.Model {
m := dao.AdminMember.Ctx(ctx)
if s.VerifySuperId(ctx, memberId) {
return m
}
var roleId int64
if contexts.GetUserId(ctx) == memberId {
// 当前登录用户直接从上下文中取角色ID
roleId = contexts.GetRoleId(ctx)
} else {
ro, err := dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().RoleId).Where(dao.AdminMember.Columns().Id, memberId).Value()
if err != nil {
g.Log().Panicf(ctx, "failed to get role information, err:%+v", err)
return nil
}
roleId = ro.Int64()
}
roleIds, err := service.AdminRole().GetSubRoleIds(ctx, roleId, false)
if err != nil {
g.Log().Panicf(ctx, "get the subordinate role permission exception, err:%+v", err)
return nil
}
return m.Where("id <> ?", memberId).WhereIn("role_id", roleIds).Handler(handler.FilterAuthWithField("id"))
}
server/internal/logic/admin/member_post.go
+44
View File
@@ -0,0 +1,44 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"hotgo/internal/dao"
"hotgo/internal/model/entity"
"hotgo/internal/service"
)
type sAdminMemberPost struct{}
func NewAdminMemberPost() *sAdminMemberPost {
return &sAdminMemberPost{}
}
func init() {
service.RegisterAdminMemberPost(NewAdminMemberPost())
}
// UpdatePostIds 更新用户岗位
func (s *sAdminMemberPost) UpdatePostIds(ctx context.Context, memberId int64, postIds []int64) (err error) {
if _, err = dao.AdminMemberPost.Ctx(ctx).Where(dao.AdminMemberPost.Columns().MemberId, memberId).Delete(); err != nil {
err = gerror.Wrap(err, "清理用户旧岗位数据失败，请稍后重试！")
return
}
for i := 0; i < len(postIds); i++ {
_, err = dao.AdminMemberPost.Ctx(ctx).OmitEmptyData().Insert(entity.AdminMemberPost{
MemberId: memberId,
PostId: postIds[i],
})
if err != nil {
err = gerror.Wrap(err, "加入用户岗位数据失败，请稍后重试！")
return err
}
}
return
}
server/internal/logic/admin/menu.go
+312
View File
@@ -0,0 +1,312 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/api/admin/role"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/casbin"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/service"
"hotgo/utility/convert"
"hotgo/utility/validate"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/text/gstr"
"github.com/gogf/gf/v2/util/gconv"
"github.com/gogf/gf/v2/util/gmode"
)
type sAdminMenu struct{}
func NewAdminMenu() *sAdminMenu {
return &sAdminMenu{}
}
func init() {
service.RegisterAdminMenu(NewAdminMenu())
}
// Model Orm模型
func (s *sAdminMenu) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
return handler.Model(dao.AdminMenu.Ctx(ctx), option...)
}
// Delete 删除
func (s *sAdminMenu) Delete(ctx context.Context, in *adminin.MenuDeleteInp) (err error) {
exist, err := dao.AdminMenu.Ctx(ctx).Where(dao.AdminMenu.Columns().Pid, in.Id).One()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
if !exist.IsEmpty() {
return gerror.New("请先删除该菜单下的所有菜单！")
}
_, err = dao.AdminMenu.Ctx(ctx).Where(dao.AdminMenu.Columns().Id, in.Id).Delete()
return
}
// VerifyUnique 验证菜单唯一属性
func (s *sAdminMenu) VerifyUnique(ctx context.Context, in *adminin.VerifyUniqueInp) (err error) {
if in.Where == nil {
return
}
cols := dao.AdminMenu.Columns()
msgMap := g.MapStrStr{
cols.Name: "菜单编码已存在，请换一个",
cols.Title: "菜单名称已存在，请换一个",
}
for k, v := range in.Where {
if v == "" {
continue
}
message, ok := msgMap[k]
if !ok {
err = gerror.Newf("字段 [ %v ] 未配置唯一属性验证", k)
return
}
if err = hgorm.IsUnique(ctx, &dao.AdminMenu, g.Map{k: v}, message, in.Id); err != nil {
return
}
}
return
}
// Edit 修改/新增
func (s *sAdminMenu) Edit(ctx context.Context, in *adminin.MenuEditInp) (err error) {
// 验证唯一性
err = s.VerifyUnique(ctx, &adminin.VerifyUniqueInp{
Id: in.Id,
Where: g.Map{
dao.AdminMenu.Columns().Title: in.Title,
dao.AdminMenu.Columns().Name: in.Name,
},
})
if err != nil {
return
}
if (in.Type == 1 || in.Type == 2) && len(in.Component) == 0 {
err = gerror.Newf("请先设置目录组件/路径")
return
}
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
in.Pid, in.Level, in.Tree, err = hgorm.AutoUpdateTree(ctx, &dao.AdminMenu, in.Id, in.Pid)
if err != nil {
return err
}
if in.Id > 0 {
if _, err = dao.AdminMenu.Ctx(ctx).Where(dao.AdminMenu.Columns().Id, in.Id).Data(in).Update(); err != nil {
err = gerror.Wrap(err, "修改菜单失败！")
return err
}
} else {
if _, err = dao.AdminMenu.Ctx(ctx).Data(in).OmitEmptyData().Insert(); err != nil {
err = gerror.Wrap(err, "新增菜单失败！")
return err
}
}
return casbin.Refresh(ctx)
})
}
// List 获取菜单列表
func (s *sAdminMenu) List(ctx context.Context, in *adminin.MenuListInp) (res *adminin.MenuListModel, err error) {
var models []*entity.AdminMenu
if err = dao.AdminMenu.Ctx(ctx).Order("sort asc,id desc").Scan(&models); err != nil {
return
}
res = new(adminin.MenuListModel)
res.List = s.treeList(0, models)
return
}
// genNaiveMenus 生成NaiveUI菜单格式
func (s *sAdminMenu) genNaiveMenus(menus []*adminin.MenuRouteSummary) (sources []*adminin.MenuRoute) {
for _, men := range menus {
var source = new(adminin.MenuRoute)
source.Name = men.Name
source.Path = men.Path
source.Redirect = men.Redirect
source.Component = men.Component
source.Meta = &adminin.MenuRouteMeta{
Title: men.Title,
Icon: men.Icon,
KeepAlive: men.KeepAlive == 1,
Hidden: men.Hidden == 1,
Sort: men.Sort,
AlwaysShow: men.AlwaysShow == 1,
ActiveMenu: men.ActiveMenu,
IsRoot: men.IsRoot == 1,
FrameSrc: men.FrameSrc,
//Permissions: men.Permissions,
Affix: men.Affix == 1,
Type: men.Type,
}
if len(men.Children) > 0 {
source.Children = append(source.Children, s.genNaiveMenus(men.Children)...)
}
sources = append(sources, source)
}
return
}
// getChildrenList 生成菜单树
func (s *sAdminMenu) getChildrenList(menu *adminin.MenuRouteSummary, treeMap map[string][]*adminin.MenuRouteSummary) (err error) {
menu.Children = treeMap[gconv.String(menu.Id)]
for i := 0; i < len(menu.Children); i++ {
if err = s.getChildrenList(menu.Children[i], treeMap); err != nil {
return
}
}
return
}
// GetMenuList 获取菜单列表
func (s *sAdminMenu) GetMenuList(ctx context.Context, memberId int64) (res *role.DynamicRes, err error) {
var (
allMenus []*adminin.MenuRouteSummary
menus []*adminin.MenuRouteSummary
treeMap = make(map[string][]*adminin.MenuRouteSummary)
mod = dao.AdminMenu.Ctx(ctx).Where(dao.AdminMenu.Columns().Status, consts.StatusEnabled).WhereIn(dao.AdminMenu.Columns().Type, []int{1, 2})
)
// 非超管验证允许的菜单列表
if !service.AdminMember().VerifySuperId(ctx, memberId) {
menuIds, err := dao.AdminRoleMenu.Ctx(ctx).Fields(dao.AdminRoleMenu.Columns().MenuId).Where(dao.AdminRoleMenu.Columns().RoleId, contexts.GetRoleId(ctx)).Array()
if err != nil {
return nil, err
}
if len(menuIds) > 0 {
pidList, err := dao.AdminMenu.Ctx(ctx).Fields(dao.AdminMenu.Columns().Pid).WhereIn(dao.AdminMenu.Columns().Id, menuIds).Group("pid").Array()
if err != nil {
return nil, err
}
if len(pidList) > 0 {
menuIds = append(pidList, menuIds...)
}
}
mod = mod.Where(dao.AdminMenu.Columns().Id, menuIds)
}
if err = mod.Order(dao.AdminMenu.Columns().Sort, dao.AdminMenu.Columns().Id, "desc").Scan(&allMenus); err != nil || len(allMenus) == 0 {
return
}
// 生产环境下隐藏一些菜单
if gmode.IsProduct() {
newMenus := make([]*adminin.MenuRouteSummary, 0)
devMenus := []string{"Develops", "doc"} // 如果你还有其他需要在生产环境隐藏的菜单，将菜单别名加入即可
for _, menu := range allMenus {
if !validate.InSlice(devMenus, menu.Name) {
newMenus = append(newMenus, menu)
}
}
allMenus = newMenus
}
for _, v := range allMenus {
treeMap[gconv.String(v.Pid)] = append(treeMap[gconv.String(v.Pid)], v)
}
menus = treeMap["0"]
for i := 0; i < len(menus); i++ {
err = s.getChildrenList(menus[i], treeMap)
}
res = new(role.DynamicRes)
res.List = append(res.List, s.genNaiveMenus(menus)...)
return
}
// LoginPermissions 获取登录成功后的细粒度权限
func (s *sAdminMenu) LoginPermissions(ctx context.Context, memberId int64) (lists adminin.MemberLoginPermissions, err error) {
type Permissions struct {
Permissions string `json:"permissions"`
}
var (
allPermissions []*Permissions
mod = dao.AdminMenu.Ctx(ctx).Fields(dao.AdminMenu.Columns().Permissions).
Where(dao.AdminMenu.Columns().Status, consts.StatusEnabled).
WhereNot(dao.AdminMenu.Columns().Permissions, "")
)
// 非超管验证允许的菜单列表
if !service.AdminMember().VerifySuperId(ctx, memberId) {
menuIds, err := dao.AdminRoleMenu.Ctx(ctx).Fields(dao.AdminRoleMenu.Columns().MenuId).Where(dao.AdminRoleMenu.Columns().RoleId, contexts.GetRoleId(ctx)).Array()
if err != nil {
return nil, err
}
mod = mod.Where("id", menuIds)
}
if err = mod.Scan(&allPermissions); err != nil {
return
}
// 无权限
if len(allPermissions) == 0 {
lists = append(lists, "value")
return
}
for _, v := range allPermissions {
for _, p := range gstr.Explode(`,`, v.Permissions) {
lists = append(lists, p)
}
}
lists = convert.UniqueSlice(lists)
return
}
// treeList 树状列表
func (s *sAdminMenu) treeList(pid int64, nodes []*entity.AdminMenu) (list []*adminin.MenuTree) {
list = make([]*adminin.MenuTree, 0)
for _, v := range nodes {
if v.Pid == pid {
item := new(adminin.MenuTree)
item.AdminMenu = *v
item.Label = v.Title
item.Key = v.Id
child := s.treeList(v.Id, nodes)
if len(child) > 0 {
item.Children = child
}
list = append(list, item)
}
}
return
}
// GetFastList 获取菜单列表
func (s *sAdminMenu) GetFastList(ctx context.Context) (res map[int64]*entity.AdminMenu, err error) {
var models []*entity.AdminMenu
if err = dao.AdminMenu.Ctx(ctx).Scan(&models); err != nil {
return
}
res = make(map[int64]*entity.AdminMenu, len(models))
for _, v := range models {
res[v.Id] = v
}
return
}
server/internal/logic/admin/monitor.go
+97
View File
@@ -0,0 +1,97 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gcron"
"github.com/gogf/gf/v2/os/gtime"
"github.com/shirou/gopsutil/v3/load"
"github.com/shirou/gopsutil/v3/net"
"hotgo/internal/library/location"
"hotgo/internal/model"
"hotgo/internal/service"
"hotgo/utility/format"
"hotgo/utility/simple"
"runtime"
"sync"
)
type sAdminMonitor struct {
data *model.MonitorData
sync.RWMutex
}
func NewAdminMonitor() *sAdminMonitor {
return &sAdminMonitor{
data: new(model.MonitorData),
}
}
func init() {
service.RegisterAdminMonitor(NewAdminMonitor())
}
// StartMonitor 启动服务监控
func (s *sAdminMonitor) StartMonitor(ctx context.Context) {
simple.SafeGo(ctx, func(ctx context.Context) {
s.data.STartTime = gtime.Now().Timestamp()
s.data.IntranetIP, _ = location.GetLocalIP()
s.data.PublicIP, _ = location.GetPublicIP(ctx)
_, err := gcron.Add(ctx, "@every 1s", func(ctx context.Context) {
s.Lock()
defer s.Unlock()
s.netIO()
s.loadAvg()
}, "AdminMonitorCronJob")
if err != nil {
g.Log().Warningf(ctx, "StartMonitor CronJob err:%+v", err)
}
})
}
// GetMeta 获取监控元数据
func (s *sAdminMonitor) GetMeta(ctx context.Context) *model.MonitorData {
return s.data
}
func (s *sAdminMonitor) loadAvg() {
pl, _ := load.Avg()
counter := model.LoadAvgStats{
Time: gtime.Now(),
Avg: pl.Load1,
Ratio: pl.Load1 / (float64(runtime.NumCPU()) * 2) * 100,
}
s.data.LoadAvg = append(s.data.LoadAvg, &counter)
if len(s.data.LoadAvg) > 10 {
s.data.LoadAvg = append(s.data.LoadAvg[:0], s.data.LoadAvg[(1):]...)
}
}
func (s *sAdminMonitor) netIO() {
var counter model.NetIOCounters
ni, _ := net.IOCounters(true)
counter.Time = gtime.Now()
for _, v := range ni {
counter.BytesSent += v.BytesSent
counter.BytesRecv += v.BytesRecv
}
if len(s.data.NetIO) > 0 {
lastNetIO := s.data.NetIO[len(s.data.NetIO)-1]
sub := counter.Time.Sub(lastNetIO.Time).Seconds()
counter.Down = format.Round2Float64((float64(counter.BytesRecv - lastNetIO.BytesRecv)) / sub)
counter.UP = format.Round2Float64((float64(counter.BytesSent - lastNetIO.BytesSent)) / sub)
}
s.data.NetIO = append(s.data.NetIO, &counter)
if len(s.data.NetIO) > 10 {
s.data.NetIO = append(s.data.NetIO[:0], s.data.NetIO[(1):]...)
}
}
server/internal/logic/admin/notice.go
+534
View File
@@ -0,0 +1,534 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"fmt"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
"hotgo/internal/websocket"
"hotgo/utility/simple"
"hotgo/utility/validate"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
)
type sAdminNotice struct{}
func NewAdminNotice() *sAdminNotice {
return &sAdminNotice{}
}
func init() {
service.RegisterAdminNotice(NewAdminNotice())
}
// Model Orm模型
func (s *sAdminNotice) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
return handler.Model(dao.AdminNotice.Ctx(ctx), option...)
}
// Delete 删除
func (s *sAdminNotice) Delete(ctx context.Context, in *adminin.NoticeDeleteInp) (err error) {
_, err = s.Model(ctx).Where("id", in.Id).Delete()
return
}
// Edit 修改/新增
func (s *sAdminNotice) Edit(ctx context.Context, in *adminin.NoticeEditInp) (err error) {
var member = contexts.Get(ctx).User
if member == nil {
err = gerror.New("获取用户信息失败！")
return
}
if in.Title == "" {
err = gerror.New("标题不能为空")
return
}
if in.Content == "" {
err = gerror.New("请输入消息内容")
return
}
if in.Type == consts.NoticeTypeLetter && len(in.Receiver) == 0 {
err = gerror.New("私信类型必须选择接收人")
return
}
// 检查选项接收人是否合法
if in.Type == consts.NoticeTypeLetter {
count, _ := dao.AdminMember.Ctx(ctx).Handler(handler.FilterAuthWithField("id")).WhereIn("id", in.Receiver).Count()
if count != len(in.Receiver) {
err = gerror.New("接收人不合法")
return
}
in.SenderAvatar = member.Avatar
}
// 修改
if in.Id > 0 {
in.UpdatedBy = member.Id
_, err = s.Model(ctx).Where("id", in.Id).Data(in).Update()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
return nil
}
// 新增
in.CreatedBy = member.Id
in.CreatedAt = gtime.Now()
in.Id, err = s.Model(ctx, &handler.Option{FilterAuth: false}).Data(in).OmitEmptyData().InsertAndGetId()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
// 推送通知
response := &websocket.WResponse{
Event: "notice",
Data: in,
}
simple.SafeGo(ctx, func(ctx context.Context) {
if in.Type == consts.NoticeTypeLetter {
for _, receiverId := range in.Receiver {
websocket.SendToUser(receiverId, response)
}
} else {
websocket.SendToAll(response)
}
})
return
}
// Status 更新部门状态
func (s *sAdminNotice) Status(ctx context.Context, in *adminin.NoticeStatusInp) (err error) {
if in.Id <= 0 {
err = gerror.New("ID不能为空")
return
}
if in.Status <= 0 {
err = gerror.New("状态不能为空")
return
}
if !validate.InSlice(consts.StatusSlice, in.Status) {
err = gerror.New("状态不正确")
return
}
// 修改
_, err = s.Model(ctx).Where("id", in.Id).Data("status", in.Status).Update()
return
}
// MaxSort 最大排序
func (s *sAdminNotice) MaxSort(ctx context.Context, in *adminin.NoticeMaxSortInp) (res *adminin.NoticeMaxSortModel, err error) {
if err = dao.AdminNotice.Ctx(ctx).Order("sort desc").Scan(&res); err != nil {
return
}
if res == nil {
res = new(adminin.NoticeMaxSortModel)
}
res.Sort = form.DefaultMaxSort(res.Sort)
return
}
// View 获取指定字典类型信息
func (s *sAdminNotice) View(ctx context.Context, in *adminin.NoticeViewInp) (res *adminin.NoticeViewModel, err error) {
if err = s.Model(ctx).Where("id", in.Id).Scan(&res); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return nil, err
}
return res, nil
}
// api列表 不需要登陆
func (s *sAdminNotice) ApiList(ctx context.Context, in *adminin.NoticeListInp) (list []*adminin.NoticeViewModel, totalCount int, err error) {
mod := s.Model(ctx)
if in.Title != "" {
mod = mod.WhereLike("title", "%"+in.Title+"%")
}
if in.Content != "" {
mod = mod.WhereLike("content", "%"+in.Content+"%")
}
if in.Type > 0 {
mod = mod.Where("type", in.Type)
}
if in.Status > 0 {
mod = mod.Where("status", in.Status)
}
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return list, totalCount, err
}
if totalCount == 0 {
return list, totalCount, nil
}
if err = mod.Page(in.Page, in.PerPage).Order("id desc").Scan(&list); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return list, totalCount, err
}
return list, totalCount, err
}
// List 获取列表
func (s *sAdminNotice) List(ctx context.Context, in *adminin.NoticeListInp) (list []*adminin.NoticeListModel, totalCount int, err error) {
var memberId = contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
mod := s.Model(ctx)
if in.Title != "" {
mod = mod.WhereLike("title", "%"+in.Title+"%")
}
if in.Content != "" {
mod = mod.WhereLike("content", "%"+in.Content+"%")
}
if in.Type > 0 {
mod = mod.Where("type", in.Type)
}
if in.Status > 0 {
mod = mod.Where("status", in.Status)
}
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return list, totalCount, err
}
if totalCount == 0 {
return list, totalCount, nil
}
if err = mod.Page(in.Page, in.PerPage).Order("id desc").Scan(&list); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return list, totalCount, err
}
for _, v := range list {
// 接收人头像组
if v.Type == consts.NoticeTypeLetter {
err = dao.AdminMember.Ctx(ctx).
Fields(fmt.Sprintf("%s as name,%s as src", dao.AdminMember.Columns().RealName, dao.AdminMember.Columns().Avatar)).
WhereIn(dao.AdminMember.Columns().Id, v.Receiver.Var().Int64s()).
Scan(&v.ReceiverGroup)
if err != nil {
return
}
}
if g.IsNil(v.ReceiverGroup) || len(v.ReceiverGroup) == 0 {
v.ReceiverGroup = make([]form.AvatarGroup, 0)
}
// 阅读次数
v.ReadCount, err = dao.AdminNoticeRead.Ctx(ctx).Where("notice_id", v.Id).Sum("clicks")
if err != nil {
return
}
}
return list, totalCount, err
}
// PullMessages 拉取未读消息列表
func (s *sAdminNotice) PullMessages(ctx context.Context, in *adminin.PullMessagesInp) (res *adminin.PullMessagesModel, err error) {
var memberId = contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
messageIds, err := s.messageIds(ctx, memberId)
if err != nil {
return
}
res = new(adminin.PullMessagesModel)
unread, err := s.UnreadCount(ctx, &adminin.NoticeUnreadCountInp{MemberId: memberId, MessageIds: messageIds})
if err != nil {
return
}
if unread != nil {
res.NoticeUnreadCountModel = unread
}
if err = s.Model(ctx, &handler.Option{FilterAuth: false}).WhereIn("id", messageIds).Limit(in.Limit).Order("id desc").Scan(&res.List); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
for _, v := range res.List {
count, _ := dao.AdminNoticeRead.Ctx(ctx).Where(dao.AdminNoticeRead.Columns().NoticeId, v.Id).Where(dao.AdminNoticeRead.Columns().MemberId, memberId).Count()
if count > 0 {
v.IsRead = true
}
if v.Type == consts.NoticeTypeLetter {
val, err := dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().Avatar).Where(dao.AdminMember.Columns().Id, v.CreatedBy).Value()
if err == nil {
v.SenderAvatar = val.String()
}
}
}
return
}
// UnreadCount 获取所有类型消息的未读数量
func (s *sAdminNotice) UnreadCount(ctx context.Context, in *adminin.NoticeUnreadCountInp) (res *adminin.NoticeUnreadCountModel, err error) {
if in.MemberId <= 0 {
if in.MemberId = contexts.GetUserId(ctx); in.MemberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
}
if len(in.MessageIds) == 0 {
in.MessageIds, err = s.messageIds(ctx, in.MemberId)
if err != nil {
return
}
if len(in.MessageIds) == 0 {
return
}
}
stat := func(t int) (count int) {
all, err := dao.AdminNotice.Ctx(ctx).As("nr").
Where("type", t).
WhereIn("id", in.MessageIds).
Count()
if err != nil {
g.Log().Infof(ctx, "UnreadCount stat err:%+v", err)
return
}
if all == 0 {
return
}
read, err := dao.AdminNoticeRead.Ctx(ctx).As("nr").
LeftJoin("admin_notice n", "nr.notice_id=n.id").
Where("n.type", t).
WhereIn("n.id", in.MessageIds).
Where("nr.member_id", in.MemberId).
Count()
if err != nil {
g.Log().Infof(ctx, "UnreadCount stat2 err:%+v", err)
return
}
count = all - read
return
}
res = new(adminin.NoticeUnreadCountModel)
res.NotifyCount = stat(consts.NoticeTypeNotify)
res.NoticeCount = stat(consts.NoticeTypeNotice)
res.LetterCount = stat(consts.NoticeTypeLetter)
return
}
// messageIds 获取我的消息所有的消息ID
func (s *sAdminNotice) messageIds(ctx context.Context, memberId int64) (ids []int64, err error) {
columns, err := s.Model(ctx, &handler.Option{FilterAuth: false}).
Fields(dao.AdminNotice.Columns().Id).
Where(dao.AdminNotice.Columns().Status, consts.StatusEnabled).
Where(
s.Model(ctx, &handler.Option{FilterAuth: false}).Builder().WhereIn("type", []int{consts.NoticeTypeNotify, consts.NoticeTypeNotice}).
WhereOr(s.Model(ctx, &handler.Option{FilterAuth: false}).Builder().Where("type", consts.NoticeTypeLetter)),
).Array()
if err != nil {
err = gerror.Wrap(err, "获取我的消息失败！")
return
}
ids = g.NewVar(columns).Int64s()
return
}
// UpRead 更新已读
func (s *sAdminNotice) UpRead(ctx context.Context, in *adminin.NoticeUpReadInp) (err error) {
var (
data *entity.AdminNotice
memberId = contexts.GetUserId(ctx)
)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
if err = dao.AdminNotice.Ctx(ctx).Where("id", in.Id).Scan(&data); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if data == nil {
return gerror.New("公告不存在")
}
return s.updatedReadClicks(ctx, in.Id, memberId)
}
// ReadAll 已读全部
func (s *sAdminNotice) ReadAll(ctx context.Context, in *adminin.NoticeReadAllInp) (err error) {
var memberId = contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
allMessageIds, err := s.messageIds(ctx, memberId)
if err != nil {
return
}
if len(allMessageIds) == 0 {
return
}
array, err := dao.AdminNotice.Ctx(ctx).
Fields("id").
Where("type", in.Type).
WhereIn("id", allMessageIds).
Array()
if err != nil {
return
}
var messageIds []int64
for _, v := range array {
messageIds = append(messageIds, v.Int64())
}
array, err = dao.AdminNoticeRead.Ctx(ctx).As("nr").
Fields("nr.notice_id").
LeftJoin("admin_notice n", "nr.notice_id=n.id").
Where("n.type", in.Type).
WhereIn("n.id", messageIds).
Where("nr.member_id", memberId).
Array()
if err != nil {
return
}
var readIds []int64
for _, v := range array {
readIds = append(readIds, v.Int64())
}
for _, messageId := range messageIds {
if !validate.InSlice(readIds, messageId) {
if err = s.updatedReadClicks(ctx, messageId, memberId); err != nil {
return
}
}
}
return
}
// updatedReadClicks 更新公告已读次数
func (s *sAdminNotice) updatedReadClicks(ctx context.Context, noticeId, memberId int64) (err error) {
var models *entity.AdminNoticeRead
err = dao.AdminNoticeRead.Ctx(ctx).
Where(dao.AdminNoticeRead.Columns().NoticeId, noticeId).
Where(dao.AdminNoticeRead.Columns().MemberId, memberId).
Scan(&models)
if err != nil {
return
}
if models == nil {
_, err = dao.AdminNoticeRead.Ctx(ctx).Data(entity.AdminNoticeRead{NoticeId: noticeId, MemberId: memberId}).OmitEmptyData().Insert()
return
}
_, err = dao.AdminNoticeRead.Ctx(ctx).Where(dao.AdminNoticeRead.Columns().Id, models.Id).Increment(dao.AdminNoticeRead.Columns().Clicks, 1)
return
}
// MessageList 我的消息列表
func (s *sAdminNotice) MessageList(ctx context.Context, in *adminin.NoticeMessageListInp) (list []*adminin.NoticeMessageListModel, totalCount int, err error) {
var memberId = contexts.GetUserId(ctx)
if memberId <= 0 {
err = gerror.New("获取用户信息失败！")
return
}
allMessageIds, err := s.messageIds(ctx, memberId)
if err != nil {
return
}
if len(allMessageIds) == 0 {
return
}
mod := s.Model(ctx, &handler.Option{FilterAuth: false}).WhereIn("id", allMessageIds).Where("type", in.Type)
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if totalCount == 0 {
return
}
if err = mod.Page(in.Page, in.PerPage).Order("id desc").Scan(&list); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
for _, v := range list {
count, _ := dao.AdminNoticeRead.Ctx(ctx).Where(dao.AdminNoticeRead.Columns().NoticeId, v.Id).Where(dao.AdminNoticeRead.Columns().MemberId, memberId).Count()
if count > 0 {
v.IsRead = true
}
if v.Type == consts.NoticeTypeLetter {
val, err := dao.AdminMember.Ctx(ctx).Fields(dao.AdminMember.Columns().Avatar).Where(dao.AdminMember.Columns().Id, v.CreatedBy).Value()
if err == nil {
v.SenderAvatar = val.String()
}
}
}
return
}
server/internal/logic/admin/order.go
+407
View File
@@ -0,0 +1,407 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"fmt"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm"
"hotgo/internal/library/hgorm/handler"
"hotgo/internal/library/hgorm/hook"
"hotgo/internal/library/payment"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/model/input/payin"
"hotgo/internal/service"
"hotgo/internal/websocket"
"hotgo/utility/convert"
"hotgo/utility/excel"
"hotgo/utility/simple"
"hotgo/utility/validate"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/util/gconv"
)
type sAdminOrder struct{}
func NewAdminOrder() *sAdminOrder {
return &sAdminOrder{}
}
func init() {
service.RegisterAdminOrder(NewAdminOrder())
}
// Model 充值订单ORM模型
func (s *sAdminOrder) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
return handler.Model(dao.AdminOrder.Ctx(ctx), option...)
}
// AcceptRefund 受理申请退款
func (s *sAdminOrder) AcceptRefund(ctx context.Context, in *adminin.OrderAcceptRefundInp) (err error) {
view, err := s.View(ctx, &adminin.OrderViewInp{Id: in.Id})
if err != nil {
return err
}
if view == nil {
err = gerror.New("订单不存在")
return
}
if view.Status != consts.OrderStatusReturnRequest {
err = gerror.New("当前订单状态不是申请退款状态，无需受理")
return
}
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
// 同意退款
if in.Status == consts.OrderStatusReturned {
// 更新余额
_, err = service.AdminCreditsLog().SaveBalance(ctx, &adminin.CreditsLogSaveBalanceInp{
MemberId: view.MemberId,
AppId: contexts.GetModule(ctx),
AddonsName: contexts.GetAddonName(ctx),
CreditGroup: consts.CreditGroupBalanceRefund,
Num: -view.Money,
MapId: view.Id,
Remark: fmt.Sprintf("余额退款:%v", in.Remark),
})
if err != nil {
return err
}
_, err = service.PayRefund().Refund(ctx, &payin.PayRefundInp{
OrderSn: view.OrderSn,
RefundMoney: view.Money,
Reason: view.RefundReason,
Remark: in.Remark,
})
if err != nil {
return err
}
}
update := g.Map{
dao.AdminOrder.Columns().Status: in.Status,
dao.AdminOrder.Columns().RejectRefundReason: in.RejectRefundReason,
}
_, err = s.Model(ctx).Where(dao.AdminOrder.Columns().Id, in.Id).Data(update).Update()
return
})
return
}
// ApplyRefund 申请退款
func (s *sAdminOrder) ApplyRefund(ctx context.Context, in *adminin.OrderApplyRefundInp) (err error) {
view, err := s.View(ctx, &adminin.OrderViewInp{Id: in.Id})
if err != nil {
return err
}
if view == nil {
err = gerror.New("订单不存在")
return
}
if view.Status == consts.OrderStatusReturnRequest {
err = gerror.New("当前订单退款正在申请处理，请勿重复提交！")
return
}
if view.Status != consts.OrderStatusDone {
err = gerror.New("当前订单状态不支持申请退款，如有疑问请联系管理员！")
return
}
update := g.Map{
dao.AdminOrder.Columns().Status: consts.OrderStatusReturnRequest,
dao.AdminOrder.Columns().RefundReason: in.RefundReason,
}
_, err = s.Model(ctx).Where(dao.AdminOrder.Columns().Id, in.Id).Data(update).Update()
return
}
// PayNotify 支付成功通知
func (s *sAdminOrder) PayNotify(ctx context.Context, in *payin.NotifyCallFuncInp) (err error) {
var models *entity.AdminOrder
if err = s.Model(ctx).Where(dao.AdminOrder.Columns().OrderSn, in.Pay.OrderSn).Scan(&models); err != nil {
return
}
if models == nil {
err = gerror.New("订单不存在")
return
}
if models.Status != consts.OrderStatusNotPay {
err = gerror.New("订单已被处理，无需重复操作")
return
}
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
// 更新订单状态
_, err = s.Model(ctx).Where(dao.AdminOrder.Columns().Id, models.Id).Data(g.Map{
dao.AdminOrder.Columns().Status: consts.OrderStatusDone,
}).Update()
if err != nil {
return
}
// 更新余额
_, err = service.AdminCreditsLog().SaveBalance(ctx, &adminin.CreditsLogSaveBalanceInp{
MemberId: models.MemberId,
AppId: in.Pay.AppId,
AddonsName: in.Pay.AddonsName,
CreditGroup: consts.CreditGroupBalanceRecharge,
Num: models.Money,
MapId: models.Id,
Remark: in.Pay.Subject,
})
if err != nil {
return err
}
return
})
if err != nil {
return
}
// 推送通知
response := &websocket.WResponse{
Event: "admin/order/notify",
Data: in.Pay,
}
simple.SafeGo(ctx, func(ctx context.Context) {
websocket.SendToUser(in.Pay.MemberId, response)
})
return
}
// Create 创建充值订单
func (s *sAdminOrder) Create(ctx context.Context, in *adminin.OrderCreateInp) (res *adminin.OrderCreateModel, err error) {
var (
subject = "支付订单"
orderSn = payment.GenOrderSn(ctx)
)
switch in.OrderType {
case consts.OrderTypeBalance:
subject = fmt.Sprintf("余额充值:￥%v", in.Money)
case consts.OrderTypeProduct:
// 读取商品信息，读取商品最终支付价格
// ...
// in.Money = 999
// subject = fmt.Sprintf("购买商品:%v", "测试商品名称")
default:
err = gerror.New("不支持的订单类型")
return
}
res = new(adminin.OrderCreateModel)
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
_, err = s.Model(ctx).Data(entity.AdminOrder{
MemberId: contexts.GetUserId(ctx),
OrderType: in.OrderType,
ProductId: in.ProductId,
OrderSn: orderSn,
Money: in.Money,
Remark: in.Remark,
Status: consts.OrderStatusNotPay,
}).OmitEmptyData().Insert()
if err != nil {
return
}
create, err := service.Pay().Create(ctx, payin.PayCreateInp{
Subject: subject,
OrderSn: orderSn,
OrderGroup: consts.OrderGroupAdminOrder,
PayType: in.PayType,
TradeType: in.TradeType,
PayAmount: in.Money,
ReturnUrl: in.ReturnUrl,
})
if err != nil {
return err
}
res.Order = create.Order
return
})
return
}
// List 获取充值订单列表
func (s *sAdminOrder) List(ctx context.Context, in *adminin.OrderListInp) (list []*adminin.OrderListModel, totalCount int, err error) {
mod := s.Model(ctx)
// 查询业务订单号
if in.OrderSn != "" {
mod = mod.WhereLike(dao.AdminOrder.Columns().OrderSn, in.OrderSn)
}
// 查询状态
if in.Status > 0 {
mod = mod.Where(dao.AdminOrder.Columns().Status, in.Status)
}
// 查询创建时间
if len(in.CreatedAt) == 2 {
mod = mod.WhereBetween(dao.AdminOrder.Columns().CreatedAt, in.CreatedAt[0], in.CreatedAt[1])
}
// 查询商户订单号
if in.PayLogOutTradeNo != "" {
mod = mod.WhereLike(dao.PayLog.Columns().OutTradeNo, in.PayLogOutTradeNo)
}
if in.MemberId > 0 {
mod = mod.Where(dao.AdminOrder.Columns().MemberId, in.MemberId)
}
// 下单用户筛选
if len(in.ComplexMemberId) == 2 && len(in.ComplexMemberId[0]) > 0 {
memberIds, err := service.AdminMember().GetComplexMemberIds(ctx, in.ComplexMemberId[0], in.ComplexMemberId[1])
if err != nil {
return nil, 0, err
}
if len(memberIds) == 0 {
return nil, 0, nil
}
mod = mod.WhereIn(dao.AdminOrder.Columns().MemberId, memberIds)
}
mod = mod.LeftJoin(hgorm.GenJoinOnRelation(
dao.AdminOrder.Table(), dao.AdminOrder.Columns().OrderSn, // 主表表名,关联条件
dao.PayLog.Table(), "payLog", dao.PayLog.Columns().OrderSn, // 关联表表名,别名,关联条件
)...)
// 操作人摘要信息
mod = mod.Hook(hook.MemberSummary)
totalCount, err = mod.Clone().Count()
if err != nil {
return
}
if totalCount == 0 {
return
}
// 关联表select
fields, err := hgorm.GenJoinSelect(ctx, adminin.OrderListModel{}, &dao.AdminOrder, []*hgorm.Join{
{Dao: &dao.PayLog, Alias: "payLog"},
})
if err != nil {
return
}
err = mod.Fields(fields).Page(in.Page, in.PerPage).OrderDesc(dao.AdminOrder.Columns().Id).Scan(&list)
return
}
// Export 导出充值订单
func (s *sAdminOrder) Export(ctx context.Context, in *adminin.OrderListInp) (err error) {
list, totalCount, err := s.List(ctx, in)
if err != nil {
return
}
// 字段的排序是依据tags的字段顺序，如果你不想使用默认的排序方式，可以直接定义 tags = []string{"字段名称", "字段名称2", ...}
tags, err := convert.GetEntityDescTags(adminin.OrderExportModel{})
if err != nil {
return
}
var (
fileName = "导出充值订单-" + gctx.CtxId(ctx)
sheetName = fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, form.CalPageCount(totalCount, in.PerPage), in.Page, len(list))
exports []adminin.OrderExportModel
)
if err = gconv.Scan(list, &exports); err != nil {
return
}
err = excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
return
}
// Edit 修改/新增充值订单
func (s *sAdminOrder) Edit(ctx context.Context, in *adminin.OrderEditInp) (err error) {
// 修改
if in.Id > 0 {
_, err = s.Model(ctx).
FieldsEx(
dao.AdminOrder.Columns().Id,
dao.AdminOrder.Columns().CreatedAt,
).
Where(dao.AdminOrder.Columns().Id, in.Id).Data(in).Update()
return
}
// 新增
_, err = s.Model(ctx, &handler.Option{FilterAuth: false}).
FieldsEx(
dao.AdminOrder.Columns().Id,
).
Data(in).OmitEmptyData().Insert()
return
}
// Delete 删除充值订单
func (s *sAdminOrder) Delete(ctx context.Context, in *adminin.OrderDeleteInp) (err error) {
_, err = s.Model(ctx).
Where(dao.AdminOrder.Columns().Id, in.Id).
Where(dao.AdminOrder.Columns().Status, consts.OrderStatusClose).
Delete()
return
}
// View 获取充值订单指定信息
func (s *sAdminOrder) View(ctx context.Context, in *adminin.OrderViewInp) (res *adminin.OrderViewModel, err error) {
err = s.Model(ctx).Where(dao.AdminOrder.Columns().Id, in.Id).Scan(&res)
return
}
// Status 更新充值订单状态
func (s *sAdminOrder) Status(ctx context.Context, in *adminin.OrderStatusInp) (err error) {
if in.Id <= 0 {
err = gerror.New("ID不能为空")
return
}
if in.Status <= 0 {
err = gerror.New("状态不能为空")
return
}
if !validate.InSlice(consts.StatusSlice, in.Status) {
err = gerror.New("状态不正确")
return
}
_, err = s.Model(ctx).Where(dao.AdminOrder.Columns().Id, in.Id).Data(g.Map{
dao.AdminOrder.Columns().Status: in.Status,
}).Update()
return
}
server/internal/logic/admin/post.go
+202
View File
@@ -0,0 +1,202 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/dict"
"hotgo/internal/library/hgorm"
"hotgo/internal/model"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
)
type sAdminPost struct{}
func NewAdminPost() *sAdminPost {
return &sAdminPost{}
}
func init() {
service.RegisterAdminPost(NewAdminPost())
dict.RegisterFunc("adminPostOption", "岗位选项", service.AdminPost().Option)
}
// Delete 删除
func (s *sAdminPost) Delete(ctx context.Context, in *adminin.PostDeleteInp) (err error) {
exist, err := dao.AdminMemberPost.Ctx(ctx).Where(dao.AdminMemberPost.Columns().PostId, in.Id).One()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
if !exist.IsEmpty() {
return gerror.New("请先解除该岗位下所有已关联用户关联关系！")
}
_, err = dao.AdminPost.Ctx(ctx).WherePri(in.Id).Delete()
return
}
// VerifyUnique 验证部门唯一属性
func (s *sAdminPost) VerifyUnique(ctx context.Context, in *adminin.VerifyUniqueInp) (err error) {
if in.Where == nil {
return
}
cols := dao.AdminPost.Columns()
msgMap := g.MapStrStr{
cols.Name: "岗位名称已存在，请换一个",
cols.Code: "岗位编码已存在，请换一个",
}
for k, v := range in.Where {
if v == "" {
continue
}
message, ok := msgMap[k]
if !ok {
err = gerror.Newf("字段 [ %v ] 未配置唯一属性验证", k)
return
}
if err = hgorm.IsUnique(ctx, &dao.AdminPost, g.Map{k: v}, message, in.Id); err != nil {
return
}
}
return
}
// Edit 修改/新增
func (s *sAdminPost) Edit(ctx context.Context, in *adminin.PostEditInp) (err error) {
// 验证唯一性
err = s.VerifyUnique(ctx, &adminin.VerifyUniqueInp{
Id: in.Id,
Where: g.Map{
dao.AdminPost.Columns().Name: in.Name,
dao.AdminPost.Columns().Code: in.Code,
},
})
if err != nil {
return
}
// 修改
if in.Id > 0 {
_, err = dao.AdminPost.Ctx(ctx).WherePri(in.Id).Data(in).Update()
return
}
// 新增
_, err = dao.AdminPost.Ctx(ctx).Data(in).OmitEmptyData().Insert()
return
}
// MaxSort 最大排序
func (s *sAdminPost) MaxSort(ctx context.Context, in *adminin.PostMaxSortInp) (res *adminin.PostMaxSortModel, err error) {
if in.Id > 0 {
if err = dao.AdminPost.Ctx(ctx).WherePri(in.Id).OrderDesc(dao.AdminPost.Columns().Sort).Scan(&res); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
}
if res == nil {
res = new(adminin.PostMaxSortModel)
}
res.Sort = form.DefaultMaxSort(res.Sort)
return
}
// View 获取指定岗位信息
func (s *sAdminPost) View(ctx context.Context, in *adminin.PostViewInp) (res *adminin.PostViewModel, err error) {
err = dao.AdminPost.Ctx(ctx).WherePri(in.Id).Scan(&res)
return
}
// List 获取列表
func (s *sAdminPost) List(ctx context.Context, in *adminin.PostListInp) (list []*adminin.PostListModel, totalCount int, err error) {
mod := dao.AdminPost.Ctx(ctx)
cols := dao.AdminPost.Columns()
// 访问路径
if in.Name != "" {
mod = mod.WhereLike(cols.Name, "%"+in.Name+"%")
}
// 模块
if in.Code != "" {
mod = mod.Where(cols.Code, in.Code)
}
// 请求方式
if in.Status > 0 {
mod = mod.Where(cols.Status, in.Status)
}
if len(in.CreatedAt) == 2 {
mod = mod.WhereBetween(cols.CreatedAt, in.CreatedAt[0], in.CreatedAt[1])
}
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, "获取岗位列表失败！")
return
}
if totalCount == 0 {
return
}
err = mod.Page(in.Page, in.PerPage).OrderAsc(cols.Sort).Scan(&list)
return
}
// Option 岗位选项
func (s *sAdminPost) Option(ctx context.Context) (opts []*model.Option, err error) {
var list []*entity.AdminPost
if err = dao.AdminPost.Ctx(ctx).OrderAsc(dao.AdminPost.Columns().Sort).Scan(&list); err != nil {
return nil, err
}
if len(list) == 0 {
opts = make([]*model.Option, 0)
return
}
for _, v := range list {
opts = append(opts, dict.GenHashOption(v.Id, v.Name))
}
return
}
// GetMemberByStartName 获取指定用户的第一岗位
func (s *sAdminPost) GetMemberByStartName(ctx context.Context, memberId int64) (name string, err error) {
// 默认取第一岗位
postId, err := dao.AdminMemberPost.Ctx(ctx).Fields(dao.AdminMemberPost.Columns().PostId).Where(dao.AdminMemberPost.Columns().MemberId, memberId).Limit(1).Value()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
val, err := dao.AdminPost.Ctx(ctx).Fields(dao.AdminPost.Columns().Name).WherePri(postId.Int()).OrderDesc(dao.AdminPost.Columns().Id).Value()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
return val.String(), nil
}
// Status 更新状态
func (s *sAdminPost) Status(ctx context.Context, in *adminin.PostStatusInp) (err error) {
_, err = dao.AdminPost.Ctx(ctx).WherePri(in.Id).Data(dao.AdminPost.Columns().Status, in.Status).Update()
return
}
server/internal/logic/admin/role.go
+481
View File
@@ -0,0 +1,481 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2025 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/casbin"
"hotgo/internal/library/contexts"
"hotgo/internal/library/hgorm"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/form"
"hotgo/internal/service"
"hotgo/utility/convert"
"hotgo/utility/tree"
"hotgo/utility/validate"
"sort"
"strings"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/util/gconv"
)
type sAdminRole struct{}
func NewAdminRole() *sAdminRole {
return &sAdminRole{}
}
func init() {
service.RegisterAdminRole(NewAdminRole())
}
// Verify 验证权限
func (s *sAdminRole) Verify(ctx context.Context, path, method string) bool {
var (
user = contexts.Get(ctx).User
err error
)
if user == nil {
g.Log().Info(ctx, "admin Verify user = nil")
return false
}
if service.AdminMember().VerifySuperId(ctx, user.Id) {
return true
}
ok, err := casbin.Enforcer.Enforce(user.RoleKey, path, method)
if err != nil {
g.Log().Infof(ctx, "admin Verify Enforce err:%+v", err)
return false
}
return ok
}
// List 获取列表
func (s *sAdminRole) List(ctx context.Context, in *adminin.RoleListInp) (res *adminin.RoleListModel, totalCount int, err error) {
var (
mod = dao.AdminRole.Ctx(ctx)
models []*entity.AdminRole
pid int64 = 0
)
// 非超管只获取下级角色
if !service.AdminMember().VerifySuperId(ctx, contexts.GetUserId(ctx)) {
pid = contexts.GetRoleId(ctx)
mod = mod.WhereLike(dao.AdminRole.Columns().Tree, "%"+tree.GetIdLabel(pid)+"%")
}
totalCount, err = mod.Count()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if err = mod.Page(in.Page, in.PerPage).Order("sort asc,id asc").Scan(&models); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
res = new(adminin.RoleListModel)
res.List = s.treeList(pid, models)
return
}
// GetName 获取指定角色的名称
func (s *sAdminRole) GetName(ctx context.Context, id int64) (name string, err error) {
r, err := dao.AdminRole.Ctx(ctx).Fields(dao.AdminRole.Columns().Name).WherePri(id).OrderDesc(dao.AdminRole.Columns().Id).Value()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
return r.String(), nil
}
// GetMemberList 获取指定用户的岗位列表
func (s *sAdminRole) GetMemberList(ctx context.Context, id int64) (list []*adminin.RoleListModel, err error) {
if err = dao.AdminRole.Ctx(ctx).WherePri(id).OrderDesc(dao.AdminRole.Columns().Id).Scan(&list); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
}
return
}
// GetPermissions 更改角色菜单权限
func (s *sAdminRole) GetPermissions(ctx context.Context, in *adminin.GetPermissionsInp) (res *adminin.GetPermissionsModel, err error) {
role, err := s.getManageableRole(ctx, in.RoleId)
if err != nil {
return nil, err
}
allowedMenuIds, err := s.getAssignableMenuIds(ctx, role)
if err != nil {
return nil, err
}
values, err := dao.AdminRoleMenu.Ctx(ctx).Fields(dao.AdminRoleMenu.Columns().MenuId).Where(dao.AdminRoleMenu.Columns().RoleId, in.RoleId).Array()
if err != nil {
return
}
res = new(adminin.GetPermissionsModel)
res.MenuIds = make([]int64, 0, len(values))
res.AllowedMenuIds = allowedMenuIds
allowedSet := make(map[int64]struct{}, len(allowedMenuIds))
for _, id := range allowedMenuIds {
allowedSet[id] = struct{}{}
}
for i := 0; i < len(values); i++ {
id := values[i].Int64()
if _, ok := allowedSet[id]; ok {
res.MenuIds = append(res.MenuIds, id)
}
}
return
}
// UpdatePermissions 更改角色菜单权限
func (s *sAdminRole) UpdatePermissions(ctx context.Context, in *adminin.UpdatePermissionsInp) (err error) {
role, err := s.getManageableRole(ctx, in.RoleId)
if err != nil {
return err
}
allowedMenuIds, err := s.getAssignableMenuIds(ctx, role)
if err != nil {
return err
}
allowedSet := make(map[int64]struct{}, len(allowedMenuIds))
for _, id := range allowedMenuIds {
allowedSet[id] = struct{}{}
}
in.MenuIds = convert.UniqueSlice(in.MenuIds)
for _, id := range in.MenuIds {
if _, ok := allowedSet[id]; !ok {
return gerror.New("所选菜单超出上级角色的授权范围")
}
}
err = dao.AdminRoleMenu.Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
if _, err = dao.AdminRoleMenu.Ctx(ctx).Where(dao.AdminRoleMenu.Columns().RoleId, in.RoleId).Delete(); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if len(in.MenuIds) == 0 {
return
}
list := make(g.List, 0, len(in.MenuIds))
for _, v := range in.MenuIds {
list = append(list, g.Map{
"role_id": in.RoleId,
"menu_id": v,
})
}
if _, err = dao.AdminRoleMenu.Ctx(ctx).Data(list).OmitEmptyData().Insert(); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
return
})
if err != nil {
return
}
return casbin.Refresh(ctx)
}
// getManageableRole 获取当前管理员有权维护的角色。
func (s *sAdminRole) getManageableRole(ctx context.Context, roleId int64) (*entity.AdminRole, error) {
if roleId <= 0 {
return nil, gerror.New("角色ID不正确")
}
var role *entity.AdminRole
if err := dao.AdminRole.Ctx(ctx).WherePri(roleId).Scan(&role); err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
if role == nil {
return nil, gerror.New("角色不存在")
}
if service.AdminMember().VerifySuperId(ctx, contexts.GetUserId(ctx)) {
return role, nil
}
if role.Id == contexts.GetRoleId(ctx) || !strings.Contains(role.Tree, tree.GetIdLabel(contexts.GetRoleId(ctx))) {
return nil, gerror.New("无权维护该角色")
}
return role, nil
}
// getAssignableMenuIds 子角色最多只能继承其直接父角色拥有的菜单权限。
func (s *sAdminRole) getAssignableMenuIds(ctx context.Context, role *entity.AdminRole) ([]int64, error) {
if role.Pid <= 0 {
values, err := dao.AdminMenu.Ctx(ctx).Fields(dao.AdminMenu.Columns().Id).Where(dao.AdminMenu.Columns().Status, consts.StatusEnabled).Array()
if err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
return gconv.SliceInt64(values), nil
}
var parent *entity.AdminRole
if err := dao.AdminRole.Ctx(ctx).WherePri(role.Pid).Scan(&parent); err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
if parent == nil {
return nil, gerror.New("上级角色不存在")
}
if parent.Key == consts.SuperRoleKey {
values, err := dao.AdminMenu.Ctx(ctx).Fields(dao.AdminMenu.Columns().Id).Where(dao.AdminMenu.Columns().Status, consts.StatusEnabled).Array()
if err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
return gconv.SliceInt64(values), nil
}
values, err := dao.AdminRoleMenu.Ctx(ctx).
Fields(dao.AdminRoleMenu.Columns().MenuId).
Where(dao.AdminRoleMenu.Columns().RoleId, parent.Id).
Array()
if err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
return s.expandMenuAncestors(ctx, gconv.SliceInt64(values))
}
// expandMenuAncestors 补齐已授权菜单的目录链，避免子菜单可用但上级目录无法勾选。
func (s *sAdminRole) expandMenuAncestors(ctx context.Context, menuIds []int64) ([]int64, error) {
var menus []*entity.AdminMenu
if err := dao.AdminMenu.Ctx(ctx).
Fields(dao.AdminMenu.Columns().Id, dao.AdminMenu.Columns().Pid).
Where(dao.AdminMenu.Columns().Status, consts.StatusEnabled).
Scan(&menus); err != nil {
return nil, gerror.Wrap(err, consts.ErrorORM)
}
parentById := make(map[int64]int64, len(menus))
for _, menu := range menus {
parentById[menu.Id] = menu.Pid
}
allowed := make(map[int64]struct{}, len(menuIds))
for _, menuId := range menuIds {
current := menuId
for current > 0 {
if _, exists := allowed[current]; exists {
break
}
parentId, exists := parentById[current]
if !exists {
break
}
allowed[current] = struct{}{}
current = parentId
}
}
result := make([]int64, 0, len(allowed))
for menuId := range allowed {
result = append(result, menuId)
}
sort.Slice(result, func(i, j int) bool { return result[i] < result[j] })
return result, nil
}
func (s *sAdminRole) Edit(ctx context.Context, in *adminin.RoleEditInp) (err error) {
if err = hgorm.IsUnique(ctx, &dao.AdminRole, g.Map{dao.AdminRole.Columns().Name: in.Name}, "名称已存在", in.Id); err != nil {
return
}
if err = hgorm.IsUnique(ctx, &dao.AdminRole, g.Map{dao.AdminRole.Columns().Key: in.Key}, "编码已存在", in.Id); err != nil {
return
}
if in.Pid, in.Level, in.Tree, err = hgorm.GenSubTree(ctx, &dao.AdminRole, in.Pid); err != nil {
return
}
// 修改
if in.Id > 0 {
err = dao.AdminRole.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
// 更新数据
_, err = dao.AdminRole.Ctx(ctx).Fields(adminin.RoleUpdateFields{}).WherePri(in.Id).Data(in).Update()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return err
}
// 如果当前角色有子级,更新子级tree关系树
return updateRoleChildrenTree(ctx, in.Id, in.Level, in.Tree)
})
return
}
// 新增
if _, err = dao.AdminRole.Ctx(ctx).Fields(adminin.RoleInsertFields{}).Data(in).OmitEmptyData().Insert(); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
return
}
func updateRoleChildrenTree(ctx context.Context, _id int64, _level int, _tree string) (err error) {
var list []*entity.AdminRole
if err = dao.AdminRole.Ctx(ctx).Where("pid", _id).Scan(&list); err != nil {
return
}
for _, child := range list {
child.Level = _level + 1
child.Tree = tree.GenLabel(_tree, child.Pid)
if _, err = dao.AdminRole.Ctx(ctx).Where("id", child.Id).Data("level", child.Level, "tree", child.Tree).Update(); err != nil {
return
}
if err = updateRoleChildrenTree(ctx, child.Id, child.Level, child.Tree); err != nil {
return
}
}
return
}
func (s *sAdminRole) Delete(ctx context.Context, in *adminin.RoleDeleteInp) (err error) {
var models *entity.AdminRole
if err = dao.AdminRole.Ctx(ctx).Where("id", in.Id).Scan(&models); err != nil {
return
}
if models == nil {
return gerror.New("数据不存在或已删除！")
}
if models.Key == consts.SuperRoleKey {
return gerror.New("超管角色禁止删除！")
}
exist, err := dao.AdminRole.Ctx(ctx).Where("pid", models.Id).Exist()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if exist {
return gerror.New("请先删除该角色下得所有子级！")
}
exist, err = dao.AdminMember.Ctx(ctx).Where("role_id", models.Id).Exist()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if exist {
return gerror.New("请先删除该角色下得所有用户账号！")
}
if _, err = dao.AdminRole.Ctx(ctx).Where("id", in.Id).Delete(); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
}
return
}
func (s *sAdminRole) DataScopeSelect() (res form.Selects) {
for k, v := range consts.RoleDataNameMap {
res = append(res, &form.Select{
Value: k,
Name: v,
Label: v,
})
}
sort.Sort(res)
return res
}
func (s *sAdminRole) DataScopeEdit(ctx context.Context, in *adminin.DataScopeEditInp) (err error) {
var models *entity.AdminRole
if err = dao.AdminRole.Ctx(ctx).Where("id", in.Id).Scan(&models); err != nil {
return
}
if models == nil {
return gerror.New("角色不存在")
}
if models.Key == consts.SuperRoleKey {
return gerror.New("超管角色拥有全部权限，无需修改！")
}
if in.DataScope == consts.RoleDataDeptCustom && len(convert.UniqueSlice(in.CustomDept)) == 0 {
return gerror.New("自定义权限必须配置自定义部门！")
}
models.DataScope = in.DataScope
models.CustomDept = gjson.New(convert.UniqueSlice(in.CustomDept))
_, err = dao.AdminRole.Ctx(ctx).
Fields(dao.AdminRole.Columns().DataScope, dao.AdminRole.Columns().CustomDept).
Where("id", in.Id).
Data(models).
Update()
return
}
// treeList 角色树列表
func (s *sAdminRole) treeList(pid int64, nodes []*entity.AdminRole) (list []*adminin.RoleTree) {
list = make([]*adminin.RoleTree, 0)
for _, v := range nodes {
if v.Pid == pid {
item := new(adminin.RoleTree)
item.AdminRole = *v
item.Label = v.Name
item.Value = v.Id
child := s.treeList(v.Id, nodes)
if len(child) > 0 {
item.Children = child
}
list = append(list, item)
}
}
return
}
// VerifyRoleId 验证角色ID
func (s *sAdminRole) VerifyRoleId(ctx context.Context, id int64) (err error) {
mb := contexts.GetUser(ctx)
if mb == nil {
err = gerror.New("用户信息获取失败！")
return
}
ids, err := s.GetSubRoleIds(ctx, mb.RoleId, service.AdminMember().VerifySuperId(ctx, mb.Id))
if err != nil {
err = gerror.New("验证角色信息失败！")
return
}
if !validate.InSlice(ids, id) {
err = gerror.New("角色ID是无效的")
return
}
return
}
// GetSubRoleIds 获取所有下级角色ID
func (s *sAdminRole) GetSubRoleIds(ctx context.Context, roleId int64, isSuper bool) (ids []int64, err error) {
mod := dao.AdminRole.Ctx(ctx).Fields(dao.AdminRole.Columns().Id)
if !isSuper {
mod = mod.WhereNot(dao.AdminRole.Columns().Id, roleId).WhereLike(dao.AdminRole.Columns().Tree, "%"+tree.GetIdLabel(roleId)+"%")
}
columns, err := mod.Array()
if err != nil {
return nil, err
}
ids = g.NewVar(columns).Int64s()
return
}
server/internal/logic/admin/site.go
+338
View File
@@ -0,0 +1,338 @@
// Package admin
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package admin
import (
"context"
"hotgo/internal/consts"
"hotgo/internal/dao"
"hotgo/internal/library/contexts"
"hotgo/internal/library/token"
"hotgo/internal/model"
"hotgo/internal/model/entity"
"hotgo/internal/model/input/adminin"
"hotgo/internal/model/input/sysin"
"hotgo/internal/service"
"hotgo/utility/simple"
"github.com/gogf/gf/v2/crypto/gmd5"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/grand"
)
type sAdminSite struct{}
func NewAdminSite() *sAdminSite {
return &sAdminSite{}
}
func init() {
service.RegisterAdminSite(NewAdminSite())
}
// Register 账号注册
func (s *sAdminSite) Register(ctx context.Context, in *adminin.RegisterInp) (err error) {
config, err := service.SysConfig().GetLogin(ctx)
if err != nil {
return
}
if config.ForceInvite == 1 && in.InviteCode == "" {
err = gerror.New("请填写邀请码")
return
}
var data adminin.MemberAddInp
// 默认上级
data.Pid = 1
// 存在邀请人
if in.InviteCode != "" {
pmb, err := service.AdminMember().GetIdByCode(ctx, &adminin.GetIdByCodeInp{Code: in.InviteCode})
if err != nil {
return err
}
if pmb == nil {
err = gerror.New("邀请人信息不存在")
return err
}
data.Pid = pmb.Id
}
if config.RegisterSwitch != 1 {
err = gerror.New("管理员未开放注册")
return
}
if config.RoleId < 1 {
err = gerror.New("管理员未配置默认角色")
return
}
if config.DeptId < 1 {
err = gerror.New("管理员未配置默认部门")
return
}
// 验证唯一性
err = service.AdminMember().VerifyUnique(ctx, &adminin.VerifyUniqueInp{
Where: g.Map{
dao.AdminMember.Columns().Username: in.Username,
dao.AdminMember.Columns().Mobile: in.Mobile,
},
})
if err != nil {
return
}
// 验证短信验证码
err = service.SysSmsLog().VerifyCode(ctx, &sysin.VerifyCodeInp{
Event: consts.SmsTemplateRegister,
Mobile: in.Mobile,
Code: in.Code,
})
if err != nil {
return
}
data.MemberEditInp = &adminin.MemberEditInp{
Id: 0,
RoleId: config.RoleId,
PostIds: config.PostIds,
DeptId: config.DeptId,
Username: in.Username,
Password: in.Password,
RealName: "",
Avatar: config.Avatar,
Sex: 3, // 保密
Mobile: in.Mobile,
Status: consts.StatusEnabled,
}
data.Salt = grand.S(6)
data.InviteCode = grand.S(12)
data.PasswordHash = gmd5.MustEncryptString(data.Password + data.Salt)
data.Level, data.Tree, err = service.AdminMember().GenTree(ctx, data.Pid)
if err != nil {
return
}
// 提交注册信息
return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
id, err := dao.AdminMember.Ctx(ctx).Data(data).OmitEmptyData().InsertAndGetId()
if err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
// 更新岗位
if err = service.AdminMemberPost().UpdatePostIds(ctx, id, config.PostIds); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
}
return
})
}
// AccountLogin 账号登录
func (s *sAdminSite) AccountLogin(ctx context.Context, in *adminin.AccountLoginInp) (res *adminin.LoginModel, err error) {
defer func() {
service.SysLoginLog().Push(ctx, &sysin.LoginLogPushInp{Response: res, Err: err})
}()
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).Where("username", in.Username).Scan(&mb); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if mb == nil {
err = gerror.New("用户名或密码错误")
return
}
res = new(adminin.LoginModel)
res.Id = mb.Id
res.Username = mb.Username
if mb.Salt == "" {
err = gerror.New("用户信息错误")
return
}
if err = simple.CheckPassword(in.Password, mb.Salt, mb.PasswordHash); err != nil {
return
}
if mb.Status != consts.StatusEnabled {
err = gerror.New("账号已被禁用")
return
}
res, err = s.handleLogin(ctx, mb)
return
}
// MobileLogin 手机号登录
func (s *sAdminSite) MobileLogin(ctx context.Context, in *adminin.MobileLoginInp) (res *adminin.LoginModel, err error) {
defer func() {
service.SysLoginLog().Push(ctx, &sysin.LoginLogPushInp{Response: res, Err: err})
}()
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).Where("mobile ", in.Mobile).Scan(&mb); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if mb == nil {
err = gerror.New("账号不存在")
return
}
res = new(adminin.LoginModel)
res.Id = mb.Id
res.Username = mb.Username
err = service.SysSmsLog().VerifyCode(ctx, &sysin.VerifyCodeInp{
Event: consts.SmsTemplateLogin,
Mobile: in.Mobile,
Code: in.Code,
})
if err != nil {
return
}
if mb.Status != consts.StatusEnabled {
err = gerror.New("账号已被禁用")
return
}
res, err = s.handleLogin(ctx, mb)
return
}
// handleLogin .
func (s *sAdminSite) handleLogin(ctx context.Context, mb *entity.AdminMember) (res *adminin.LoginModel, err error) {
role, dept, err := s.getLoginRoleAndDept(ctx, mb.RoleId, mb.DeptId)
if err != nil {
return nil, err
}
user := &model.Identity{
Id: mb.Id,
Pid: mb.Pid,
DeptId: dept.Id,
DeptType: dept.Type,
RoleId: role.Id,
RoleKey: role.Key,
Username: mb.Username,
RealName: mb.RealName,
Avatar: mb.Avatar,
Email: mb.Email,
Mobile: mb.Mobile,
App: consts.AppAdmin,
LoginAt: gtime.Now(),
}
lt, expires, err := token.Login(ctx, user)
if err != nil {
return nil, err
}
res = &adminin.LoginModel{
Username: user.Username,
Id: user.Id,
Token: lt,
Expires: expires,
}
return
}
// getLoginRoleAndDept 获取登录的角色和部门信息
func (s *sAdminSite) getLoginRoleAndDept(ctx context.Context, roleId, deptId int64) (role *entity.AdminRole, dept *entity.AdminDept, err error) {
if err = dao.AdminRole.Ctx(ctx).Fields(dao.AdminRole.Columns().Id, dao.AdminRole.Columns().Key, dao.AdminRole.Columns().Status).WherePri(roleId).Scan(&role); err != nil {
err = gerror.Wrap(err, consts.ErrorORM)
return
}
if role == nil {
err = gerror.New("角色不存在或已被删除")
return
}
if role.Status != consts.StatusEnabled {
err = gerror.New("角色已被禁用，如有疑问请联系管理员")
return
}
if err = dao.AdminDept.Ctx(ctx).Fields(dao.AdminDept.Columns().Id, dao.AdminDept.Columns().Type, dao.AdminDept.Columns().Status).WherePri(deptId).Scan(&dept); err != nil {
err = gerror.Wrap(err, "获取部门信息失败，请稍后重试！")
return
}
if dept == nil {
err = gerror.New("部门不存在或已被删除")
return
}
if dept.Status != consts.StatusEnabled {
err = gerror.New("部门已被禁用，如有疑问请联系管理员")
return
}
return
}
// BindUserContext 绑定用户上下文
func (s *sAdminSite) BindUserContext(ctx context.Context, claims *model.Identity) (err error) {
//// 如果不想每次访问都重新加载用户信息，可以放开注释。但在本次登录未失效前，用户信息不会刷新
// contexts.SetUser(ctx, claims)
// return
var mb *entity.AdminMember
if err = dao.AdminMember.Ctx(ctx).WherePri(claims.Id).Scan(&mb); err != nil {
err = gerror.Wrap(err, "获取用户信息失败，请稍后重试！")
return
}
if mb == nil {
err = gerror.Wrap(err, "账号不存在或已被删除！")
return
}
if mb.Status != consts.StatusEnabled {
err = gerror.New("账号已被禁用，如有疑问请联系管理员")
return
}
role, dept, err := s.getLoginRoleAndDept(ctx, mb.RoleId, mb.DeptId)
if err != nil {
return err
}
user := &model.Identity{
Id: mb.Id,
Pid: mb.Pid,
DeptId: dept.Id,
DeptType: dept.Type,
RoleId: mb.RoleId,
RoleKey: role.Key,
Username: mb.Username,
RealName: mb.RealName,
Avatar: mb.Avatar,
Email: mb.Email,
Mobile: mb.Mobile,
App: claims.App,
LoginAt: claims.LoginAt,
}
contexts.SetUser(ctx, user)
return
}