375 lines
16 KiB
Go
375 lines
16 KiB
Go
package sys
|
|
|
|
import (
|
|
"context"
|
|
|
|
"hotgo/internal/consts"
|
|
"hotgo/internal/dao"
|
|
"hotgo/internal/library/contexts"
|
|
"hotgo/internal/library/imtenant"
|
|
"hotgo/internal/model/input/sysin"
|
|
"hotgo/internal/service"
|
|
|
|
"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 sSysImUserPolicyGroup struct{}
|
|
|
|
const imTenantLoginIPWhitelistTable = "im_tenant_login_ip_whitelists"
|
|
|
|
func NewSysImUserPolicyGroup() *sSysImUserPolicyGroup { return &sSysImUserPolicyGroup{} }
|
|
func init() { service.RegisterSysImUserPolicyGroup(NewSysImUserPolicyGroup()) }
|
|
|
|
func (s *sSysImUserPolicyGroup) List(ctx context.Context, in *sysin.ImUserPolicyGroupListInp) (list []*sysin.ImUserPolicyGroupListModel, total int, err error) {
|
|
if err = in.Filter(ctx); err != nil {
|
|
return
|
|
}
|
|
tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
c := dao.ImUserPolicyGroups.Columns()
|
|
mc := dao.ImUserPolicyGroupMembers.Columns()
|
|
model := imtenant.RegistryDB().Model(dao.ImUserPolicyGroups.Table()+" p").Safe().Ctx(ctx).
|
|
Fields("p."+c.Id, "p."+c.TenantId, "p."+c.GroupCode, "p."+c.GroupName, "p."+c.Priority, "p."+c.Status,
|
|
"CAST(p."+c.PolicyJson+" AS CHAR) policy_json", "CAST(p."+c.IpWhitelist+" AS CHAR) ip_whitelist",
|
|
"CAST(p."+c.IpBlacklist+" AS CHAR) ip_blacklist", "p."+c.Version, "p."+c.Remark, "p."+c.CreatedAt, "p."+c.UpdatedAt,
|
|
"(SELECT COUNT(*) FROM "+dao.ImUserPolicyGroupMembers.Table()+" m WHERE m."+mc.GroupId+"=p."+c.Id+" AND m."+mc.Status+"=1 AND m."+mc.DeletedAt+" IS NULL) member_count").
|
|
Where("p."+c.TenantId, tenantID).WhereNull("p." + c.DeletedAt)
|
|
if in.Keyword != "" {
|
|
keyword := "%" + in.Keyword + "%"
|
|
model = model.Where("(p."+c.GroupCode+" LIKE ? OR p."+c.GroupName+" LIKE ?)", keyword, keyword)
|
|
}
|
|
if in.Status != 0 {
|
|
model = model.Where("p."+c.Status, in.Status)
|
|
}
|
|
err = model.Page(in.Page, in.PerPage).OrderDesc("p."+c.Priority).OrderDesc("p."+c.Id).ScanAndCount(&list, &total, false)
|
|
if err != nil {
|
|
err = gerror.Wrap(err, "获取用户策略分组失败")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) View(ctx context.Context, in *sysin.ImUserPolicyGroupViewInp) (res *sysin.ImUserPolicyGroupViewModel, err error) {
|
|
if err = in.Filter(ctx); err != nil {
|
|
return
|
|
}
|
|
c := dao.ImUserPolicyGroups.Columns()
|
|
var row *sysin.ImUserPolicyGroupListModel
|
|
err = imtenant.RegistryDB().Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).
|
|
Fields(c.Id, c.TenantId, c.GroupCode, c.GroupName, c.Priority, c.Status, "CAST("+c.PolicyJson+" AS CHAR) policy_json", "CAST("+c.IpWhitelist+" AS CHAR) ip_whitelist", "CAST("+c.IpBlacklist+" AS CHAR) ip_blacklist", c.Version, c.Remark, c.CreatedAt, c.UpdatedAt).
|
|
Where(c.Id, in.Id).WhereNull(c.DeletedAt).Scan(&row)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取用户策略分组详情失败")
|
|
}
|
|
if row == nil {
|
|
return nil, gerror.New("用户策略分组不存在")
|
|
}
|
|
if _, _, err = resolveImPolicyTenant(ctx, row.TenantId); err != nil {
|
|
return nil, err
|
|
}
|
|
return &sysin.ImUserPolicyGroupViewModel{ImUserPolicyGroupListModel: *row}, nil
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) Edit(ctx context.Context, in *sysin.ImUserPolicyGroupEditInp) error {
|
|
if err := in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
tenantID, tenantCode, err := resolveImPolicyTenant(ctx, in.TenantId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c := dao.ImUserPolicyGroups.Columns()
|
|
db := imtenant.RegistryDB()
|
|
now := gtime.Now()
|
|
operator := contexts.GetUserId(ctx)
|
|
data := g.Map{c.GroupName: in.GroupName, c.Priority: in.Priority, c.Status: in.Status, c.PolicyJson: policyJSON(in.PolicyJson, "{}"), c.IpWhitelist: policyJSON(in.IpWhitelist, "[]"), c.IpBlacklist: policyJSON(in.IpBlacklist, "[]"), c.Remark: in.Remark, c.UpdatedAt: now, c.UpdatedBy: operator}
|
|
var targetID int64
|
|
if in.Id > 0 {
|
|
var current gdb.Record
|
|
if current, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
|
|
return gerror.Wrap(err, "读取用户策略分组失败")
|
|
}
|
|
if current.IsEmpty() || current[c.TenantId].Int64() != tenantID {
|
|
return gerror.New("用户策略分组不存在")
|
|
}
|
|
if current[c.GroupCode].String() != in.GroupCode {
|
|
return gerror.New("分组编码创建后不能修改")
|
|
}
|
|
data[c.Version] = gdb.Raw("version+1")
|
|
if _, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(data).Update(); err != nil {
|
|
return gerror.Wrap(err, "更新用户策略分组失败")
|
|
}
|
|
targetID = in.Id
|
|
} else {
|
|
data[c.TenantId] = tenantID
|
|
data[c.GroupCode] = in.GroupCode
|
|
data[c.Version] = 1
|
|
data[c.CreatedAt] = now
|
|
data[c.CreatedBy] = operator
|
|
result, insertErr := db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Data(data).Insert()
|
|
if insertErr != nil {
|
|
return gerror.Wrap(insertErr, "新增用户策略分组失败")
|
|
}
|
|
targetID, err = result.LastInsertId()
|
|
if err != nil {
|
|
return gerror.Wrap(err, "获取用户策略分组ID失败")
|
|
}
|
|
}
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_user_policy_group_edit", "im_user_policy_group", targetID, "success", g.Map{"group_code": in.GroupCode})
|
|
return publishImPolicyEvent(ctx, tenantID, tenantCode, "user_policy_group.updated", "user_policy_groups", uint(targetID))
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) Delete(ctx context.Context, in *sysin.ImUserPolicyGroupDeleteInp) error {
|
|
if err := in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
c := dao.ImUserPolicyGroups.Columns()
|
|
mc := dao.ImUserPolicyGroupMembers.Columns()
|
|
db := imtenant.RegistryDB()
|
|
var row gdb.Record
|
|
var err error
|
|
if row, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
|
|
return gerror.Wrap(err, "读取用户策略分组失败")
|
|
}
|
|
if row.IsEmpty() {
|
|
return gerror.New("用户策略分组不存在")
|
|
}
|
|
tenantID, tenantCode, err := resolveImPolicyTenant(ctx, row[c.TenantId].Int64())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
count, err := db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Where(mc.GroupId, in.Id).Where(mc.Status, consts.StatusEnabled).WhereNull(mc.DeletedAt).Count()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count > 0 {
|
|
return gerror.New("请先移除分组内成员")
|
|
}
|
|
now := gtime.Now()
|
|
_, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(g.Map{c.DeletedAt: now, c.DeletedBy: contexts.GetUserId(ctx), c.Status: consts.StatusDisable}).Update()
|
|
if err != nil {
|
|
return gerror.Wrap(err, "删除用户策略分组失败")
|
|
}
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_user_policy_group_delete", "im_user_policy_group", in.Id, "success", nil)
|
|
return publishImPolicyEvent(ctx, tenantID, tenantCode, "user_policy_group.deleted", "user_policy_groups", uint(in.Id))
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) Status(ctx context.Context, in *sysin.ImUserPolicyGroupStatusInp) error {
|
|
if err := in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
c := dao.ImUserPolicyGroups.Columns()
|
|
db := imtenant.RegistryDB()
|
|
var row gdb.Record
|
|
var err error
|
|
if row, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
|
|
return err
|
|
}
|
|
if row.IsEmpty() {
|
|
return gerror.New("用户策略分组不存在")
|
|
}
|
|
tenantID, tenantCode, err := resolveImPolicyTenant(ctx, row[c.TenantId].Int64())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(g.Map{c.Status: in.Status, c.Version: gdb.Raw("version+1"), c.UpdatedBy: contexts.GetUserId(ctx), c.UpdatedAt: gtime.Now()}).Update()
|
|
if err != nil {
|
|
return gerror.Wrap(err, "更新用户策略分组状态失败")
|
|
}
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_user_policy_group_status", "im_user_policy_group", in.Id, "success", g.Map{"status": in.Status})
|
|
return publishImPolicyEvent(ctx, tenantID, tenantCode, "user_policy_group.updated", "user_policy_groups", uint(in.Id))
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) MemberList(ctx context.Context, in *sysin.ImUserPolicyGroupMemberListInp) (list []*sysin.ImUserPolicyGroupMemberModel, total int, err error) {
|
|
if err = in.Filter(ctx); err != nil {
|
|
return
|
|
}
|
|
gc := dao.ImUserPolicyGroups.Columns()
|
|
mc := dao.ImUserPolicyGroupMembers.Columns()
|
|
var group gdb.Record
|
|
if group, err = imtenant.RegistryDB().Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(gc.Id, in.GroupId).WhereNull(gc.DeletedAt).One(); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if group.IsEmpty() {
|
|
return nil, 0, gerror.New("用户策略分组不存在")
|
|
}
|
|
if _, _, err = resolveImPolicyTenant(ctx, group[gc.TenantId].Int64()); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
model := imtenant.RegistryDB().Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Fields(mc.Id, mc.GroupId, mc.TenantId, mc.UserId, mc.Status, mc.ValidFrom, mc.ValidUntil, mc.Remark, mc.CreatedAt).Where(mc.GroupId, in.GroupId).WhereNull(mc.DeletedAt)
|
|
if in.UserId > 0 {
|
|
model = model.Where(mc.UserId, in.UserId)
|
|
}
|
|
err = model.Page(in.Page, in.PerPage).OrderDesc(mc.Id).ScanAndCount(&list, &total, false)
|
|
return
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) MemberAdd(ctx context.Context, in *sysin.ImUserPolicyGroupMemberAddInp) error {
|
|
if err := in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
gc := dao.ImUserPolicyGroups.Columns()
|
|
mc := dao.ImUserPolicyGroupMembers.Columns()
|
|
db := imtenant.RegistryDB()
|
|
var group gdb.Record
|
|
var err error
|
|
if group, err = db.Model(dao.ImUserPolicyGroups.Table()).Safe().Ctx(ctx).Where(gc.Id, in.GroupId).WhereNull(gc.DeletedAt).One(); err != nil {
|
|
return err
|
|
}
|
|
if group.IsEmpty() {
|
|
return gerror.New("用户策略分组不存在")
|
|
}
|
|
tenantID, tenantCode, err := resolveImPolicyTenant(ctx, group[gc.TenantId].Int64())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if tenantID == 0 {
|
|
return gerror.New("全局默认分组不能添加成员，请先选择具体租户")
|
|
}
|
|
tenantDB, _, err := imtenant.DB(ctx, tenantID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
userCount, err := tenantDB.Model("im_users").Safe().Ctx(ctx).Where("id", in.UserId).Count()
|
|
if err != nil {
|
|
return gerror.Wrap(err, "检查租户用户失败")
|
|
}
|
|
if userCount == 0 {
|
|
return gerror.New("用户不存在或不属于当前租户")
|
|
}
|
|
var current gdb.Record
|
|
current, err = db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Where(mc.GroupId, in.GroupId).Where(mc.UserId, in.UserId).One()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
now := gtime.Now()
|
|
data := g.Map{mc.TenantId: tenantID, mc.Status: consts.StatusEnabled, mc.ValidFrom: in.ValidFrom, mc.ValidUntil: in.ValidUntil, mc.Remark: in.Remark, mc.DeletedAt: nil, mc.DeletedBy: nil, mc.UpdatedAt: now, mc.UpdatedBy: contexts.GetUserId(ctx)}
|
|
if current.IsEmpty() {
|
|
data[mc.GroupId] = in.GroupId
|
|
data[mc.UserId] = in.UserId
|
|
data[mc.CreatedAt] = now
|
|
data[mc.CreatedBy] = contexts.GetUserId(ctx)
|
|
_, err = db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Data(data).Insert()
|
|
} else {
|
|
_, err = db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Where(mc.Id, current[mc.Id]).Data(data).Update()
|
|
}
|
|
if err != nil {
|
|
return gerror.Wrap(err, "添加策略分组成员失败")
|
|
}
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_user_policy_group_member_add", "im_user_policy_group", in.GroupId, "success", g.Map{"user_id": in.UserId})
|
|
return publishImPolicyEvent(ctx, tenantID, tenantCode, "user_policy_group.updated", "user_policy_groups", uint(in.GroupId))
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) MemberRemove(ctx context.Context, in *sysin.ImUserPolicyGroupMemberRemoveInp) error {
|
|
if err := in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
mc := dao.ImUserPolicyGroupMembers.Columns()
|
|
db := imtenant.RegistryDB()
|
|
var row gdb.Record
|
|
var err error
|
|
if row, err = db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Where(mc.Id, in.Id).WhereNull(mc.DeletedAt).One(); err != nil {
|
|
return err
|
|
}
|
|
if row.IsEmpty() {
|
|
return gerror.New("策略分组成员不存在")
|
|
}
|
|
tenantID, tenantCode, err := resolveImPolicyTenant(ctx, row[mc.TenantId].Int64())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = db.Model(dao.ImUserPolicyGroupMembers.Table()).Safe().Ctx(ctx).Where(mc.Id, in.Id).Data(g.Map{mc.Status: consts.StatusDisable, mc.DeletedAt: gtime.Now(), mc.DeletedBy: contexts.GetUserId(ctx), mc.UpdatedAt: gtime.Now(), mc.UpdatedBy: contexts.GetUserId(ctx)}).Update()
|
|
if err != nil {
|
|
return gerror.Wrap(err, "移除策略分组成员失败")
|
|
}
|
|
groupID := row[mc.GroupId].Int64()
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_user_policy_group_member_remove", "im_user_policy_group", groupID, "success", g.Map{"user_id": row[mc.UserId].Int64()})
|
|
return publishImPolicyEvent(ctx, tenantID, tenantCode, "user_policy_group.updated", "user_policy_groups", uint(groupID))
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) LoginIPWhitelist(ctx context.Context, in *sysin.ImTenantLoginIPWhitelistInp) (res *sysin.ImTenantLoginIPWhitelistModel, err error) {
|
|
if err = in.Filter(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.LoginIPWhitelistByTenant(ctx, tenantID)
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) LoginIPWhitelistByTenant(ctx context.Context, tenantID int64) (res *sysin.ImTenantLoginIPWhitelistModel, err error) {
|
|
if tenantID <= 0 {
|
|
return nil, gerror.New("租户ID不合法")
|
|
}
|
|
rows, err := imtenant.RegistryDB().Model(imTenantLoginIPWhitelistTable).Safe().Ctx(ctx).
|
|
Fields("channel", "ip_cidr").
|
|
Where("tenant_id", tenantID).
|
|
Where("status", consts.StatusEnabled).
|
|
WhereNull("deleted_at").
|
|
OrderAsc("channel").OrderAsc("id").All()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取租户登录IP白名单失败")
|
|
}
|
|
res = &sysin.ImTenantLoginIPWhitelistModel{
|
|
TenantId: tenantID,
|
|
AppList: make([]string, 0),
|
|
WebList: make([]string, 0),
|
|
}
|
|
for _, row := range rows {
|
|
switch row["channel"].String() {
|
|
case consts.ImLoginChannelApp:
|
|
res.AppList = append(res.AppList, row["ip_cidr"].String())
|
|
case consts.ImLoginChannelWeb:
|
|
res.WebList = append(res.WebList, row["ip_cidr"].String())
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (s *sSysImUserPolicyGroup) LoginIPWhitelistSave(ctx context.Context, in *sysin.ImTenantLoginIPWhitelistSaveInp) (err error) {
|
|
if err = in.Filter(ctx); err != nil {
|
|
return err
|
|
}
|
|
tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
now := gtime.Now()
|
|
operatorID := contexts.GetUserId(ctx)
|
|
db := imtenant.RegistryDB()
|
|
err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
|
|
if _, txErr := tx.Model(imTenantLoginIPWhitelistTable).Safe().Ctx(ctx).
|
|
Where("tenant_id", tenantID).WhereNull("deleted_at").
|
|
Data(g.Map{"status": consts.StatusDisable, "deleted_at": now, "deleted_by": operatorID, "updated_at": now, "updated_by": operatorID}).Update(); txErr != nil {
|
|
return txErr
|
|
}
|
|
for channel, values := range map[string][]string{
|
|
consts.ImLoginChannelApp: in.AppList,
|
|
consts.ImLoginChannelWeb: in.WebList,
|
|
} {
|
|
for _, value := range values {
|
|
if _, txErr := tx.Exec(`INSERT INTO im_tenant_login_ip_whitelists
|
|
(tenant_id,channel,ip_cidr,status,created_by,updated_by)
|
|
VALUES(?,?,?,?,?,?)
|
|
ON DUPLICATE KEY UPDATE status=VALUES(status),deleted_at=NULL,deleted_by=NULL,updated_at=CURRENT_TIMESTAMP(3),updated_by=VALUES(updated_by)`,
|
|
tenantID, channel, value, consts.StatusEnabled, operatorID, operatorID); txErr != nil {
|
|
return txErr
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return gerror.Wrap(err, "保存租户登录IP白名单失败")
|
|
}
|
|
_ = writeImAdminAudit(ctx, tenantID, "im_tenant_login_ip_whitelist_save", "im_tenant", tenantID, "success", g.Map{
|
|
"app_count": len(in.AppList), "web_count": len(in.WebList),
|
|
})
|
|
return nil
|
|
}
|