Files
bj_power/bj_power_mes/internal/logic/auth.go
T

627 lines
21 KiB
Go
Raw Normal View History

2026-08-28 15:06:01 +08:00
package logic
import (
"context"
"crypto/rand"
"encoding/hex"
2026-08-28 15:06:01 +08:00
"errors"
"fmt"
2026-08-28 15:06:01 +08:00
"time"
tokenx "bj_power_mes/common/token"
"bj_power_mes/ent"
"bj_power_mes/ent/permission"
"bj_power_mes/ent/role"
"bj_power_mes/ent/station"
2026-08-28 15:06:01 +08:00
"bj_power_mes/ent/user"
"bj_power_mes/ent/userstation"
2026-08-28 15:06:01 +08:00
"golang.org/x/crypto/bcrypt"
)
// ------ 请求/返回 DTO ------
type LoginReq struct {
Username string `json:"username"`
Password string `json:"password"`
}
type LoginResp struct {
AccessToken string `json:"accessToken"`
AccessExpire int64 `json:"accessExpire"`
}
// sessionExpire 会话闲置窗口(秒),默认 1 小时
func (s *Service) sessionExpire() int64 {
if s.ctx.Config.Auth.AccessExpire > 0 {
return s.ctx.Config.Auth.AccessExpire
}
return 3600
}
// newSessionID 生成后台登录会话标识(32 位 hex,随机 16 字节)
func newSessionID() string {
b := make([]byte, 16)
if _, err := rand.Read(b); err != nil {
return fmt.Sprintf("%d", time.Now().UnixNano())
}
return hex.EncodeToString(b)
}
// currentToken 签发 access token(滑动续签模式,无 refresh);sid=后台登录会话标识(互踢用,工位终端登录传空)
func (s *Service) issueTokens(usr *ent.User, roleEntity *ent.Role, sid string) (LoginResp, error) {
claims := tokenx.Claims{UserId: usr.ID, Username: usr.Username, Name: usr.Name, RoleId: usr.RoleId, Sid: sid}
if roleEntity != nil {
claims.RoleCode = roleEntity.Code
claims.RoleName = roleEntity.Name
}
expire := s.sessionExpire()
access, err := tokenx.Issue(s.ctx.Config.Auth.AccessSecret, time.Duration(expire)*time.Second, claims)
if err != nil {
return LoginResp{}, err
}
return LoginResp{AccessToken: access, AccessExpire: expire}, nil
2026-08-28 15:06:01 +08:00
}
type UserInfoResp struct {
UserId int `json:"userId"`
Username string `json:"username"`
Name string `json:"name"`
RoleId int `json:"roleId"`
RoleCode string `json:"roleCode"`
RoleName string `json:"roleName"`
Menus []permissionItem `json:"menus"`
PermissionCodes []string `json:"permissionCodes"`
}
type ChangePasswordReq struct {
OldPassword string `json:"oldPassword"`
NewPassword string `json:"newPassword"`
}
2026-08-28 15:06:01 +08:00
type permissionItem struct {
Code string `json:"code"`
Name string `json:"name"`
Path string `json:"path"`
Icon string `json:"icon"`
}
// Login 登录
func (s *Service) Login(ctx context.Context, req LoginReq) (LoginResp, error) {
var resp LoginResp
usr, err := s.ctx.EntClient.User.Query().Where(user.Username(req.Username)).First(ctx)
if err != nil {
return resp, errors.New("用户名或密码错误")
}
if usr.Status != "ENABLED" {
return resp, errors.New("账号已禁用")
}
if bcrypt.CompareHashAndPassword([]byte(usr.Password), []byte(req.Password)) != nil {
return resp, errors.New("用户名或密码错误")
}
// 记录最近登录时间 + 写入新会话标识 activeToken=SID(同账号互踢:新登录顶掉旧后台会话;
// 工位终端登录走 StationLogin,不写本字段,互不影响。写失败不阻塞登录)
now := time.Now().Unix()
sid := newSessionID()
if err := s.ctx.EntClient.User.UpdateOneID(usr.ID).SetLastLoginAt(now).SetActiveToken(sid).Exec(ctx); err != nil {
// 不阻塞登录,仅记日志
}
usr.LastLoginAt = &now
2026-08-28 15:06:01 +08:00
roleEntity, _ := s.ctx.EntClient.Role.Get(ctx, usr.RoleId)
return s.issueTokens(usr, roleEntity, sid)
2026-08-28 15:06:01 +08:00
}
// UserInfo 当前用户信息 + 菜单权限
func (s *Service) UserInfo(ctx context.Context, userId int) (UserInfoResp, error) {
var out UserInfoResp
usr, err := s.ctx.EntClient.User.Get(ctx, userId)
if err != nil {
return out, err
}
out.UserId = usr.ID
out.Username = usr.Username
out.Name = usr.Name
out.RoleId = usr.RoleId
roleEntity, err := s.ctx.EntClient.Role.Get(ctx, usr.RoleId)
if err != nil {
roleEntity = nil
}
if roleEntity != nil {
out.RoleCode = roleEntity.Code
out.RoleName = roleEntity.Name
out.PermissionCodes = roleEntity.PermissionCodes
}
// 取所拥有权限对应的菜单
perms, err := s.ctx.EntClient.Permission.Query().
Where(permission.Type("MENU")).
Order(ent.Asc(permission.FieldSort)).All(ctx)
if err != nil {
return out, nil
}
owned := map[string]bool{}
for _, c := range out.PermissionCodes {
owned[c] = true
}
for _, p := range perms {
if roleEntity == nil {
continue
}
if roleEntity.Code == "SUPER_ADMIN" || owned[p.Code] || owned["*"] {
out.Menus = append(out.Menus, permissionItem{Code: p.Code, Name: p.Name, Path: p.Path, Icon: p.Icon})
}
}
return out, nil
}
// ChangePassword 当前登录用户修改自己的密码
func (s *Service) ChangePassword(ctx context.Context, userId int, req ChangePasswordReq) error {
if userId <= 0 {
return errors.New("未登录")
}
if req.OldPassword == "" || req.NewPassword == "" {
return errors.New("请输入旧密码与新密码")
}
if len(req.NewPassword) < 6 {
return errors.New("新密码长度至少 6 位")
}
2026-08-29 15:30:25 +08:00
if err := checkPasswordStrong(req.NewPassword); err != nil {
return err
}
usr, err := s.ctx.EntClient.User.Get(ctx, userId)
if err != nil {
return errors.New("用户不存在")
}
if bcrypt.CompareHashAndPassword([]byte(usr.Password), []byte(req.OldPassword)) != nil {
return errors.New("旧密码不正确")
}
hash, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
if err != nil {
return err
}
return s.ctx.EntClient.User.UpdateOneID(userId).SetPassword(string(hash)).Exec(ctx)
}
// ------ 工位终端登录(块1:用户体系来源于 MES,终端登录改调本接口) ------
type StationLoginReq struct {
Username string `json:"username"`
Password string `json:"password"`
StationNo int `json:"stationNo"`
}
type StationLoginResp struct {
AccessToken string `json:"accessToken"`
ExpireAt int64 `json:"expireAt"`
User UserInfoResp `json:"user"`
Stations []int `json:"stations"`
StationNo int `json:"stationNo"`
}
// StationOption 登录页工位选项(2026-11-09 拍板:未配置工位的终端登录页可选实体+虚拟工位)。
type StationOption struct {
StationNo int `json:"stationNo"`
Name string `json:"name"`
StationType string `json:"stationType"` // LINE 实体工位 / OFFLINE 虚拟工位(0 上线位、13 下线位)
}
// StationOptions 登录页可选工位清单:全部启用工位(实体+虚拟),按工位号升序。
// 未配置固定工位的终端在登录前调用(免用户态,X-API-TOKEN 保护)。
func (s *Service) StationOptions(ctx context.Context) ([]StationOption, error) {
sts, err := s.ctx.EntClient.Station.Query().
Where(station.Status("ENABLED")).Order(station.ByStationNo()).All(ctx)
if err != nil {
return nil, err
}
out := make([]StationOption, 0, len(sts))
for _, st := range sts {
out = append(out, StationOption{
StationNo: st.StationNo, Name: st.Name, StationType: st.StationType,
})
}
return out, nil
}
// StationLogin 工位终端登录:校验 用户名 + 工位终端密码 + 工位权限
func (s *Service) StationLogin(ctx context.Context, req StationLoginReq) (StationLoginResp, error) {
var resp StationLoginResp
if req.Username == "" || req.Password == "" {
return resp, errors.New("用户名和密码必填")
}
usr, err := s.ctx.EntClient.User.Query().Where(user.Username(req.Username)).First(ctx)
if err != nil {
return resp, errors.New("用户名或密码错误")
}
if usr.Status != "ENABLED" {
return resp, errors.New("账号已禁用")
}
if !usr.CanLoginWorkstation {
return resp, errors.New("该账号未开通工位终端登录权限")
}
if usr.WorkstationPassword == "" || bcrypt.CompareHashAndPassword([]byte(usr.WorkstationPassword), []byte(req.Password)) != nil {
return resp, errors.New("用户名或密码错误")
}
stations := s.UserStations(ctx, usr.ID)
if len(stations) == 0 {
// 未配置工位权限时兜底授权全部启用的非线下位工位(OFFLINE 类型不参与)
if dbStations, e := s.ctx.EntClient.Station.Query().
Where(station.StationTypeNEQ("OFFLINE"), station.Status("ENABLED")).All(ctx); e == nil {
for _, st := range dbStations {
stations = append(stations, st.StationNo)
}
}
if len(stations) == 0 {
for i := 1; i <= 12; i++ {
stations = append(stations, i)
}
}
}
if req.StationNo > 0 {
// 虚拟工位(线下位 OFFLINE)免工位权限校验(2026-11-11 多会话拍板):虚拟工位不连 PLC、
// 不占产线点位、仅记录作业,权限体系面向实体工位——任何已开通工位终端登录的账号均可登录。
// 存在性仍以 station 表为准(存在且 ENABLED 的 OFFLINE 才放行);实体工位保持原权限校验。
if st, gerr := s.ctx.EntClient.Station.Query().
Where(station.StationNo(req.StationNo)).First(ctx); gerr == nil && st.Status == "ENABLED" && st.StationType == "OFFLINE" {
// 放行
} else {
allowed := false
for _, no := range stations {
if no == req.StationNo {
allowed = true
break
}
}
if !allowed {
return resp, errors.New("该账号无此工位的操作权限")
}
}
}
roleEntity, _ := s.ctx.EntClient.Role.Get(ctx, usr.RoleId)
claims := tokenx.Claims{UserId: usr.ID, Username: usr.Username, Name: usr.Name, RoleId: usr.RoleId, StationNo: req.StationNo}
if roleEntity != nil {
claims.RoleCode = roleEntity.Code
claims.RoleName = roleEntity.Name
}
access, err := tokenx.Issue(s.ctx.Config.Auth.AccessSecret, time.Duration(s.ctx.Config.Auth.AccessExpire)*time.Second, claims)
if err != nil {
return resp, err
}
resp.AccessToken = access
resp.ExpireAt = time.Now().Add(time.Duration(s.ctx.Config.Auth.AccessExpire) * time.Second).Unix()
resp.User = UserInfoResp{UserId: usr.ID, Username: usr.Username, Name: usr.Name, RoleId: usr.RoleId}
if roleEntity != nil {
resp.User.RoleCode = roleEntity.Code
resp.User.RoleName = roleEntity.Name
}
resp.Stations = stations
resp.StationNo = req.StationNo
return resp, nil
}
// StationRefreshTokenResp 工位终端滑动续签响应
type StationRefreshTokenResp struct {
AccessToken string `json:"accessToken"`
ExpireAt int64 `json:"expireAt"`
}
// StationRefreshToken 工位终端滑动续签:校验当前登录态 JWT 有效后,原样重签新 JWT(延长有效期)。
// 终端任何人工触屏经前端 30 秒节流后调用,作业中令牌不再因固定有效期过期而被登出。
// 工位终端与 MES 同密钥,claims(含 StationNo)原样保留。
func (s *Service) StationRefreshToken(tokenStr string) (StationRefreshTokenResp, error) {
var resp StationRefreshTokenResp
claims, err := tokenx.Parse(s.ctx.Config.Auth.AccessSecret, tokenStr)
if err != nil || claims == nil {
return resp, errors.New("登录凭证无效或已过期,请重新登录")
}
expire := s.sessionExpire()
access, err := tokenx.Issue(s.ctx.Config.Auth.AccessSecret, time.Duration(expire)*time.Second, *claims)
if err != nil {
return resp, err
}
resp.AccessToken = access
resp.ExpireAt = time.Now().Add(time.Duration(expire) * time.Second).Unix()
return resp, nil
}
// StationChangePassword 工位终端修改自己的工位终端密码
func (s *Service) StationChangePassword(ctx context.Context, userId int, oldPwd, newPwd string) error {
if userId <= 0 {
return errors.New("未登录")
}
if oldPwd == "" || newPwd == "" {
return errors.New("请输入原密码与新密码")
}
if err := checkPasswordStrong(newPwd); err != nil {
return err
}
usr, err := s.ctx.EntClient.User.Get(ctx, userId)
if err != nil {
return errors.New("用户不存在")
}
if !usr.CanLoginWorkstation {
return errors.New("该账号未开通工位终端登录权限")
}
if bcrypt.CompareHashAndPassword([]byte(usr.WorkstationPassword), []byte(oldPwd)) != nil {
return errors.New("原工位终端密码不正确")
}
hash, _ := bcrypt.GenerateFromPassword([]byte(newPwd), bcrypt.DefaultCost)
return s.ctx.EntClient.User.UpdateOneID(userId).SetWorkstationPassword(string(hash)).Exec(ctx)
}
2026-08-28 15:06:01 +08:00
// ------ 用户 / 角色 / 权限 管理 ------
type UserReq struct {
Id int `json:"id"`
Username string `json:"username"`
Password string `json:"password"`
Name string `json:"name"`
RoleId int `json:"roleId"`
Status string `json:"status"`
CanLoginWorkstation bool `json:"canLoginWorkstation"`
WorkstationPassword string `json:"workstationPassword"`
Stations []int `json:"stations"` // 允许操作的工位号列表
2026-08-28 15:06:01 +08:00
}
2026-08-29 15:30:25 +08:00
// checkPasswordStrong 校验密码:长度>=6 且不能是纯数字
func checkPasswordStrong(pwd string) error {
if len(pwd) < 6 {
return errors.New("密码长度至少 6 位")
}
allDigit := true
for _, r := range pwd {
if r < '0' || r > '9' {
allDigit = false
break
}
}
if allDigit {
return errors.New("密码不能是纯数字")
}
return nil
}
2026-08-28 15:06:01 +08:00
func (s *Service) CreateUser(ctx context.Context, req UserReq) error {
2026-08-29 15:30:25 +08:00
if err := checkPasswordStrong(req.Password); err != nil {
return err
}
2026-08-28 15:06:01 +08:00
hash, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
status := req.Status
if status == "" {
status = "ENABLED"
}
create := s.ctx.EntClient.User.Create().
2026-08-28 15:06:01 +08:00
SetUsername(req.Username).
SetPassword(string(hash)).
SetName(req.Name).
SetRoleId(req.RoleId).
SetStatus(status).
SetCanLoginWorkstation(req.CanLoginWorkstation)
if req.CanLoginWorkstation {
wsPwd := req.WorkstationPassword
if wsPwd == "" {
wsPwd = req.Password // 默认复用登录密码
}
if err := checkPasswordStrong(wsPwd); err != nil {
return errors.New("工位终端密码" + err.Error())
}
wsHash, err := bcrypt.GenerateFromPassword([]byte(wsPwd), bcrypt.DefaultCost)
if err != nil {
return err
}
create.SetWorkstationPassword(string(wsHash))
}
usr, err := create.Save(ctx)
if err != nil {
return err
}
return s.replaceUserStations(ctx, usr.ID, req.Stations)
2026-08-28 15:06:01 +08:00
}
func (s *Service) UpdateUser(ctx context.Context, req UserReq) error {
// 仅内置管理员账号(username=admin)不允许通过管理接口修改;其余账号(含 SUPER_ADMIN 角色的用户)均可修改。
// 2026-09-28 修正:原按角色码 SUPER_ADMIN 锁定的规则过宽,导致普通新建账号被误锁、无法编辑/删除/改状态。
2026-09-03 18:13:59 +08:00
if usr, e := s.ctx.EntClient.User.Get(ctx, req.Id); e == nil {
if usr.Username == "admin" {
return errors.New("系统内置管理员账号不允许修改")
}
}
u := s.ctx.EntClient.User.UpdateOneID(req.Id).SetRoleId(req.RoleId).SetName(req.Name).
SetCanLoginWorkstation(req.CanLoginWorkstation)
2026-08-28 15:06:01 +08:00
if req.Password != "" {
2026-08-29 15:30:25 +08:00
if err := checkPasswordStrong(req.Password); err != nil {
return err
}
2026-08-28 15:06:01 +08:00
hash, _ := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
u.SetPassword(string(hash))
}
if req.CanLoginWorkstation {
if req.WorkstationPassword != "" {
if err := checkPasswordStrong(req.WorkstationPassword); err != nil {
return errors.New("工位终端密码" + err.Error())
}
wsHash, _ := bcrypt.GenerateFromPassword([]byte(req.WorkstationPassword), bcrypt.DefaultCost)
u.SetWorkstationPassword(string(wsHash))
}
} else {
u.SetWorkstationPassword("")
}
2026-08-28 15:06:01 +08:00
if req.Status != "" {
u.SetStatus(req.Status)
}
if err := u.Exec(ctx); err != nil {
return err
}
return s.replaceUserStations(ctx, req.Id, req.Stations)
}
// replaceUserStations 全量替换用户-工位关联
func (s *Service) replaceUserStations(ctx context.Context, userId int, stations []int) error {
if _, err := s.ctx.EntClient.UserStation.Delete().Where(userstation.UserId(userId)).Exec(ctx); err != nil {
return err
}
for _, no := range stations {
if no <= 0 {
continue
}
if err := s.ctx.EntClient.UserStation.Create().
SetUserId(userId).SetStationNo(no).Exec(ctx); err != nil {
return err
}
}
return nil
}
// UserStations 查询用户绑定的工位号
func (s *Service) UserStations(ctx context.Context, userId int) []int {
rows, _ := s.ctx.EntClient.UserStation.Query().
Where(userstation.UserId(userId)).All(ctx)
out := make([]int, 0, len(rows))
for _, r := range rows {
out = append(out, r.StationNo)
}
return out
2026-08-28 15:06:01 +08:00
}
func (s *Service) DeleteUser(ctx context.Context, id int) error {
2026-09-03 18:13:59 +08:00
usr, err := s.ctx.EntClient.User.Get(ctx, id)
if err != nil {
return errors.New("用户不存在")
}
// 仅内置管理员账号(username=admin)不允许删除;其余账号(含 SUPER_ADMIN 角色的用户)均可删除。
// 2026-09-28 修正:原按角色码 SUPER_ADMIN 锁定的规则过宽,导致普通新建账号被误锁、无法删除。
2026-09-03 18:13:59 +08:00
if usr.Username == "admin" {
return errors.New("系统内置管理员账号不允许删除")
}
2026-08-28 15:06:01 +08:00
return s.ctx.EntClient.User.DeleteOneID(id).Exec(ctx)
}
// UserVO 用户列表返回体(含工位终端属性与允许操作工位)
type UserVO struct {
Id int `json:"id"`
Username string `json:"username"`
Name string `json:"name"`
RoleId int `json:"roleId"`
Status string `json:"status"`
CanLoginWorkstation bool `json:"canLoginWorkstation"`
Stations []int `json:"stations"` // 允许登录/操作的工位号(空=全部工位)
LastLoginAt *int64 `json:"lastLoginAt"` // 最近登录时间(unix秒),null=从未登录
CreatedAt *time.Time `json:"createdAt"` // 创建时间
UpdatedAt *time.Time `json:"updatedAt"` // 更新时间
}
func (s *Service) ListUsers(ctx context.Context) ([]UserVO, error) {
usrs, err := s.ctx.EntClient.User.Query().Order(ent.Desc(user.FieldCreatedAt)).All(ctx)
if err != nil {
return nil, err
}
out := make([]UserVO, 0, len(usrs))
for _, u := range usrs {
out = append(out, UserVO{
Id: u.ID,
Username: u.Username,
Name: u.Name,
RoleId: u.RoleId,
Status: u.Status,
CanLoginWorkstation: u.CanLoginWorkstation,
Stations: s.UserStations(ctx, u.ID),
LastLoginAt: u.LastLoginAt,
CreatedAt: &u.CreatedAt,
UpdatedAt: u.UpdatedAt,
})
}
return out, nil
2026-08-28 15:06:01 +08:00
}
type RoleReq struct {
Id int `json:"id"`
Name string `json:"name"`
Code string `json:"code"`
Remark string `json:"remark"`
PermissionCodes []string `json:"permissionCodes"`
}
func (s *Service) CreateRole(ctx context.Context, req RoleReq) error {
return s.ctx.EntClient.Role.Create().
SetName(req.Name).SetCode(req.Code).SetRemark(req.Remark).
SetPermissionCodes(req.PermissionCodes).Exec(ctx)
}
func (s *Service) UpdateRole(ctx context.Context, req RoleReq) error {
2026-09-03 18:13:59 +08:00
// 内置管理员角色(SUPER_ADMIN)不允许修改其权限(admin 拥有所有权限,且不可被缩减)
rl, err := s.ctx.EntClient.Role.Get(ctx, req.Id)
if err != nil {
return errors.New("角色不存在")
}
if rl.Code == "SUPER_ADMIN" {
2026-09-03 18:13:59 +08:00
return errors.New("内置管理员角色不允许修改其权限")
}
// 角色编码创建后不可修改(对齐 WMS 语义;内置角色 code 变更会破坏权限体系)
if req.Code != "" && req.Code != rl.Code {
return errors.New("角色编码创建后不可修改")
}
2026-08-28 15:06:01 +08:00
return s.ctx.EntClient.Role.UpdateOneID(req.Id).
SetName(req.Name).SetCode(rl.Code).SetRemark(req.Remark).
2026-08-28 15:06:01 +08:00
SetPermissionCodes(req.PermissionCodes).Exec(ctx)
}
func (s *Service) DeleteRole(ctx context.Context, id int) error {
// 保护:不可删除内置角色(超级管理员/生产操作员/质检员)
2026-08-29 15:30:25 +08:00
r, err := s.ctx.EntClient.Role.Get(ctx, id)
if err != nil {
return errors.New("角色不存在")
}
if r.Code == "SUPER_ADMIN" || r.Code == "OPERATOR" || r.Code == "INSPECTOR" {
return errors.New("内置角色不允许删除")
2026-08-29 15:30:25 +08:00
}
// 保护:仍有关联用户的角色不可删除(避免产生无主用户/失去全部管理员)
cnt, err := s.ctx.EntClient.User.Query().
Where(user.RoleId(id)).Count(ctx)
if err == nil && cnt > 0 {
return errors.New("该角色下仍有用户,请先移除相关用户")
}
2026-08-28 15:06:01 +08:00
return s.ctx.EntClient.Role.DeleteOneID(id).Exec(ctx)
}
2026-10-26 16:32:35 +08:00
func (s *Service) ListRoles(ctx context.Context, keyword string) ([]*ent.Role, error) {
q := s.ctx.EntClient.Role.Query().Order(ent.Asc(role.FieldID))
if keyword != "" {
kw := keyword
q = q.Where(role.Or(role.NameContainsFold(kw), role.CodeContainsFold(kw)))
}
return q.All(ctx)
2026-08-28 15:06:01 +08:00
}
type PermissionReq struct {
Id int `json:"id"`
Code string `json:"code"`
Name string `json:"name"`
Type string `json:"type"`
Path string `json:"path"`
Icon string `json:"icon"`
Sort int `json:"sort"`
Remark string `json:"remark"`
}
func (s *Service) CreatePermission(ctx context.Context, req PermissionReq) error {
return s.ctx.EntClient.Permission.Create().
SetCode(req.Code).SetName(req.Name).SetType(req.Type).
SetPath(req.Path).SetIcon(req.Icon).SetSort(req.Sort).SetRemark(req.Remark).Exec(ctx)
}
func (s *Service) UpdatePermission(ctx context.Context, req PermissionReq) error {
return s.ctx.EntClient.Permission.UpdateOneID(req.Id).
SetCode(req.Code).SetName(req.Name).SetType(req.Type).
SetPath(req.Path).SetIcon(req.Icon).SetSort(req.Sort).SetRemark(req.Remark).Exec(ctx)
}
func (s *Service) DeletePermission(ctx context.Context, id int) error {
return s.ctx.EntClient.Permission.DeleteOneID(id).Exec(ctx)
}
func (s *Service) ListPermissions(ctx context.Context) ([]*ent.Permission, error) {
return s.ctx.EntClient.Permission.Query().Order(ent.Asc(permission.FieldSort), ent.Asc(permission.FieldID)).All(ctx)
}