chore: seed migration objects batch 5

server/internal/logic/admin/member.go

@@ -470,7 +470,7 @@ func (s *sAdminMember) Edit(ctx context.Context, in *adminin.MemberEditInp) (err
 
 	if service.AdminMember().VerifySuperId(ctx, opMemberId) {
 		if in.TenantId > 0 {
-			count, queryErr := imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx).
+			count, queryErr := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).
 				Where(dao.ImTenant.Columns().Id, in.TenantId).
 				Where(dao.ImTenant.Columns().State, consts.ImTenantStateActive).
 				Count()
@@ -488,7 +488,6 @@ func (s *sAdminMember) Edit(ctx context.Context, in *adminin.MemberEditInp) (err
 			return gerror.New("当前管理员未关联租户")
 		}
 	} else {
-		// 非租户域管理员不能通过浏览器为账号指定租户。
 		in.TenantId = 0
 	}
 

server/internal/logic/hook/init.go

@@ -8,6 +8,7 @@ package hook
 import (
 	"github.com/gogf/gf/v2/net/ghttp"
 	"hotgo/internal/service"
+	"strings"
 )
 
 type sHook struct {
@@ -22,10 +23,23 @@ func New() *sHook {
 }
 
 func (s *sHook) BeforeServe(r *ghttp.Request) {
-
+	s.setAdminStaticCacheHeader(r)
 }
 
 func (s *sHook) AfterOutput(r *ghttp.Request) {
 	s.accessLog(r)
 	s.lastAdminActive(r)
 }
+
+func (s *sHook) setAdminStaticCacheHeader(r *ghttp.Request) {
+	path := r.URL.Path
+	if path == "/admin" || path == "/admin/" || path == "/admin/index.html" || path == "/admin/app.config.js" {
+		r.Response.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		r.Response.Header().Set("Pragma", "no-cache")
+		r.Response.Header().Set("Expires", "0")
+		return
+	}
+	if strings.HasPrefix(path, "/admin/assets/") {
+		r.Response.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
+	}
+}

server/internal/logic/sys/im_abuse_reason.go

@@ -0,0 +1,166 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"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"
+)
+
+const imAbuseReasonsTable = "im_abuse_reasons"
+
+type sSysImAbuseReason struct{}
+
+func NewSysImAbuseReason() *sSysImAbuseReason { return &sSysImAbuseReason{} }
+
+func init() {
+	service.RegisterSysImAbuseReason(NewSysImAbuseReason())
+}
+
+func (s *sSysImAbuseReason) List(ctx context.Context, in *sysin.ImAbuseReasonListInp) (list []*sysin.ImAbuseReasonModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaults(ctx, db); err != nil {
+		return
+	}
+	mod := s.model(ctx, db)
+	if in.TargetType != "" {
+		mod = mod.Where("target_type", in.TargetType)
+	}
+	if in.ReasonCode != "" {
+		mod = mod.WhereLike("reason_code", "%"+in.ReasonCode+"%")
+	}
+	if in.Enabled != nil {
+		mod = mod.Where("enabled", *in.Enabled)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc("target_type").OrderAsc("sort_order").OrderAsc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM举报原因失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantId = tenant.Id
+		item.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImAbuseReason) Edit(ctx context.Context, in *sysin.ImAbuseReasonEditInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaults(ctx, db); err != nil {
+		return
+	}
+	data := g.Map{
+		"target_type":          in.TargetType,
+		"reason_code":          in.ReasonCode,
+		"label":                in.Label,
+		"requires_description": in.RequiresDescription,
+		"allows_evidence":      in.AllowsEvidence,
+		"sort_order":           in.SortOrder,
+		"enabled":              in.Enabled,
+		"updated_at":           gtime.Now(),
+	}
+	action := "im_abuse_reason_create"
+	targetId := in.Id
+	if in.Id > 0 {
+		if _, err = db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).WherePri(in.Id).Data(data).Update(); err != nil {
+			return gerror.Wrap(err, "更新IM举报原因失败，请稍后重试！")
+		}
+		action = "im_abuse_reason_update"
+	} else {
+		data["created_at"] = gtime.Now()
+		if _, err = db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).Data(data).Insert(); err != nil {
+			return gerror.Wrap(err, "新增IM举报原因失败，请稍后重试！")
+		}
+		idValue, err := db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).Fields("id").
+			Where("target_type", in.TargetType).Where("reason_code", in.ReasonCode).Value()
+		if err != nil {
+			return gerror.Wrap(err, "获取IM举报原因ID失败，请稍后重试！")
+		}
+		targetId = idValue.Int64()
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, action, "im_abuse_reason", targetId, "success", g.Map{
+		"target_type": in.TargetType, "reason_code": in.ReasonCode, "enabled": in.Enabled,
+	})
+	return nil
+}
+
+func (s *sSysImAbuseReason) Delete(ctx context.Context, in *sysin.ImAbuseReasonDeleteInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if _, err = db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).WherePri(in.Id).
+		Data(g.Map{"enabled": 0, "updated_at": gtime.Now()}).Update(); err != nil {
+		return gerror.Wrap(err, "禁用IM举报原因失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_abuse_reason_disable", "im_abuse_reason", in.Id, "success", nil)
+	return nil
+}
+
+func (s *sSysImAbuseReason) model(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).Fields(
+		"id",
+		"target_type",
+		"reason_code",
+		"label",
+		"requires_description",
+		"allows_evidence",
+		"sort_order",
+		"enabled",
+		"created_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImAbuseReason) ensureDefaults(ctx context.Context, db gdb.DB) (err error) {
+	defaults := []g.Map{
+		{"target_type": consts.ImAbuseTargetTypeUser, "reason_code": "fraud", "label": "诈骗欺诈", "requires_description": 0, "allows_evidence": 1, "sort_order": 10},
+		{"target_type": consts.ImAbuseTargetTypeUser, "reason_code": "harassment", "label": "骚扰辱骂", "requires_description": 0, "allows_evidence": 1, "sort_order": 20},
+		{"target_type": consts.ImAbuseTargetTypeUser, "reason_code": "illegal", "label": "违法违规", "requires_description": 1, "allows_evidence": 1, "sort_order": 30},
+		{"target_type": consts.ImAbuseTargetTypeGroup, "reason_code": "fraud", "label": "诈骗欺诈", "requires_description": 0, "allows_evidence": 1, "sort_order": 10},
+		{"target_type": consts.ImAbuseTargetTypeGroup, "reason_code": "spam", "label": "垃圾广告", "requires_description": 0, "allows_evidence": 1, "sort_order": 20},
+		{"target_type": consts.ImAbuseTargetTypeGroup, "reason_code": "illegal", "label": "违法违规", "requires_description": 1, "allows_evidence": 1, "sort_order": 30},
+		{"target_type": consts.ImAbuseTargetTypeMessage, "reason_code": "fraud", "label": "诈骗欺诈", "requires_description": 0, "allows_evidence": 1, "sort_order": 10},
+		{"target_type": consts.ImAbuseTargetTypeMessage, "reason_code": "spam", "label": "垃圾广告", "requires_description": 0, "allows_evidence": 1, "sort_order": 20},
+		{"target_type": consts.ImAbuseTargetTypeMessage, "reason_code": "harassment", "label": "骚扰辱骂", "requires_description": 0, "allows_evidence": 1, "sort_order": 30},
+		{"target_type": consts.ImAbuseTargetTypeMessage, "reason_code": "illegal", "label": "违法违规", "requires_description": 1, "allows_evidence": 1, "sort_order": 40},
+	}
+	now := gtime.Now()
+	for _, item := range defaults {
+		var count int
+		if count, err = db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).
+			Where("target_type", item["target_type"]).Where("reason_code", item["reason_code"]).Count(); err != nil {
+			return gerror.Wrap(err, "检查IM举报默认原因失败，请稍后重试！")
+		}
+		if count > 0 {
+			continue
+		}
+		item["enabled"] = 1
+		item["created_at"] = now
+		item["updated_at"] = now
+		if _, err = db.Model(imAbuseReasonsTable).Safe().Ctx(ctx).Data(item).Insert(); err != nil {
+			return gerror.Wrap(err, "初始化IM举报默认原因失败，请稍后重试！")
+		}
+	}
+	return nil
+}

server/internal/logic/sys/im_admin_query_client.go

@@ -0,0 +1,258 @@
+package sys
+
+import (
+	"context"
+	"encoding/json"
+	"hotgo/internal/dao"
+	"hotgo/internal/library/imadmin"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type imAdminQueryPage struct {
+	Items   []map[string]any `json:"items"`
+	Total   int              `json:"total"`
+	Page    int              `json:"page"`
+	PerPage int              `json:"per_page"`
+}
+
+func resolveImAdminTenant(ctx context.Context, selectedTenantId int64) (tenant *entity.ImTenant, err error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(scope.TenantId).Scan(&tenant); err != nil {
+		return nil, gerror.Wrap(err, "获取IM租户失败")
+	}
+	if tenant == nil || tenant.Id <= 0 || tenant.Code == "" {
+		return nil, gerror.New("IM租户不存在或编码为空")
+	}
+	return tenant, nil
+}
+
+func imAdminQueryList[T any](ctx context.Context, tenant *entity.ImTenant, path string, values url.Values, aliases map[string]string) (list []*T, totalCount int, err error) {
+	if values == nil {
+		values = url.Values{}
+	}
+	query := values.Encode()
+	if query != "" {
+		path += "?" + query
+	}
+	var page imAdminQueryPage
+	if err = imadmin.DefaultClient(ctx).InternalGet(ctx, path, &page); err != nil {
+		return nil, 0, err
+	}
+	normalizeImAdminRows(page.Items, aliases)
+	if len(page.Items) == 0 {
+		return []*T{}, page.Total, nil
+	}
+	raw, err := json.Marshal(page.Items)
+	if err != nil {
+		return nil, 0, gerror.Wrap(err, "转换IM内部查询列表失败")
+	}
+	if err = json.Unmarshal(raw, &list); err != nil {
+		return nil, 0, gerror.Wrap(err, "解析IM内部查询列表失败")
+	}
+	fillImTenantFields(tenant, &list)
+	return list, page.Total, nil
+}
+
+func imAdminQueryOne[T any](ctx context.Context, tenant *entity.ImTenant, path string, aliases map[string]string) (res *T, err error) {
+	row := map[string]any{}
+	if err = imadmin.DefaultClient(ctx).InternalGet(ctx, path, &row); err != nil {
+		return nil, err
+	}
+	normalizeImAdminRow(row, aliases)
+	raw, err := json.Marshal(row)
+	if err != nil {
+		return nil, gerror.Wrap(err, "转换IM内部查询详情失败")
+	}
+	if err = json.Unmarshal(raw, &res); err != nil {
+		return nil, gerror.Wrap(err, "解析IM内部查询详情失败")
+	}
+	fillImTenantFields(tenant, res)
+	return res, nil
+}
+
+func normalizeImAdminRows(rows []map[string]any, aliases map[string]string) {
+	for _, row := range rows {
+		normalizeImAdminRow(row, aliases)
+	}
+}
+
+func normalizeImAdminRow(row map[string]any, aliases map[string]string) {
+	for key, value := range row {
+		target := snakeToLowerCamel(key)
+		if aliases != nil {
+			if alias := aliases[key]; alias != "" {
+				target = alias
+			}
+		}
+		value = normalizeImAdminValue(target, value)
+		if target == key {
+			row[key] = value
+			continue
+		}
+		row[target] = value
+		delete(row, key)
+	}
+	if _, ok := row["authNames"]; !ok {
+		username, _ := row["username"].(string)
+		phone, _ := row["phone"].(string)
+		authNames := username
+		if phone != "" && phone != username {
+			if authNames != "" {
+				authNames += ", "
+			}
+			authNames += phone
+		}
+		if authNames != "" {
+			row["authNames"] = authNames
+		}
+	}
+}
+
+func normalizeImAdminValue(target string, value any) any {
+	switch target {
+	case "credentials":
+		items, ok := value.([]any)
+		if !ok {
+			return value
+		}
+		parts := make([]string, 0, len(items))
+		for _, item := range items {
+			m, ok := item.(map[string]any)
+			if !ok {
+				continue
+			}
+			method, _ := m["method"].(string)
+			val, _ := m["value"].(string)
+			if method == "" && val == "" {
+				continue
+			}
+			text := method
+			if val != "" {
+				if text != "" {
+					text += ":"
+				}
+				text += val
+			}
+			if done, ok := m["done"].(bool); ok && !done {
+				text += "(未验证)"
+			}
+			parts = append(parts, text)
+		}
+		return strings.Join(parts, ", ")
+	case "profileJson", "trustedJson", "accessJson", "head", "content", "metadata", "atUsers":
+		return normalizeImAdminJSONString(value)
+	default:
+		return value
+	}
+}
+
+func normalizeImAdminJSONString(value any) string {
+	switch v := value.(type) {
+	case nil:
+		return ""
+	case string:
+		return v
+	default:
+		encoded, err := json.Marshal(v)
+		if err != nil {
+			return ""
+		}
+		return string(encoded)
+	}
+}
+
+func snakeToLowerCamel(s string) string {
+	if !strings.Contains(s, "_") {
+		return s
+	}
+	parts := strings.Split(s, "_")
+	var b strings.Builder
+	for i, part := range parts {
+		if part == "" {
+			continue
+		}
+		if i == 0 {
+			b.WriteString(part)
+			continue
+		}
+		b.WriteString(strings.ToUpper(part[:1]))
+		if len(part) > 1 {
+			b.WriteString(part[1:])
+		}
+	}
+	return b.String()
+}
+
+func fillImTenantFields(tenant *entity.ImTenant, target any) {
+	raw, err := json.Marshal(target)
+	if err != nil {
+		return
+	}
+	var rows []map[string]any
+	if err = json.Unmarshal(raw, &rows); err == nil {
+		for _, row := range rows {
+			row["tenantId"] = tenant.Id
+			row["tenantName"] = tenant.Name
+		}
+		updated, _ := json.Marshal(rows)
+		_ = json.Unmarshal(updated, target)
+		return
+	}
+	var row map[string]any
+	if err = json.Unmarshal(raw, &row); err == nil {
+		row["tenantId"] = tenant.Id
+		row["tenantName"] = tenant.Name
+		updated, _ := json.Marshal(row)
+		_ = json.Unmarshal(updated, target)
+	}
+}
+
+func addPageQuery(values url.Values, page int, perPage int) url.Values {
+	if values == nil {
+		values = url.Values{}
+	}
+	if page <= 0 {
+		page = 1
+	}
+	if perPage <= 0 {
+		perPage = 20
+	}
+	values.Set("page", intToString(page))
+	values.Set("per_page", intToString(perPage))
+	return values
+}
+
+func addTimeRangeQuery(values url.Values, prefix string, times []*gtime.Time) {
+	if len(times) != 2 {
+		return
+	}
+	if times[0] != nil {
+		values.Set(prefix+"_start", times[0].Time.UTC().Format(time.RFC3339Nano))
+	}
+	if times[1] != nil {
+		values.Set(prefix+"_end", times[1].Time.UTC().Format(time.RFC3339Nano))
+	}
+}
+
+func intToString(v int) string {
+	return strconvFormatInt(int64(v))
+}
+
+func int64ToString(v int64) string {
+	return strconvFormatInt(v)
+}
+
+func strconvFormatInt(v int64) string {
+	return strconv.FormatInt(v, 10)
+}

server/internal/logic/sys/im_admin_scope.go

@@ -11,6 +11,7 @@ import (
 	"hotgo/internal/service"
 	"hotgo/utility/simple"
 
+	"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"
@@ -28,7 +29,7 @@ func resolveImAdminScope(ctx context.Context, selectedTenantId int64) (scope ima
 	scope.OperatorId = operatorId
 	scope.RoleKey = contexts.GetRoleKey(ctx)
 	scope.RequestId = gctx.CtxId(ctx)
-	if service.AdminMember().VerifySuperId(ctx, operatorId) {
+	if isImPlatformAdmin(ctx, operatorId) {
 		if selectedTenantId <= 0 {
 			return scope, gerror.New("请选择IM租户")
 		}
@@ -39,12 +40,12 @@ func resolveImAdminScope(ctx context.Context, selectedTenantId int64) (scope ima
 		return scope, nil
 	}
 
-	if contexts.GetDeptType(ctx) != consts.DeptTypeTenant {
-		return scope, gerror.New("当前账号不是租户管理员，不能管理邀请码")
+	if !contexts.IsTenantDept(ctx) {
+		return scope, gerror.New("当前账号无权管理IM租户")
 	}
-	tenantId := contexts.GetTenantId(ctx)
-	if tenantId <= 0 {
-		return scope, gerror.New("当前管理员未关联租户")
+	tenantId, err := resolveImAdminBoundTenant(ctx)
+	if err != nil {
+		return scope, err
 	}
 	if err = ensureImTenantActive(ctx, tenantId); err != nil {
 		return scope, err
@@ -53,6 +54,21 @@ func resolveImAdminScope(ctx context.Context, selectedTenantId int64) (scope ima
 	return scope, nil
 }
 
+func isImPlatformAdmin(ctx context.Context, operatorId int64) bool {
+	if contexts.IsCompanyDept(ctx) {
+		return true
+	}
+	return service.AdminMember().VerifySuperId(ctx, operatorId)
+}
+
+func resolveImAdminBoundTenant(ctx context.Context) (int64, error) {
+	tenantId := contexts.GetTenantId(ctx)
+	if tenantId <= 0 {
+		return 0, gerror.New("当前管理员未关联IM租户")
+	}
+	return tenantId, nil
+}
+
 func ensureImTenantActive(ctx context.Context, tenantId int64) (err error) {
 	var tenant *entity.ImTenant
 	if err = imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(tenantId).Scan(&tenant); err != nil {
@@ -67,6 +83,14 @@ func ensureImTenantActive(ctx context.Context, tenantId int64) (err error) {
 	return nil
 }
 
+func resolveImTenantDB(ctx context.Context, selectedTenantId int64) (db gdb.DB, tenant *entity.ImTenant, err error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantId)
+	if err != nil {
+		return nil, nil, err
+	}
+	return imtenant.DB(ctx, scope.TenantId)
+}
+
 func writeImAdminAudit(ctx context.Context, tenantId int64, action string, targetType string, targetId int64, result string, detail g.Map) error {
 	operatorId := contexts.GetUserId(ctx)
 	request := ghttp.RequestFromCtx(ctx)

server/internal/logic/sys/im_admin_scope_test.go

@@ -0,0 +1,57 @@
+package sys
+
+import (
+	"context"
+	"testing"
+
+	"hotgo/internal/consts"
+	"hotgo/internal/model"
+)
+
+func TestCompanyDepartmentIsImPlatformAdmin(t *testing.T) {
+	ctx := context.WithValue(context.Background(), consts.ContextHTTPKey, &model.Context{
+		User: &model.Identity{Id: 14, TenantId: 1, DeptType: consts.DeptTypeCompany, RoleKey: "imManage"},
+	})
+	if !isImPlatformAdmin(ctx, 14) {
+		t.Fatal("expected company department IM manager to use platform tenant selection")
+	}
+}
+
+func TestResolveImAdminBoundTenant(t *testing.T) {
+	tests := []struct {
+		name     string
+		identity *model.Identity
+		want     int64
+	}{
+		{
+			name: "tenant department with tenant binding",
+			identity: &model.Identity{
+				TenantId: 2,
+				DeptType: consts.DeptTypeTenant,
+			},
+			want: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.WithValue(context.Background(), consts.ContextHTTPKey, &model.Context{User: tt.identity})
+			got, err := resolveImAdminBoundTenant(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got != tt.want {
+				t.Fatalf("tenant binding mismatch: got %d, want %d", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestResolveImAdminBoundTenantRejectsUnboundAccount(t *testing.T) {
+	ctx := context.WithValue(context.Background(), consts.ContextHTTPKey, &model.Context{
+		User: &model.Identity{DeptType: consts.DeptTypeTenant, RoleKey: "tenantManager"},
+	})
+	if _, err := resolveImAdminBoundTenant(ctx); err == nil {
+		t.Fatal("expected unbound account to be rejected")
+	}
+}

server/internal/logic/sys/im_app_release.go

@@ -0,0 +1,153 @@
+package sys
+
+import (
+	"context"
+	"fmt"
+
+	"hotgo/internal/consts"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imkafka"
+	"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"
+)
+
+const imAppReleasesTable = "im_app_releases"
+
+type sSysImAppRelease struct{}
+
+func NewSysImAppRelease() *sSysImAppRelease { return &sSysImAppRelease{} }
+
+func init() {
+	service.RegisterSysImAppRelease(NewSysImAppRelease())
+}
+
+func (s *sSysImAppRelease) List(ctx context.Context, in *sysin.ImAppReleaseListInp) (list []*sysin.ImAppReleaseModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db := imtenant.RegistryDB()
+	if err = s.ensureDefaults(ctx, db); err != nil {
+		return
+	}
+	mod := s.model(ctx, db)
+	if in.Platform != "" {
+		mod = mod.Where("platform", in.Platform)
+	}
+	if in.Channel != "" {
+		mod = mod.WhereLike("channel", "%"+in.Channel+"%")
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc("platform").OrderAsc("channel")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM客户端版本策略失败，请稍后重试！")
+		return
+	}
+	return
+}
+
+func (s *sSysImAppRelease) Edit(ctx context.Context, in *sysin.ImAppReleaseEditInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db := imtenant.RegistryDB()
+	if err = s.ensureDefaults(ctx, db); err != nil {
+		return
+	}
+	data := g.Map{
+		"platform":              in.Platform,
+		"channel":               in.Channel,
+		"latest_version":        in.LatestVersion,
+		"min_supported_version": in.MinSupportedVersion,
+		"update_type":           in.UpdateType,
+		"release_notes":         in.ReleaseNotes,
+		"store_url":             in.StoreUrl,
+		"package_url":           in.PackageUrl,
+		"checksum":              in.Checksum,
+		"remind_after_seconds":  in.RemindAfterSeconds,
+		"published_at":          gtime.Now(),
+		"updated_at":            gtime.Now(),
+	}
+	action := "im_app_release_create"
+	targetId := in.Id
+	if in.Id > 0 {
+		if _, err = db.Model(imAppReleasesTable).Safe().Ctx(ctx).WherePri(in.Id).Data(data).Update(); err != nil {
+			return gerror.Wrap(err, "更新IM客户端版本策略失败，请稍后重试！")
+		}
+		action = "im_app_release_update"
+	} else {
+		data["created_at"] = gtime.Now()
+		if _, err = db.Model(imAppReleasesTable).Safe().Ctx(ctx).Data(data).Insert(); err != nil {
+			return gerror.Wrap(err, "新增IM客户端版本策略失败，请稍后重试！")
+		}
+		idValue, err := db.Model(imAppReleasesTable).Safe().Ctx(ctx).Fields("id").
+			Where("platform", in.Platform).Where("channel", in.Channel).Value()
+		if err != nil {
+			return gerror.Wrap(err, "获取IM客户端版本策略ID失败，请稍后重试！")
+		}
+		targetId = idValue.Int64()
+	}
+	_ = writeImAdminAudit(ctx, 0, action, "im_app_release", targetId, "success", g.Map{
+		"platform": in.Platform, "channel": in.Channel, "update_type": in.UpdateType,
+	})
+	if err = imkafka.PublishConfigEvent(ctx, imkafka.ConfigEventInput{
+		TenantCode: "*", EventType: "app.release.updated", Group: "app_release",
+		Keys: []string{in.Platform, in.Channel}, BizID: in.Platform + ":" + in.Channel,
+		Actor:     &imkafka.Actor{Type: "admin", ID: fmt.Sprint(contexts.GetUserId(ctx))},
+		CreatedBy: contexts.GetUserId(ctx),
+	}); err != nil {
+		g.Log().Warningf(ctx, "版本策略已保存，缓存失效事件等待 Outbox 重试: %v", err)
+	}
+	return nil
+}
+
+func (s *sSysImAppRelease) model(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model(imAppReleasesTable).Safe().Ctx(ctx).Fields(
+		"id",
+		"platform",
+		"channel",
+		"latest_version",
+		"min_supported_version",
+		"update_type",
+		"release_notes",
+		"store_url",
+		"package_url",
+		"checksum",
+		"remind_after_seconds",
+		"published_at",
+		"created_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImAppRelease) ensureDefaults(ctx context.Context, db gdb.DB) (err error) {
+	defaults := []g.Map{
+		{"platform": consts.ImAppPlatformIos, "channel": "stable", "latest_version": "1.0.0", "min_supported_version": "1.0.0", "update_type": consts.ImAppUpdateTypeNone, "release_notes": "当前已是最新版本。", "remind_after_seconds": 0},
+		{"platform": consts.ImAppPlatformAndroid, "channel": "stable", "latest_version": "1.0.0", "min_supported_version": "1.0.0", "update_type": consts.ImAppUpdateTypeNone, "release_notes": "当前已是最新版本。", "remind_after_seconds": 0},
+	}
+	now := gtime.Now()
+	for _, item := range defaults {
+		var count int
+		if count, err = db.Model(imAppReleasesTable).Safe().Ctx(ctx).
+			Where("platform", item["platform"]).Where("channel", item["channel"]).Count(); err != nil {
+			return gerror.Wrap(err, "检查IM客户端默认版本策略失败，请稍后重试！")
+		}
+		if count > 0 {
+			continue
+		}
+		item["store_url"] = ""
+		item["package_url"] = ""
+		item["checksum"] = ""
+		item["published_at"] = now
+		item["created_at"] = now
+		item["updated_at"] = now
+		if _, err = db.Model(imAppReleasesTable).Safe().Ctx(ctx).Data(item).Insert(); err != nil {
+			return gerror.Wrap(err, "初始化IM客户端默认版本策略失败，请稍后重试！")
+		}
+	}
+	return nil
+}

server/internal/logic/sys/im_audit_log.go

@@ -7,12 +7,18 @@ package sys
 
 import (
 	"context"
+	"fmt"
 	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/input/form"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
+	"hotgo/utility/convert"
+	"hotgo/utility/excel"
 
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type sSysImAuditLog struct{}
@@ -30,7 +36,11 @@ func (s *sSysImAuditLog) List(ctx context.Context, in *sysin.ImAuditLogListInp)
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	db, tenant, err := imtenant.DB(ctx, scope.TenantId)
 	if err != nil {
 		return
 	}
@@ -107,7 +117,11 @@ func (s *sSysImAuditLog) View(ctx context.Context, in *sysin.ImAuditLogViewInp)
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	db, tenant, err := imtenant.DB(ctx, scope.TenantId)
 	if err != nil {
 		return nil, err
 	}
@@ -123,3 +137,23 @@ func (s *sSysImAuditLog) View(ctx context.Context, in *sysin.ImAuditLogViewInp)
 	res.TenantName = tenant.Name
 	return
 }
+
+// Export 导出IM审计日志列表
+func (s *sSysImAuditLog) Export(ctx context.Context, in *sysin.ImAuditLogListInp) (err error) {
+	list, totalCount, err := s.List(ctx, in)
+	if err != nil {
+		return
+	}
+	tags, err := convert.GetEntityDescTags(sysin.ImAuditLogExportModel{})
+	if err != nil {
+		return
+	}
+
+	var exports []sysin.ImAuditLogExportModel
+	if err = gconv.Scan(list, &exports); err != nil {
+		return
+	}
+	fileName := "导出IM审计日志-" + gctx.CtxId(ctx)
+	sheetName := fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, form.CalPageCount(totalCount, in.PerPage), in.Page, len(list))
+	return excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
+}

server/internal/logic/sys/im_dashboard.go

@@ -0,0 +1,38 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+	"net/url"
+)
+
+type sSysImDashboard struct{}
+
+func NewSysImDashboard() *sSysImDashboard { return &sSysImDashboard{} }
+
+func init() { service.RegisterSysImDashboard(NewSysImDashboard()) }
+
+func (s *sSysImDashboard) Overview(ctx context.Context, in *sysin.ImDashboardOverviewInp) (*sysin.ImDashboardOverviewModel, error) {
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	return imAdminQueryOne[sysin.ImDashboardOverviewModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/dashboard/overview", nil)
+}
+
+func (s *sSysImDashboard) Trends(ctx context.Context, in *sysin.ImDashboardTrendsInp) ([]*sysin.ImDashboardTrendModel, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	values := addPageQuery(url.Values{}, 1, in.Days)
+	values.Set("days", intToString(in.Days))
+	list, _, err := imAdminQueryList[sysin.ImDashboardTrendModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/dashboard/trends", values, nil)
+	return list, err
+}

server/internal/logic/sys/im_dead_letter.go

@@ -166,7 +166,7 @@ func (s *sSysImDeadLetter) getTenant(ctx context.Context, tenantId int64) (tenan
 	if tenantId <= 0 {
 		return nil, gerror.New("请选择IM租户")
 	}
-	if err = imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(tenantId).Scan(&tenant); err != nil {
+	if err = imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(tenantId).Scan(&tenant); err != nil {
 		return nil, gerror.Wrap(err, "获取IM租户失败")
 	}
 	if tenant == nil || tenant.Id <= 0 {

server/internal/logic/sys/im_external_config.go

@@ -0,0 +1,227 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"hotgo/internal/dao"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+
+	"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/os/gtime"
+)
+
+type sSysImExternalConfig struct{}
+
+func NewSysImExternalConfig() *sSysImExternalConfig { return &sSysImExternalConfig{} }
+
+func init() {
+	service.RegisterSysImExternalConfig(NewSysImExternalConfig())
+}
+
+func (s *sSysImExternalConfig) List(ctx context.Context, in *sysin.ImExternalConfigListInp) (list []*sysin.ImExternalConfigListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return
+	}
+	mod := s.model(ctx).Where("tenant_id", tenant.Id)
+	if in.Service != "" {
+		mod = mod.Where("service", in.Service)
+	}
+	if in.Provider != "" {
+		mod = mod.WhereLike("provider", "%"+in.Provider+"%")
+	}
+	if in.Enabled != nil {
+		mod = mod.Where("enabled", *in.Enabled)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc("service")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM外部服务配置失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImExternalConfig) View(ctx context.Context, in *sysin.ImExternalConfigViewInp) (res *sysin.ImExternalConfigViewModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return nil, err
+	}
+	if err = s.model(ctx).Where("tenant_id", tenant.Id).Where("service", in.Service).Scan(&res); err != nil {
+		return nil, gerror.Wrap(err, "获取IM外部服务配置详情失败，请稍后重试！")
+	}
+	if res != nil {
+		res.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImExternalConfig) Update(ctx context.Context, in *sysin.ImExternalConfigUpdateInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	if !s.validService(in.Service) {
+		return gerror.New("服务类型不正确")
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return err
+	}
+	configJson := "{}"
+	if in.ConfigJson != nil && in.ConfigJson.String() != "" && in.ConfigJson.String() != "null" {
+		configJson = in.ConfigJson.String()
+	}
+	data := g.Map{
+		"provider":    in.Provider,
+		"endpoint":    in.Endpoint,
+		"enabled":     in.Enabled,
+		"config_json": configJson,
+		"updated_at":  gtime.Now(),
+		"updated_by":  contexts.GetUserId(ctx),
+	}
+	if in.SecretJson != nil && in.SecretJson.String() != "" && in.SecretJson.String() != "null" && in.SecretJson.String() != "{}" {
+		data["secret_json"] = in.SecretJson.String()
+	}
+	if _, err = imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
+		Where("tenant_id", tenant.Id).Where("service", in.Service).Data(data).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM外部服务配置失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_external_config_update", "im_external_config", 0, "success", g.Map{
+		"service": in.Service, "provider": in.Provider, "enabled": in.Enabled,
+	})
+	return nil
+}
+
+func (s *sSysImExternalConfig) Check(ctx context.Context, in *sysin.ImExternalConfigCheckInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return err
+	}
+	var row gdb.Record
+	if row, err = imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
+		Where("tenant_id", tenant.Id).Where("service", in.Service).One(); err != nil {
+		return gerror.Wrap(err, "检查IM外部服务配置失败，请稍后重试！")
+	}
+	status := consts.ImExternalConfigStatusConfigured
+	result := "配置完整"
+	if row == nil || row["enabled"].Int() != 1 || row["provider"].String() == "" {
+		status = consts.ImExternalConfigStatusUnconfigured
+		result = "未启用或服务商为空"
+	}
+	if _, err = imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
+		Where("tenant_id", tenant.Id).Where("service", in.Service).
+		Data(g.Map{"status": status, "checked_at": gtime.Now(), "check_result": result, "updated_at": gtime.Now()}).
+		Update(); err != nil {
+		return gerror.Wrap(err, "更新IM外部服务检查结果失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_external_config_check", "im_external_config", 0, "success", g.Map{
+		"service": in.Service, "status": status,
+	})
+	return nil
+}
+
+func (s *sSysImExternalConfig) model(ctx context.Context) *gdb.Model {
+	return imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).Fields(
+		"tenant_id",
+		"id",
+		"service",
+		"provider",
+		"endpoint",
+		"enabled",
+		"status",
+		"CAST(config_json AS CHAR) config_json",
+		"CASE WHEN secret_json IS NULL OR CAST(secret_json AS CHAR)='{}' THEN 0 ELSE 1 END has_secret",
+		"checked_at",
+		"check_result",
+		"created_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImExternalConfig) resolveTenant(ctx context.Context, selectedTenantId int64) (tenant *entity.ImTenant, err error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(scope.TenantId).Scan(&tenant); err != nil {
+		return nil, gerror.Wrap(err, "获取IM租户失败")
+	}
+	if tenant == nil {
+		return nil, gerror.New("IM租户不存在")
+	}
+	return tenant, nil
+}
+
+func (s *sSysImExternalConfig) ensureRows(ctx context.Context, tenantId int64) error {
+	services := []string{
+		consts.ImExternalServiceSms,
+		consts.ImExternalServicePush,
+		consts.ImExternalServiceTurn,
+		consts.ImExternalServiceStorage,
+		consts.ImExternalServiceModeration,
+	}
+	for _, serviceName := range services {
+		count, err := imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
+			Where("tenant_id", tenantId).Where("service", serviceName).Count()
+		if err != nil {
+			return gerror.Wrap(err, "初始化IM外部服务配置失败")
+		}
+		if count > 0 {
+			continue
+		}
+		_, err = imtenant.RegistryDB().Exec(ctx, `INSERT INTO im_external_config
+			(tenant_id,service,provider,endpoint,enabled,status,config_json,secret_json,created_by,updated_by)
+			VALUES(?,?,?,?,?,?,CAST(? AS JSON),CAST(? AS JSON),?,?)`,
+			tenantId, serviceName, "", "", 0, consts.ImExternalConfigStatusUnconfigured, "{}", "{}", contexts.GetUserId(ctx), contexts.GetUserId(ctx))
+		if err != nil {
+			return gerror.Wrap(err, "初始化IM外部服务配置失败")
+		}
+	}
+	return nil
+}
+
+func (s *sSysImExternalConfig) validService(serviceName string) bool {
+	switch serviceName {
+	case consts.ImExternalServiceSms, consts.ImExternalServicePush, consts.ImExternalServiceTurn, consts.ImExternalServiceStorage, consts.ImExternalServiceModeration:
+		return true
+	default:
+		return false
+	}
+}
+
+func externalConfigJson(value string) *gjson.Json {
+	if value == "" {
+		return gjson.New("{}")
+	}
+	return gjson.New(value)
+}

server/internal/logic/sys/im_feedback_config.go

@@ -0,0 +1,112 @@
+package sys
+
+import (
+	"context"
+	"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"
+)
+
+const imFeedbackConfigTable = "im_feedback_config"
+
+type sSysImFeedbackConfig struct{}
+
+func NewSysImFeedbackConfig() *sSysImFeedbackConfig { return &sSysImFeedbackConfig{} }
+
+func init() {
+	service.RegisterSysImFeedbackConfig(NewSysImFeedbackConfig())
+}
+
+func (s *sSysImFeedbackConfig) Get(ctx context.Context, in *sysin.ImFeedbackConfigGetInp) (res *sysin.ImFeedbackConfigModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = s.ensureDefault(ctx, db); err != nil {
+		return nil, err
+	}
+	if err = s.model(ctx, db).OrderAsc("id").Limit(1).Scan(&res); err != nil {
+		return nil, gerror.Wrap(err, "获取IM意见反馈配置失败，请稍后重试！")
+	}
+	if res != nil {
+		res.TenantId = tenant.Id
+		res.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImFeedbackConfig) Update(ctx context.Context, in *sysin.ImFeedbackConfigUpdateInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = s.ensureDefault(ctx, db); err != nil {
+		return err
+	}
+	categories := `["bug","suggestion","complaint","other"]`
+	if in.Categories != nil && in.Categories.String() != "" && in.Categories.String() != "null" {
+		categories = in.Categories.String()
+	}
+	attachmentPolicy := `{"max_files":5,"purpose":"feedback"}`
+	if in.AttachmentPolicy != nil && in.AttachmentPolicy.String() != "" && in.AttachmentPolicy.String() != "null" {
+		attachmentPolicy = in.AttachmentPolicy.String()
+	}
+	if _, err = db.Model(imFeedbackConfigTable).Safe().Ctx(ctx).Where("id", 1).Data(g.Map{
+		"categories":         categories,
+		"max_length":         in.MaxLength,
+		"attachment_policy":  attachmentPolicy,
+		"allow_contact":      in.AllowContact,
+		"diagnostics_notice": in.DiagnosticsNotice,
+		"updated_at":         gtime.Now(),
+	}).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM意见反馈配置失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_feedback_config_update", "im_feedback_config", 1, "success", g.Map{"allow_contact": in.AllowContact})
+	return nil
+}
+
+func (s *sSysImFeedbackConfig) model(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model(imFeedbackConfigTable).Safe().Ctx(ctx).Fields(
+		"id",
+		"CAST(categories AS CHAR) categories",
+		"max_length",
+		"CAST(attachment_policy AS CHAR) attachment_policy",
+		"allow_contact",
+		"diagnostics_notice",
+		"updated_at",
+	)
+}
+
+func (s *sSysImFeedbackConfig) ensureDefault(ctx context.Context, db gdb.DB) (err error) {
+	var count int
+	if count, err = db.Model(imFeedbackConfigTable).Safe().Ctx(ctx).Where("id", 1).Count(); err != nil {
+		return gerror.Wrap(err, "检查IM意见反馈默认配置失败，请稍后重试！")
+	}
+	if count > 0 {
+		return nil
+	}
+	_, err = db.Model(imFeedbackConfigTable).Safe().Ctx(ctx).Data(g.Map{
+		"id":                 1,
+		"categories":         `["bug","suggestion","complaint","other"]`,
+		"max_length":         1000,
+		"attachment_policy":  `{"max_files":5,"purpose":"feedback"}`,
+		"allow_contact":      1,
+		"diagnostics_notice": "仅在你同意时上传脱敏诊断信息。",
+		"created_at":         gtime.Now(),
+		"updated_at":         gtime.Now(),
+	}).Insert()
+	if err != nil {
+		return gerror.Wrap(err, "初始化IM意见反馈默认配置失败，请稍后重试！")
+	}
+	return nil
+}

server/internal/logic/sys/im_file.go

@@ -0,0 +1,244 @@
+// Package sys
+// @Link  https://github.com/bufanyun/hotgo
+// @Copyright  Copyright (c) 2026 HotGo
+// @Author  Ms <133814250@qq.com>
+// @License  https://github.com/bufanyun/hotgo/blob/master/LICENSE
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/model/entity"
+	"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 sSysImFile struct{}
+
+func NewSysImFile() *sSysImFile {
+	return &sSysImFile{}
+}
+
+func init() {
+	service.RegisterSysImFile(NewSysImFile())
+}
+
+// List 获取IM文件列表
+func (s *sSysImFile) List(ctx context.Context, in *sysin.ImFileListInp) (list []*sysin.ImFileListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := s.fileModel(ctx, db)
+	mod = s.applyWhere(mod, in)
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("fu.updatedat").OrderDesc("fu.id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM文件列表失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantId = tenant.Id
+		item.TenantName = tenant.Name
+		if !contexts.IsCompanyDept(ctx) {
+			item.Location = ""
+		}
+	}
+	return
+}
+
+// View 获取IM文件详情
+func (s *sSysImFile) View(ctx context.Context, in *sysin.ImFileViewInp) (res *sysin.ImFileViewModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = s.fileModel(ctx, db).Where("fu.id", in.Id).Scan(&res); err != nil {
+		return nil, gerror.Wrap(err, "获取IM文件详情失败，请稍后重试！")
+	}
+	if res == nil {
+		return nil, nil
+	}
+	res.TenantId = tenant.Id
+	res.TenantName = tenant.Name
+	if !contexts.IsCompanyDept(ctx) {
+		res.Location = ""
+	}
+	if err = db.Model("im_filemsglinks").Safe().Ctx(ctx).
+		Fields("id", "createdat created_at", "fileid file_id", "COALESCE(msgid,0) msg_id", "COALESCE(topic,'') topic", "COALESCE(userid,0) user_id").
+		Where("fileid", in.Id).
+		OrderDesc("id").
+		Limit(50).
+		Scan(&res.Links); err != nil {
+		return nil, gerror.Wrap(err, "获取IM文件引用失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_file_view", "im_file", in.Id, "success", g.Map{
+		"file_id": in.Id,
+	})
+	return
+}
+
+// Quarantine 隔离IM文件
+func (s *sSysImFile) Quarantine(ctx context.Context, in *sysin.ImFileActionInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.updateStatus(ctx, in, consts.ImFileStatusQuarantined, "im_file_quarantine")
+}
+
+// Delete 删除IM文件
+func (s *sSysImFile) Delete(ctx context.Context, in *sysin.ImFileActionInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.updateStatus(ctx, in, consts.ImFileStatusDeleted, "im_file_delete")
+}
+
+// CleanupOrphan 清理IM孤儿文件
+func (s *sSysImFile) CleanupOrphan(ctx context.Context, in *sysin.ImFileCleanupOrphanInp) (res *sysin.ImFileCleanupOrphanModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	cutoff := gtime.Now().AddDate(0, 0, -in.Days)
+	rows, err := db.Model("im_fileuploads fu").Safe().Ctx(ctx).
+		LeftJoin("im_filemsglinks fml", "fml.fileid=fu.id").
+		Fields("fu.id", "fu.location").
+		Where("fml.id IS NULL").
+		WhereLT("fu.updatedat", cutoff).
+		WhereNotIn("fu.status", []int{consts.ImFileStatusDeleted, consts.ImFileStatusQuarantined}).
+		Group("fu.id").
+		OrderAsc("fu.updatedat").
+		Limit(in.Limit).
+		All()
+	if err != nil {
+		return nil, gerror.Wrap(err, "扫描IM孤儿文件失败，请稍后重试！")
+	}
+	res = &sysin.ImFileCleanupOrphanModel{Locations: []string{}}
+	if len(rows) == 0 {
+		return res, nil
+	}
+	ids := make([]int64, 0, len(rows))
+	for _, row := range rows {
+		ids = append(ids, row["id"].Int64())
+		if location := row["location"].String(); location != "" {
+			res.Locations = append(res.Locations, location)
+		}
+	}
+	if _, err = db.Model("im_fileuploads").Safe().Ctx(ctx).
+		WhereIn("id", ids).
+		Data(g.Map{"status": consts.ImFileStatusDeleted, "updatedat": gtime.Now()}).
+		Update(); err != nil {
+		return nil, gerror.Wrap(err, "标记IM孤儿文件失败，请稍后重试！")
+	}
+	res.Count = len(ids)
+	if !contexts.IsCompanyDept(ctx) {
+		res.Locations = []string{}
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_file_cleanup_orphan", "im_file", 0, "success", g.Map{
+		"days": in.Days, "limit": in.Limit, "count": res.Count,
+	})
+	return
+}
+
+func (s *sSysImFile) fileModel(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model("im_fileuploads fu").Safe().Ctx(ctx).
+		LeftJoin("im_filemsglinks fml", "fml.fileid=fu.id").
+		Fields(
+			"fu.id",
+			"fu.createdat created_at",
+			"fu.updatedat updated_at",
+			"COALESCE(fu.userid,0) user_id",
+			"fu.status",
+			"fu.mimetype mime_type",
+			"fu.size",
+			"COALESCE(fu.etag,'') etag",
+			"fu.location",
+			"COUNT(fml.id) link_count",
+			"COALESCE(MIN(fml.topic),'') first_topic",
+			"COALESCE(MIN(fml.msgid),0) first_msg_id",
+			"MIN(fml.createdat) first_link_at",
+			`CASE
+				WHEN COUNT(fml.id)=0 THEN 'orphan'
+				WHEN SUM(CASE WHEN fml.topic LIKE 'grp%' THEN 1 ELSE 0 END)>0 THEN 'chat'
+				ELSE 'chat'
+			END purpose`,
+		).
+		Group("fu.id")
+}
+
+func (s *sSysImFile) applyWhere(mod *gdb.Model, in *sysin.ImFileListInp) *gdb.Model {
+	if in.FileId > 0 {
+		mod = mod.Where("fu.id", in.FileId)
+	}
+	if in.UserId > 0 {
+		mod = mod.Where("fu.userid", in.UserId)
+	}
+	if in.Status != nil {
+		mod = mod.Where("fu.status", *in.Status)
+	}
+	if in.MimeType != "" {
+		mod = mod.WhereLike("fu.mimetype", "%"+in.MimeType+"%")
+	}
+	if in.Topic != "" {
+		mod = mod.WhereLike("fml.topic", "%"+in.Topic+"%")
+	}
+	if in.Purpose == consts.ImFilePurposeOrphan {
+		mod = mod.Having("link_count = 0")
+	}
+	if in.Purpose != "" && in.Purpose != consts.ImFilePurposeOrphan && in.Purpose != consts.ImFilePurposeUnknown {
+		mod = mod.Having("purpose", in.Purpose)
+	}
+	if len(in.CreatedAt) == 2 {
+		mod = mod.WhereBetween("fu.createdat", in.CreatedAt[0], in.CreatedAt[1])
+	}
+	if len(in.UpdatedAt) == 2 {
+		mod = mod.WhereBetween("fu.updatedat", in.UpdatedAt[0], in.UpdatedAt[1])
+	}
+	return mod
+}
+
+func (s *sSysImFile) updateStatus(ctx context.Context, in *sysin.ImFileActionInp, status int, action string) (err error) {
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	current, err := db.Model("im_fileuploads").Safe().Ctx(ctx).Where("id", in.Id).One()
+	if err != nil {
+		return gerror.Wrap(err, "获取IM文件失败，请稍后重试！")
+	}
+	if current == nil {
+		return gerror.New("IM文件不存在")
+	}
+	if current["status"].Int() == consts.ImFileStatusDeleted && status == consts.ImFileStatusDeleted {
+		return gerror.New("IM文件已删除")
+	}
+	if _, err = db.Model("im_fileuploads").Safe().Ctx(ctx).
+		Where("id", in.Id).
+		Data(g.Map{"status": status, "updatedat": gtime.Now()}).
+		Update(); err != nil {
+		return gerror.Wrap(err, "更新IM文件状态失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, action, "im_file", in.Id, "success", g.Map{
+		"file_id": in.Id, "before_status": current["status"].Int(), "after_status": status, "reason": in.Reason,
+	})
+	return nil
+}
+
+func (s *sSysImFile) tenantDB(ctx context.Context, selectedTenantId int64) (db gdb.DB, tenant *entity.ImTenant, err error) {
+	return resolveImTenantDB(ctx, selectedTenantId)
+}

server/internal/logic/sys/im_file_policy.go

@@ -0,0 +1,169 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"hotgo/internal/dao"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"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 sSysImFilePolicy struct{}
+
+func NewSysImFilePolicy() *sSysImFilePolicy {
+	return &sSysImFilePolicy{}
+}
+
+func init() {
+	service.RegisterSysImFilePolicy(NewSysImFilePolicy())
+}
+
+func (s *sSysImFilePolicy) List(ctx context.Context, in *sysin.ImFilePolicyListInp) (list []*sysin.ImFilePolicyListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return
+	}
+	mod := s.model(ctx).Where("tenant_id", tenant.Id)
+	if in.Purpose != "" {
+		mod = mod.Where("purpose", in.Purpose)
+	}
+	if in.AutoCleanup != nil {
+		mod = mod.Where("auto_cleanup", *in.AutoCleanup)
+	}
+	if in.ScanEnabled != nil {
+		mod = mod.Where("scan_enabled", *in.ScanEnabled)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM文件策略失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImFilePolicy) Update(ctx context.Context, in *sysin.ImFilePolicyUpdateInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := s.resolveTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = s.ensureRows(ctx, tenant.Id); err != nil {
+		return err
+	}
+	allowedMimes := "[]"
+	if in.AllowedMimes != nil && in.AllowedMimes.String() != "" && in.AllowedMimes.String() != "null" {
+		allowedMimes = in.AllowedMimes.String()
+	}
+	if _, err = imtenant.RegistryDB().Model("im_file_policy").Safe().Ctx(ctx).
+		Where("tenant_id", tenant.Id).
+		Where("purpose", in.Purpose).
+		Data(g.Map{
+			"max_size":       in.MaxSize,
+			"retention_days": in.RetentionDays,
+			"allowed_mimes":  allowedMimes,
+			"auto_cleanup":   in.AutoCleanup,
+			"scan_enabled":   in.ScanEnabled,
+			"remark":         in.Remark,
+			"updated_at":     gtime.Now(),
+			"updated_by":     contexts.GetUserId(ctx),
+		}).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM文件策略失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_file_policy_update", "im_file_policy", 0, "success", g.Map{
+		"purpose": in.Purpose, "auto_cleanup": in.AutoCleanup, "scan_enabled": in.ScanEnabled,
+	})
+	return nil
+}
+
+func (s *sSysImFilePolicy) model(ctx context.Context) *gdb.Model {
+	return imtenant.RegistryDB().Model("im_file_policy").Safe().Ctx(ctx).Fields(
+		"id",
+		"tenant_id",
+		"purpose",
+		"max_size",
+		"retention_days",
+		"CAST(allowed_mimes AS CHAR) allowed_mimes",
+		"auto_cleanup",
+		"scan_enabled",
+		"remark",
+		"updated_at",
+	)
+}
+
+func (s *sSysImFilePolicy) resolveTenant(ctx context.Context, selectedTenantId int64) (tenant *entity.ImTenant, err error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).WherePri(scope.TenantId).Scan(&tenant); err != nil {
+		return nil, gerror.Wrap(err, "获取IM租户失败")
+	}
+	if tenant == nil {
+		return nil, gerror.New("IM租户不存在")
+	}
+	return tenant, nil
+}
+
+func (s *sSysImFilePolicy) ensureRows(ctx context.Context, tenantId int64) error {
+	for _, item := range defaultFilePolicies() {
+		count, err := imtenant.RegistryDB().Model("im_file_policy").Safe().Ctx(ctx).
+			Where("tenant_id", tenantId).
+			Where("purpose", item.Purpose).
+			Count()
+		if err != nil {
+			return gerror.Wrap(err, "检查IM文件策略失败")
+		}
+		if count > 0 {
+			continue
+		}
+		_, err = imtenant.RegistryDB().Exec(ctx, `INSERT INTO im_file_policy
+			(tenant_id,purpose,max_size,retention_days,allowed_mimes,auto_cleanup,scan_enabled,remark,created_by,updated_by)
+			VALUES(?,?,?,?,CAST(? AS JSON),?,?,?,?,?)`,
+			tenantId, item.Purpose, item.MaxSize, item.RetentionDays, item.AllowedMimes, item.AutoCleanup, item.ScanEnabled, item.Remark, contexts.GetUserId(ctx), contexts.GetUserId(ctx))
+		if err != nil {
+			return gerror.Wrap(err, "初始化IM文件策略失败")
+		}
+	}
+	return nil
+}
+
+type filePolicySeed struct {
+	Purpose       string
+	MaxSize       int64
+	RetentionDays int
+	AllowedMimes  string
+	AutoCleanup   int
+	ScanEnabled   int
+	Remark        string
+}
+
+func defaultFilePolicies() []*filePolicySeed {
+	const mb = 1024 * 1024
+	return []*filePolicySeed{
+		{Purpose: consts.ImFilePurposeChat, MaxSize: 100 * mb, RetentionDays: 365, AllowedMimes: "[]", AutoCleanup: 0, ScanEnabled: 0, Remark: "聊天附件默认策略"},
+		{Purpose: consts.ImFilePurposeUserAvatar, MaxSize: 5 * mb, RetentionDays: 0, AllowedMimes: `["image/jpeg","image/png","image/webp"]`, AutoCleanup: 0, ScanEnabled: 0, Remark: "用户头像长期保留"},
+		{Purpose: consts.ImFilePurposeGroupAvatar, MaxSize: 5 * mb, RetentionDays: 0, AllowedMimes: `["image/jpeg","image/png","image/webp"]`, AutoCleanup: 0, ScanEnabled: 0, Remark: "群头像长期保留"},
+		{Purpose: consts.ImFilePurposeGroupFile, MaxSize: 200 * mb, RetentionDays: 365, AllowedMimes: "[]", AutoCleanup: 0, ScanEnabled: 0, Remark: "群文件默认策略"},
+		{Purpose: consts.ImFilePurposeAbuseEvidence, MaxSize: 50 * mb, RetentionDays: 730, AllowedMimes: "[]", AutoCleanup: 0, ScanEnabled: 0, Remark: "举报证据默认策略"},
+		{Purpose: consts.ImFilePurposeFeedback, MaxSize: 50 * mb, RetentionDays: 365, AllowedMimes: "[]", AutoCleanup: 0, ScanEnabled: 0, Remark: "反馈附件默认策略"},
+	}
+}

server/internal/logic/sys/im_group.go

@@ -7,6 +7,8 @@ package sys
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"hotgo/internal/consts"
 	"hotgo/internal/library/contexts"
 	"hotgo/internal/library/imkafka"
@@ -14,14 +16,23 @@ import (
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
 	"strconv"
-	"time"
 
 	"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/os/gtime"
+	"github.com/gogf/gf/v2/util/guid"
 )
 
 type sSysImGroup struct{}
 
+const (
+	imGroupModeMember = "JRWPS"
+	imGroupModeAdmin  = "JRWPASO"
+	imGroupModeOwner  = "JRWPASDO"
+)
+
 func NewSysImGroup() *sSysImGroup {
 	return &sSysImGroup{}
 }
@@ -36,7 +47,7 @@ func (s *sSysImGroup) List(ctx context.Context, in *sysin.ImGroupListInp) (list
 		return
 	}
 
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}
@@ -59,10 +70,14 @@ func (s *sSysImGroup) List(ctx context.Context, in *sysin.ImGroupListInp) (list
 func (s *sSysImGroup) groupModel(ctx context.Context, db gdb.DB) *gdb.Model {
 	return db.Model("im_topics t").Safe().Ctx(ctx).
 		LeftJoin("im_group_settings gs", "gs.topic = t.name").
+		LeftJoin("im_users owner", "owner.id = COALESCE(gs.owner_user_id, t.owner)").
+		LeftJoin("im_user_profiles owner_profile", "owner_profile.user_id = COALESCE(gs.owner_user_id, t.owner)").
 		Fields(
 			"t.name topic",
 			"t.state",
 			"COALESCE(gs.owner_user_id, t.owner) owner_id",
+			"COALESCE(NULLIF(owner_profile.nickname, ''), owner.username, '') owner_nickname",
+			"COALESCE(owner.username, '') owner_username",
 			"t.seqid seq_id",
 			"t.delid del_id",
 			"t.subcnt sub_cnt",
@@ -73,7 +88,7 @@ func (s *sSysImGroup) groupModel(ctx context.Context, db gdb.DB) *gdb.Model {
 			"t.trusted trusted_json",
 			"t.tags tags_json",
 			"t.aux aux_json",
-			"COALESCE(gs.name, '') group_name",
+			"COALESCE(NULLIF(gs.name, ''), NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.public, '$.fn')), ''), NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.public, '$.name')), ''), t.name) group_name",
 			"COALESCE(gs.avatar_file_id, '') avatar_file_id",
 			"COALESCE(gs.description, '') description",
 			"COALESCE(gs.group_status, '') group_status",
@@ -119,17 +134,21 @@ func (s *sSysImGroup) View(ctx context.Context, in *sysin.ImGroupViewInp) (res *
 		return
 	}
 
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}
 
 	err = db.Model("im_topics t").Safe().Ctx(ctx).
 		LeftJoin("im_group_settings gs", "gs.topic = t.name").
+		LeftJoin("im_users owner", "owner.id = COALESCE(gs.owner_user_id, t.owner)").
+		LeftJoin("im_user_profiles owner_profile", "owner_profile.user_id = COALESCE(gs.owner_user_id, t.owner)").
 		Fields(
 			"t.name topic",
 			"t.state",
 			"COALESCE(gs.owner_user_id, t.owner) owner_id",
+			"COALESCE(NULLIF(owner_profile.nickname, ''), owner.username, '') owner_nickname",
+			"COALESCE(owner.username, '') owner_username",
 			"t.seqid seq_id",
 			"t.delid del_id",
 			"t.subcnt sub_cnt",
@@ -142,7 +161,7 @@ func (s *sSysImGroup) View(ctx context.Context, in *sysin.ImGroupViewInp) (res *
 			"t.aux aux_json",
 			"t.access access_json",
 			"t.usebt use_bt",
-			"COALESCE(gs.name, '') group_name",
+			"COALESCE(NULLIF(gs.name, ''), NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.public, '$.fn')), ''), NULLIF(JSON_UNQUOTE(JSON_EXTRACT(t.public, '$.name')), ''), t.name) group_name",
 			"COALESCE(gs.avatar_file_id, '') avatar_file_id",
 			"COALESCE(gs.description, '') description",
 			"COALESCE(gs.group_status, '') group_status",
@@ -177,7 +196,7 @@ func (s *sSysImGroup) MemberList(ctx context.Context, in *sysin.ImGroupMemberLis
 		return
 	}
 
-	db, _, err := imtenant.DB(ctx, in.TenantId)
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}
@@ -289,7 +308,7 @@ func (s *sSysImGroup) Governance(ctx context.Context, in *sysin.ImGroupTopicInp)
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return nil, err
 	}
@@ -329,303 +348,241 @@ func (s *sSysImGroup) Governance(ctx context.Context, in *sysin.ImGroupTopicInp)
 	return
 }
 
-// JoinRequestList 获取IM入群申请列表
-func (s *sSysImGroup) JoinRequestList(ctx context.Context, in *sysin.ImGroupJoinRequestListInp) (list []*sysin.ImGroupJoinRequestListModel, totalCount int, err error) {
-	if err = in.Filter(ctx); err != nil {
-		return
-	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
-	if err != nil {
-		return
-	}
-	mod := db.Model("im_group_join_requests").Safe().Ctx(ctx).Where("topic", in.Topic)
-	if in.Status != "" {
-		mod = mod.Where("status", in.Status)
-	}
-	if in.ApplicantUserId > 0 {
-		mod = mod.Where("applicant_user_id", in.ApplicantUserId)
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
-		err = gerror.Wrap(err, "获取IM入群申请列表失败，请稍后重试！")
-	}
-	return
-}
-
-// InvitationList 获取IM群邀请列表
-func (s *sSysImGroup) InvitationList(ctx context.Context, in *sysin.ImGroupInvitationListInp) (list []*sysin.ImGroupInvitationListModel, totalCount int, err error) {
-	if err = in.Filter(ctx); err != nil {
-		return
-	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
-	if err != nil {
-		return
-	}
-	mod := db.Model("im_group_invitations").Safe().Ctx(ctx).Where("topic", in.Topic)
-	if in.Status != "" {
-		mod = mod.Where("status", in.Status)
-	}
-	if in.TargetUserId > 0 {
-		mod = mod.Where("target_user_id", in.TargetUserId)
-	}
-	if in.InviterUserId > 0 {
-		mod = mod.Where("inviter_user_id", in.InviterUserId)
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
-		err = gerror.Wrap(err, "获取IM群邀请列表失败，请稍后重试！")
-	}
-	return
-}
-
-// AnnouncementList 获取IM群公告列表
-func (s *sSysImGroup) AnnouncementList(ctx context.Context, in *sysin.ImGroupAnnouncementListInp) (list []*sysin.ImGroupAnnouncementListModel, totalCount int, err error) {
-	if err = in.Filter(ctx); err != nil {
-		return
-	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
-	if err != nil {
-		return
-	}
-	mod := db.Model("im_group_announcements").Safe().Ctx(ctx).Where("topic", in.Topic)
-	if in.Status != "" {
-		mod = mod.Where("status", in.Status)
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("published_at").OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
-		err = gerror.Wrap(err, "获取IM群公告列表失败，请稍后重试！")
-	}
-	return
-}
-
-// MuteList 获取IM群禁言列表
-func (s *sSysImGroup) MuteList(ctx context.Context, in *sysin.ImGroupMuteListInp) (list []*sysin.ImGroupMuteListModel, totalCount int, err error) {
-	if err = in.Filter(ctx); err != nil {
-		return
-	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
-	if err != nil {
-		return
-	}
-	mod := db.Model("im_group_mutes").Safe().Ctx(ctx).Where("topic", in.Topic)
-	if in.Status != "" {
-		mod = mod.Where("status", in.Status)
-	}
-	if in.UserId > 0 {
-		mod = mod.Where("user_id", in.UserId)
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("muted_at").OrderDesc("user_id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
-		err = gerror.Wrap(err, "获取IM群禁言列表失败，请稍后重试！")
-	}
-	return
-}
-
-// AdminLogList 获取IM群管理日志列表
-func (s *sSysImGroup) AdminLogList(ctx context.Context, in *sysin.ImGroupAdminLogListInp) (list []*sysin.ImGroupAdminLogListModel, totalCount int, err error) {
-	if err = in.Filter(ctx); err != nil {
-		return
-	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
-	if err != nil {
-		return
-	}
-	mod := db.Model("im_group_admin_logs").Safe().Ctx(ctx).
-		Fields(
-			"id",
-			"log_id",
-			"topic",
-			"operator_id",
-			"target_user_id",
-			"action",
-			"object_type",
-			"object_id",
-			"CAST(before_data AS CHAR) before_data",
-			"CAST(after_data AS CHAR) after_data",
-			"request_id",
-			"idempotency_key",
-			"created_at",
-		).
-		Where("topic", in.Topic)
-	if in.Action != "" {
-		mod = mod.WhereLike("action", "%"+in.Action+"%")
-	}
-	if in.OperatorId > 0 {
-		mod = mod.Where("operator_id", in.OperatorId)
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
-		err = gerror.Wrap(err, "获取IM群管理日志列表失败，请稍后重试！")
-	}
-	return
-}
-
-// ProfileUpdate 通过Kafka修改IM群资料
-func (s *sSysImGroup) ProfileUpdate(ctx context.Context, in *sysin.ImGroupProfileUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
-		return nil, err
-	}
-	if in.ActorUserId <= 0 {
-		return nil, gerror.New("操作IM用户ID不能为空")
-	}
-	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
-		"topic":         in.Topic,
-		"profile":       map[string]any{},
-		"version":       in.Version,
-	}
-	profile := payload["profile"].(map[string]any)
-	if in.Name != "" {
-		profile["name"] = in.Name
-	}
-	if in.AvatarFileId != "" {
-		profile["avatar_file_id"] = in.AvatarFileId
-	}
-	if in.Description != "" {
-		profile["description"] = in.Description
-	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupProfileUpdate, in.Topic, int64(in.Version), payload)
-}
-
-// GovernanceUpdate 通过Kafka修改IM群治理配置
+// GovernanceUpdate 更新IM群治理配置
 func (s *sSysImGroup) GovernanceUpdate(ctx context.Context, in *sysin.ImGroupGovernanceUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 {
-		return nil, gerror.New("操作IM用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"governance":    map[string]any{},
-		"version":       in.Version,
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"governance": map[string]any{
+			"join_approval":       in.JoinApproval == 1,
+			"mute_all":            in.MuteAll == 1,
+			"member_upload_files": in.MemberUploadFiles == 1,
+			"member_private_chat": in.MemberPrivateChat == 1,
+			"member_invite":       in.MemberInvite == 1,
+			"max_member_count":    in.MaxMemberCount,
+			"max_admin_count":     in.MaxAdminCount,
+		},
 	}
-	governance := payload["governance"].(map[string]any)
-	if in.JoinApproval != nil {
-		governance["join_approval"] = *in.JoinApproval
-	}
-	if in.MuteAll != nil {
-		governance["mute_all"] = *in.MuteAll
-	}
-	if in.MemberUploadFiles != nil {
-		governance["member_upload_files"] = *in.MemberUploadFiles
-	}
-	if in.MemberPrivateChat != nil {
-		governance["member_private_chat"] = *in.MemberPrivateChat
-	}
-	if in.MemberInvite != nil {
-		governance["member_invite"] = *in.MemberInvite
-	}
-	if len(governance) == 0 {
-		return nil, gerror.New("请至少选择一个治理配置")
-	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupGovernUpdate, in.Topic, int64(in.Version), payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupGovernUpdate, payload, 0)
 }
 
-// AdminSet 通过Kafka设置IM群管理员
-func (s *sSysImGroup) AdminSet(ctx context.Context, in *sysin.ImGroupAdminSetInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+func (s *sSysImGroup) ProfileUpdate(ctx context.Context, in *sysin.ImGroupProfileUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || len(in.UserIds) == 0 {
-		return nil, gerror.New("操作IM用户ID和用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"user_ids":      imUserIds(in.UserIds),
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"profile": map[string]any{
+			"name":           in.Name,
+			"avatar_file_id": in.AvatarFileId,
+			"description":    in.Description,
+		},
 	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupAdminSet, in.Topic, 0, payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupProfileUpdate, payload, in.Version)
 }
 
-// AdminRemove 通过Kafka删除IM群管理员
-func (s *sSysImGroup) AdminRemove(ctx context.Context, in *sysin.ImGroupAdminRemoveInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+// Dissolve 解散IM群
+func (s *sSysImGroup) Dissolve(ctx context.Context, in *sysin.ImGroupDissolveInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || in.UserId <= 0 {
-		return nil, gerror.New("操作IM用户ID和用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"user_id":       imUserId(in.UserId),
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"reason":        in.Reason,
 	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupAdminRemove, in.Topic, 0, payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupDissolve, payload, 0)
 }
 
-// MemberMute 通过Kafka禁言IM群成员
-func (s *sSysImGroup) MemberMute(ctx context.Context, in *sysin.ImGroupMemberMuteInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+// Mute 禁言IM群成员
+func (s *sSysImGroup) Mute(ctx context.Context, in *sysin.ImGroupMuteInp) (res *sysin.ImGroupCommandModel, err error) {
+	return s.MemberMute(ctx, in)
+}
+
+func (s *sSysImGroup) MemberMute(ctx context.Context, in *sysin.ImGroupMuteInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || in.UserId <= 0 {
-		return nil, gerror.New("操作IM用户ID和用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"user_id":       imUserId(in.UserId),
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"user_id":       strconv.FormatInt(in.UserId, 10),
 		"reason":        in.Reason,
 	}
 	if in.ExpiresAt != nil {
-		payload["expires_at"] = in.ExpiresAt.Time.UTC().Format(time.RFC3339Nano)
+		payload["expires_at"] = in.ExpiresAt.Time.Format("2006-01-02T15:04:05.000Z07:00")
 	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupMemberMute, in.Topic, 0, payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupMemberMute, payload, 0)
 }
 
-// MemberUnmute 通过Kafka解除IM群成员禁言
-func (s *sSysImGroup) MemberUnmute(ctx context.Context, in *sysin.ImGroupMemberUnmuteInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+// Unmute 解除IM群成员禁言
+func (s *sSysImGroup) Unmute(ctx context.Context, in *sysin.ImGroupUnmuteInp) (res *sysin.ImGroupCommandModel, err error) {
+	return s.MemberUnmute(ctx, in)
+}
+
+func (s *sSysImGroup) MemberUnmute(ctx context.Context, in *sysin.ImGroupUnmuteInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || in.UserId <= 0 {
-		return nil, gerror.New("操作IM用户ID和用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"user_id":       imUserId(in.UserId),
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"user_id":       strconv.FormatInt(in.UserId, 10),
 	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupMemberUnmute, in.Topic, 0, payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupMemberUnmute, payload, 0)
 }
 
-// MemberRemove 通过Kafka移出IM群成员
 func (s *sSysImGroup) MemberRemove(ctx context.Context, in *sysin.ImGroupMemberRemoveInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || in.UserId <= 0 {
-		return nil, gerror.New("操作IM用户ID和用户ID不能为空")
-	}
 	payload := map[string]any{
-		"actor_user_id": imUserId(in.ActorUserId),
 		"topic":         in.Topic,
-		"user_id":       imUserId(in.UserId),
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"user_id":       strconv.FormatInt(in.UserId, 10),
+		"reason":        in.Reason,
 	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupMemberRemove, in.Topic, 0, payload)
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupMemberRemove, payload, 0)
 }
 
-// OwnerTransfer 通过Kafka转让IM群主
-func (s *sSysImGroup) OwnerTransfer(ctx context.Context, in *sysin.ImGroupOwnerTransferInp) (res *sysin.ImGroupCommandModel, err error) {
-	if err = in.ImGroupTopicInp.Filter(ctx); err != nil {
+// JoinRequestApprove 通过IM入群申请
+func (s *sSysImGroup) JoinRequestApprove(ctx context.Context, in *sysin.ImGroupJoinRequestResolveInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.resolveJoinRequest(ctx, in, consts.ImGroupRequestStatusAccepted)
+}
+
+// JoinRequestReject 拒绝IM入群申请
+func (s *sSysImGroup) JoinRequestReject(ctx context.Context, in *sysin.ImGroupJoinRequestResolveInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.resolveJoinRequest(ctx, in, consts.ImGroupRequestStatusRejected)
+}
+
+func (s *sSysImGroup) resolveJoinRequest(ctx context.Context, in *sysin.ImGroupJoinRequestResolveInp, status string) (err error) {
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	actor := contexts.GetUserId(ctx)
+	requestId := gctx.CtxId(ctx)
+	if requestId == "" {
+		requestId = guid.S()
+	}
+	now := gtime.Now()
+	return db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		if err := s.ensureActiveGroup(ctx, tx, in.Topic); err != nil {
+			return err
+		}
+		before, txErr := s.groupJoinRequestSnapshot(ctx, tx, in.Topic, in.RequestId)
+		if txErr != nil {
+			return txErr
+		}
+		if before == nil {
+			return gerror.New("入群申请不存在")
+		}
+		if before["status"].String() != consts.ImGroupRequestStatusPending {
+			return gerror.New("入群申请已处理")
+		}
+		applicantUserId := before["applicant_user_id"].Int64()
+		if status == consts.ImGroupRequestStatusAccepted {
+			if txErr = s.upsertGroupSubscription(ctx, tx, in.Topic, applicantUserId, imGroupModeMember, now); txErr != nil {
+				return txErr
+			}
+			if txErr = s.upsertGroupMember(ctx, tx, in.Topic, applicantUserId, consts.ImGroupRoleMember, "approval", actor, now); txErr != nil {
+				return txErr
+			}
+		}
+		result, txErr := tx.Exec(`UPDATE im_group_join_requests
+			SET status=?,reject_reason=?,handled_by=?,handled_at=?,updated_at=?,version=version+1
+			WHERE topic=? AND request_id=? AND status=?`,
+			status, in.RejectReason, actor, now, now, in.Topic, in.RequestId, consts.ImGroupRequestStatusPending)
+		if txErr != nil {
+			return txErr
+		}
+		if affected, _ := result.RowsAffected(); affected == 0 {
+			return gerror.New("入群申请已处理")
+		}
+		if txErr = s.recountGroupMembers(ctx, tx, in.Topic); txErr != nil {
+			return txErr
+		}
+		after, txErr := s.groupJoinRequestSnapshot(ctx, tx, in.Topic, in.RequestId)
+		if txErr != nil {
+			return txErr
+		}
+		action := "join_request_reject"
+		if status == consts.ImGroupRequestStatusAccepted {
+			action = "join_request_accept"
+		}
+		if txErr = s.insertGroupAdminLog(ctx, tx, in.Topic, actor, applicantUserId, action, "join_request", in.RequestId, recordMap(before), recordMap(after), requestId); txErr != nil {
+			return txErr
+		}
+		return s.insertGroupEvent(ctx, tx, in.Topic, actor, "group.join_request."+status, g.Map{
+			"topic": in.Topic, "request_id": in.RequestId, "applicant_user_id": applicantUserId, "status": status, "request_id_admin": requestId,
+		})
+	})
+}
+
+// RoleUpdate 更新IM群成员角色
+func (s *sSysImGroup) RoleUpdate(ctx context.Context, in *sysin.ImGroupRoleUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	if in.ActorUserId <= 0 || in.TargetUserId <= 0 {
-		return nil, gerror.New("操作IM用户ID和新群主ID不能为空")
+	switch in.Role {
+	case consts.ImGroupRoleAdmin:
+		return s.AdminSet(ctx, in)
+	case consts.ImGroupRoleMember:
+		return s.AdminRemove(ctx, in)
+	default:
+		return nil, gerror.New("只能设置管理员或普通成员")
 	}
-	payload := map[string]any{
-		"actor_user_id":  imUserId(in.ActorUserId),
-		"topic":          in.Topic,
-		"target_user_id": imUserId(in.TargetUserId),
-		"version":        in.Version,
-	}
-	return s.publishGroupCommand(ctx, in.TenantId, consts.ImAdminCommandGroupOwnerTransfer, in.Topic, int64(in.Version), payload)
 }
 
-func (s *sSysImGroup) publishGroupCommand(ctx context.Context, tenantId int64, eventType string, topic string, version int64, payload map[string]any) (*sysin.ImGroupCommandModel, error) {
-	_, tenant, err := imtenant.DB(ctx, tenantId)
+func (s *sSysImGroup) AdminSet(ctx context.Context, in *sysin.ImGroupRoleUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	payload := map[string]any{
+		"topic":         in.Topic,
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"user_ids":      []string{strconv.FormatInt(in.UserId, 10)},
+	}
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupAdminSet, payload, 0)
+}
+
+func (s *sSysImGroup) AdminRemove(ctx context.Context, in *sysin.ImGroupRoleUpdateInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	payload := map[string]any{
+		"topic":         in.Topic,
+		"actor_user_id": strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"user_id":       strconv.FormatInt(in.UserId, 10),
+	}
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupAdminRemove, payload, 0)
+}
+
+// OwnerTransfer 转让IM群主
+func (s *sSysImGroup) OwnerTransfer(ctx context.Context, in *sysin.ImGroupOwnerTransferInp) (res *sysin.ImGroupCommandModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	payload := map[string]any{
+		"topic":          in.Topic,
+		"actor_user_id":  strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		"target_user_id": strconv.FormatInt(in.UserId, 10),
+	}
+	return s.publishGroupCommand(ctx, in.TenantId, in.Topic, consts.ImAdminCommandGroupOwnerTransfer, payload, 0)
+}
+
+func (s *sSysImGroup) publishGroupCommand(ctx context.Context, tenantId int64, topic string, eventType string, payload map[string]any, version int64) (*sysin.ImGroupCommandModel, error) {
+	_, tenant, err := resolveImTenantDB(ctx, tenantId)
 	if err != nil {
 		return nil, err
 	}
@@ -663,16 +620,385 @@ func (s *sSysImGroup) publishGroupCommand(ctx context.Context, tenantId int64, e
 	}, nil
 }
 
-func imUserId(id int64) string {
-	return strconv.FormatInt(id, 10)
+func (s *sSysImGroup) groupGovernanceSnapshot(ctx context.Context, tx gdb.TX, topic string) (res gdb.Record, err error) {
+	return tx.Model("im_group_settings").Safe().Ctx(ctx).
+		Fields(
+			"topic", "owner_user_id", "name", "group_status", "join_approval", "mute_all",
+			"member_upload_files", "member_private_chat", "member_invite", "max_member_count",
+			"max_admin_count", "member_count", "version", "created_by", "dissolved_by",
+			"dissolved_at", "created_at", "updated_at",
+		).
+		Where("topic", topic).
+		One()
 }
 
-func imUserIds(ids []int64) []string {
-	list := make([]string, 0, len(ids))
-	for _, id := range ids {
-		if id > 0 {
-			list = append(list, imUserId(id))
+func (s *sSysImGroup) groupJoinRequestSnapshot(ctx context.Context, tx gdb.TX, topic string, requestId string) (res gdb.Record, err error) {
+	return tx.Model("im_group_join_requests").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("request_id", requestId).
+		One()
+}
+
+func (s *sSysImGroup) groupMemberSnapshot(ctx context.Context, tx gdb.TX, topic string, userId int64) (res gdb.Record, err error) {
+	return tx.Model("im_group_members").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("user_id", userId).
+		One()
+}
+
+func (s *sSysImGroup) groupFileSnapshot(ctx context.Context, tx gdb.TX, topic string, groupFileId string) (res gdb.Record, err error) {
+	return tx.Model("im_group_files").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("group_file_id", groupFileId).
+		One()
+}
+
+func (s *sSysImGroup) ensureActiveGroup(ctx context.Context, tx gdb.TX, topic string) error {
+	status, err := tx.Model("im_group_settings").Safe().Ctx(ctx).Where("topic", topic).Value("group_status")
+	if err != nil {
+		return err
+	}
+	if status.IsNil() {
+		return gerror.New("群治理配置不存在")
+	}
+	if status.String() == consts.ImGroupStatusDissolved {
+		return gerror.New("已解散群不能执行该操作")
+	}
+	return nil
+}
+
+func (s *sSysImGroup) groupMuteSnapshot(ctx context.Context, tx gdb.TX, topic string, userId int64) (res gdb.Record, err error) {
+	return tx.Model("im_group_mutes").Safe().Ctx(ctx).
+		Fields(
+			"topic", "user_id", "muted_by", "muted_at", "expires_at", "reason", "status",
+			"revoked_by", "revoked_at", "version", "created_at", "updated_at",
+		).
+		Where("topic", topic).
+		Where("user_id", userId).
+		One()
+}
+
+func (s *sSysImGroup) ensureActiveGroupMember(ctx context.Context, tx gdb.TX, topic string, userId int64) error {
+	count, err := tx.Model("im_group_members").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("user_id", userId).
+		Where("member_status", consts.ImGroupMemberStatusActive).
+		Count()
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return gerror.New("成员不在群内或不是正常状态")
+	}
+	return nil
+}
+
+func (s *sSysImGroup) ensureAdminLimit(ctx context.Context, tx gdb.TX, topic string, userId int64) error {
+	currentRole, err := tx.Model("im_group_members").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("user_id", userId).
+		Where("member_status", consts.ImGroupMemberStatusActive).
+		Value("role")
+	if err != nil {
+		return err
+	}
+	if currentRole.String() == consts.ImGroupRoleAdmin {
+		return nil
+	}
+	maxAdminCount, err := tx.Model("im_group_settings").Safe().Ctx(ctx).Where("topic", topic).Value("max_admin_count")
+	if err != nil {
+		return err
+	}
+	if maxAdminCount.Int() <= 0 {
+		return nil
+	}
+	adminCount, err := tx.Model("im_group_members").Safe().Ctx(ctx).
+		Where("topic", topic).
+		Where("role", consts.ImGroupRoleAdmin).
+		Where("member_status", consts.ImGroupMemberStatusActive).
+		Count()
+	if err != nil {
+		return err
+	}
+	if adminCount >= maxAdminCount.Int() {
+		return gerror.New("群管理员数量已达上限")
+	}
+	return nil
+}
+
+func (s *sSysImGroup) upsertGroupSubscription(ctx context.Context, tx gdb.TX, topic string, userId int64, modeGiven string, now *gtime.Time) error {
+	_, err := tx.Exec(`INSERT INTO im_subscriptions(createdat,updatedat,deletedat,userid,topic,modewant,modegiven,private)
+		VALUES(?,?,NULL,?,?,?,?,CAST('{}' AS JSON))
+		ON DUPLICATE KEY UPDATE createdat=VALUES(createdat),updatedat=VALUES(updatedat),deletedat=NULL,
+		modewant=VALUES(modewant),modegiven=VALUES(modegiven),delid=0,recvseqid=0,readseqid=0`,
+		now, now, userId, topic, imGroupModeMember, modeGiven)
+	return err
+}
+
+func (s *sSysImGroup) upsertGroupMember(ctx context.Context, tx gdb.TX, topic string, userId int64, role string, joinSource string, joinedBy int64, now *gtime.Time) error {
+	_, err := tx.Exec(`INSERT INTO im_group_members(topic,user_id,role,member_status,join_source,joined_by,joined_at,version,created_at,updated_at)
+		VALUES(?,?,?,?,?,?,?,?,?,?)
+		ON DUPLICATE KEY UPDATE role=VALUES(role),member_status=VALUES(member_status),join_source=VALUES(join_source),
+		joined_by=VALUES(joined_by),joined_at=VALUES(joined_at),left_at=NULL,removed_by=NULL,version=version+1,updated_at=VALUES(updated_at)`,
+		topic, userId, role, consts.ImGroupMemberStatusActive, joinSource, joinedBy, now, 1, now, now)
+	return err
+}
+
+func (s *sSysImGroup) recountGroupMembers(ctx context.Context, tx gdb.TX, topic string) error {
+	if _, err := tx.Exec(`UPDATE im_group_settings
+		SET member_count=(SELECT COUNT(*) FROM im_group_members WHERE topic=? AND member_status=?),updated_at=CURRENT_TIMESTAMP(3)
+		WHERE topic=?`, topic, consts.ImGroupMemberStatusActive, topic); err != nil {
+		return err
+	}
+	_, err := tx.Exec(`UPDATE im_topics
+		SET subcnt=(SELECT COUNT(*) FROM im_subscriptions WHERE topic=? AND deletedat IS NULL),updatedat=CURRENT_TIMESTAMP(3)
+		WHERE name=?`, topic, topic)
+	return err
+}
+
+func recordMap(record gdb.Record) any {
+	if record == nil {
+		return nil
+	}
+	return record.Map()
+}
+
+func (s *sSysImGroup) insertGroupAdminLog(ctx context.Context, tx gdb.TX, topic string, operatorId int64, targetUserId int64, action string, objectType string, objectId string, beforeData any, afterData any, requestId string) error {
+	id, err := imtenant.NextSnowflakeID(ctx)
+	if err != nil {
+		return gerror.Wrap(err, "生成群管理日志ID失败")
+	}
+	logId := fmt.Sprintf("gal_%d", id)
+	beforeJson, _ := json.Marshal(beforeData)
+	afterJson, _ := json.Marshal(afterData)
+	_, err = tx.Exec(`INSERT INTO im_group_admin_logs
+		(log_id,topic,operator_id,target_user_id,action,object_type,object_id,before_data,after_data,request_id,idempotency_key)
+		VALUES(?,?,?,?,?,?,?,CAST(? AS JSON),CAST(? AS JSON),?,?)`,
+		logId, topic, operatorId, targetUserId, action, objectType, objectId, string(beforeJson), string(afterJson), requestId, requestId)
+	return err
+}
+
+func (s *sSysImGroup) insertGroupEvent(ctx context.Context, tx gdb.TX, topic string, actorId int64, eventType string, payload any) error {
+	id, err := imtenant.NextSnowflakeID(ctx)
+	if err != nil {
+		return gerror.Wrap(err, "生成群事件ID失败")
+	}
+	payloadJson, _ := json.Marshal(payload)
+	_, err = tx.Exec(`INSERT INTO im_group_events_outbox
+		(event_id,topic,actor_user_id,event_type,payload,status)
+		VALUES(?,?,?,?,CAST(? AS JSON),'pending')`,
+		fmt.Sprintf("gev_%d", id), topic, actorId, eventType, string(payloadJson))
+	return err
+}
+
+// JoinRequestList 获取IM入群申请列表
+func (s *sSysImGroup) JoinRequestList(ctx context.Context, in *sysin.ImGroupJoinRequestListInp) (list []*sysin.ImGroupJoinRequestListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_join_requests").Safe().Ctx(ctx).Where("topic", in.Topic)
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	if in.ApplicantUserId > 0 {
+		mod = mod.Where("applicant_user_id", in.ApplicantUserId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM入群申请列表失败，请稍后重试！")
+	}
+	return
+}
+
+// FileList 获取IM群文件列表
+func (s *sSysImGroup) FileList(ctx context.Context, in *sysin.ImGroupFileListInp) (list []*sysin.ImGroupFileListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_files").Safe().Ctx(ctx).Where("topic", in.Topic)
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	if in.FileType != "" {
+		mod = mod.Where("file_type", in.FileType)
+	}
+	if in.FileName != "" {
+		mod = mod.WhereLike("file_name", "%"+in.FileName+"%")
+	}
+	if in.UploaderId > 0 {
+		mod = mod.Where("uploader_id", in.UploaderId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM群文件列表失败，请稍后重试！")
+	}
+	return
+}
+
+// FileDelete 删除IM群文件
+func (s *sSysImGroup) FileDelete(ctx context.Context, in *sysin.ImGroupFileDeleteInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	actor := contexts.GetUserId(ctx)
+	requestId := gctx.CtxId(ctx)
+	if requestId == "" {
+		requestId = guid.S()
+	}
+	now := gtime.Now()
+	return db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		if err := s.ensureActiveGroup(ctx, tx, in.Topic); err != nil {
+			return err
+		}
+		before, txErr := s.groupFileSnapshot(ctx, tx, in.Topic, in.GroupFileId)
+		if txErr != nil {
+			return txErr
+		}
+		if before == nil {
+			return gerror.New("群文件不存在")
+		}
+		if before["status"].String() == consts.ImGroupFileStatusDeleted {
+			return gerror.New("群文件已删除")
+		}
+		result, txErr := tx.Exec(`UPDATE im_group_files
+			SET status=?,deleted_by=?,deleted_at=?,updated_at=?
+			WHERE topic=? AND group_file_id=? AND status<>?`,
+			consts.ImGroupFileStatusDeleted, actor, now, now, in.Topic, in.GroupFileId, consts.ImGroupFileStatusDeleted)
+		if txErr != nil {
+			return txErr
+		}
+		if affected, _ := result.RowsAffected(); affected == 0 {
+			return gerror.New("群文件已删除")
 		}
+		after, txErr := s.groupFileSnapshot(ctx, tx, in.Topic, in.GroupFileId)
+		if txErr != nil {
+			return txErr
+		}
+		if txErr = s.insertGroupAdminLog(ctx, tx, in.Topic, actor, before["uploader_id"].Int64(), "group_file_delete", "group_file", in.GroupFileId, recordMap(before), recordMap(after), requestId); txErr != nil {
+			return txErr
+		}
+		return s.insertGroupEvent(ctx, tx, in.Topic, actor, "group.file.deleted", g.Map{
+			"topic": in.Topic, "group_file_id": in.GroupFileId, "file_id": before["file_id"].String(), "request_id": requestId,
+		})
+	})
+}
+
+// InvitationList 获取IM群邀请列表
+func (s *sSysImGroup) InvitationList(ctx context.Context, in *sysin.ImGroupInvitationListInp) (list []*sysin.ImGroupInvitationListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_invitations").Safe().Ctx(ctx).Where("topic", in.Topic)
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	if in.TargetUserId > 0 {
+		mod = mod.Where("target_user_id", in.TargetUserId)
+	}
+	if in.InviterUserId > 0 {
+		mod = mod.Where("inviter_user_id", in.InviterUserId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM群邀请列表失败，请稍后重试！")
+	}
+	return
+}
+
+// AnnouncementList 获取IM群公告列表
+func (s *sSysImGroup) AnnouncementList(ctx context.Context, in *sysin.ImGroupAnnouncementListInp) (list []*sysin.ImGroupAnnouncementListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_announcements").Safe().Ctx(ctx).Where("topic", in.Topic)
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("published_at").OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM群公告列表失败，请稍后重试！")
+	}
+	return
+}
+
+// MuteList 获取IM群禁言列表
+func (s *sSysImGroup) MuteList(ctx context.Context, in *sysin.ImGroupMuteListInp) (list []*sysin.ImGroupMuteListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_mutes").Safe().Ctx(ctx).Where("topic", in.Topic)
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	if in.UserId > 0 {
+		mod = mod.Where("user_id", in.UserId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("muted_at").OrderDesc("user_id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM群禁言列表失败，请稍后重试！")
+	}
+	return
+}
+
+// AdminLogList 获取IM群管理日志列表
+func (s *sSysImGroup) AdminLogList(ctx context.Context, in *sysin.ImGroupAdminLogListInp) (list []*sysin.ImGroupAdminLogListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	mod := db.Model("im_group_admin_logs").Safe().Ctx(ctx).
+		Fields(
+			"id",
+			"log_id",
+			"topic",
+			"operator_id",
+			"target_user_id",
+			"action",
+			"object_type",
+			"object_id",
+			"CAST(before_data AS CHAR) before_data",
+			"CAST(after_data AS CHAR) after_data",
+			"request_id",
+			"idempotency_key",
+			"created_at",
+		).
+		Where("topic", in.Topic)
+	if in.Action != "" {
+		mod = mod.WhereLike("action", "%"+in.Action+"%")
+	}
+	if in.OperatorId > 0 {
+		mod = mod.Where("operator_id", in.OperatorId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM群管理日志列表失败，请稍后重试！")
 	}
-	return list
+	return
 }

server/internal/logic/sys/im_invite.go

@@ -2,247 +2,512 @@ package sys
 
 import (
 	"context"
+	cryptorand "crypto/rand"
+	"encoding/csv"
+	"errors"
 	"fmt"
-	"hotgo/internal/library/imadmin"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
-	"io"
+	"net/url"
 	"strconv"
+	"strings"
 	"time"
 
+	mysqldriver "github.com/go-sql-driver/mysql"
+	"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"
 )
 
+const inviteGenerateRetries = 10
+
+var errInviteBatchNotFound = errors.New("invite batch not found")
+
 type sSysImInvite struct{}
 
-func NewSysImInvite() *sSysImInvite {
-	return &sSysImInvite{}
-}
+func NewSysImInvite() *sSysImInvite { return &sSysImInvite{} }
 
-func init() {
-	service.RegisterSysImInvite(NewSysImInvite())
-}
+func init() { service.RegisterSysImInvite(NewSysImInvite()) }
 
 type imInviteListRequest struct {
-	Page           int    `json:"page,omitempty"`
-	PerPage        int    `json:"per_page,omitempty"`
-	InviteCode     string `json:"invite_code,omitempty"`
-	Status         string `json:"status,omitempty"`
-	BatchID        int64  `json:"batch_id,omitempty"`
-	CreatedBy      int64  `json:"created_by,omitempty"`
-	CreatedAtStart string `json:"created_at_start,omitempty"`
-	CreatedAtEnd   string `json:"created_at_end,omitempty"`
-	ExpiresAtStart string `json:"expires_at_start,omitempty"`
-	ExpiresAtEnd   string `json:"expires_at_end,omitempty"`
-}
-
-type imInviteCreateRequest struct {
-	ExpiresAt      string `json:"expires_at"`
-	Remark         string `json:"remark,omitempty"`
-	IdempotencyKey string `json:"idempotency_key,omitempty"`
-}
-
-type imInviteBatchCreateRequest struct {
-	Quantity       int    `json:"quantity"`
-	ExpiresAt      string `json:"expires_at"`
-	Remark         string `json:"remark,omitempty"`
-	IdempotencyKey string `json:"idempotency_key,omitempty"`
+	TenantID       int64
+	InviteCode     string
+	Status         string
+	BatchID        int64
+	CreatedBy      int64
+	CreatedAtStart *time.Time
+	CreatedAtEnd   *time.Time
+	ExpiresAtStart *time.Time
+	ExpiresAtEnd   *time.Time
 }
 
 type imInviteCodeResponse struct {
-	ID        int64      `json:"id"`
-	BatchID   *int64     `json:"batch_id"`
-	Code      string     `json:"code"`
-	Status    string     `json:"status"`
-	ExpiresAt *time.Time `json:"expires_at"`
-	UsedBy    *int64     `json:"used_by"`
-	UsedAt    *time.Time `json:"used_at"`
-	RequestID string     `json:"request_id"`
-	CreatedBy int64      `json:"created_by"`
-	Remark    string     `json:"remark"`
-	CreatedAt *time.Time `json:"created_at"`
+	ID             int64      `json:"id"`
+	TenantID       int64      `json:"tenant_id"`
+	TenantName     string     `json:"tenant_name"`
+	BatchID        *int64     `json:"batch_id"`
+	Code           string     `json:"code"`
+	Status         string     `json:"status"`
+	ExpiresAt      time.Time  `json:"expires_at"`
+	MaxUses        int        `json:"max_uses"`
+	UsageCount     int        `json:"usage_count"`
+	BoundUserID    *int64     `json:"bound_user_id"`
+	BoundUserLabel string     `json:"bound_user_label"`
+	LastUsedAt     *time.Time `json:"last_used_at"`
+	CreatedBy      int64      `json:"created_by"`
+	Remark         string     `json:"remark"`
+	CreatedAt      time.Time  `json:"created_at"`
 }
 
 type imInviteBatchResponse struct {
-	BatchID      int64      `json:"batch_id"`
-	Quantity     int        `json:"quantity"`
-	ActiveCount  int        `json:"active_count"`
-	UsedCount    int        `json:"used_count"`
-	RevokedCount int        `json:"revoked_count"`
-	ExpiredCount int        `json:"expired_count"`
-	ExpiresAt    *time.Time `json:"expires_at"`
-	CreatedAt    *time.Time `json:"created_at"`
+	BatchID        int64     `json:"batch_id"`
+	TenantID       int64     `json:"tenant_id"`
+	Quantity       int       `json:"quantity"`
+	IdempotencyKey string    `json:"idempotency_key"`
+	Remark         string    `json:"remark"`
+	ActiveCount    int       `json:"active_count"`
+	UsageCount     int       `json:"usage_count"`
+	RevokedCount   int       `json:"revoked_count"`
+	ExpiredCount   int       `json:"expired_count"`
+	ExpiresAt      time.Time `json:"expires_at"`
+	CreatedAt      time.Time `json:"created_at"`
 }
 
 func (s *sSysImInvite) List(ctx context.Context, in *sysin.ImInviteListInp) (list []*sysin.ImInviteCodeModel, totalCount int, err error) {
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteQueryDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return nil, 0, err
 	}
 	req, err := buildInviteListRequest(in)
 	if err != nil {
-		return
+		return nil, 0, err
 	}
-	var page imadmin.Page[imInviteCodeResponse]
-	if err = imadmin.DefaultClient(ctx).ListCodes(ctx, scope, req, &page); err != nil {
-		_ = writeImAdminAudit(ctx, scope.TenantId, "invite_list", "invite_code", 0, "failed", g.Map{"hasInviteCode": in.InviteCode != ""})
-		return
+	if !validInviteStatus(req.Status) {
+		return nil, 0, gerror.New("邀请码状态不正确")
 	}
-	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_list", "invite_code", 0, "success", g.Map{"hasInviteCode": in.InviteCode != ""})
-	list = make([]*sysin.ImInviteCodeModel, 0, len(page.Items))
-	for i := range page.Items {
-		list = append(list, convertInviteCode(page.Items[i]))
+	req.TenantID = scope.TenantId
+	items, total, err := queryInviteCodes(ctx, db, req, in.PerPage, (in.Page-1)*in.PerPage)
+	result := "success"
+	if err != nil {
+		result = "failed"
+	} else {
+		list = convertInviteCodes(items)
+		totalCount = total
 	}
-	totalCount = page.Total
-	return
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_list", "invite_code", 0, result, g.Map{"hasInviteCode": in.InviteCode != ""})
+	return list, totalCount, err
 }
 
 func (s *sSysImInvite) Create(ctx context.Context, in *sysin.ImInviteCreateInp) (res *sysin.ImInviteCodeModel, err error) {
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return nil, err
+	}
+	expiresAt := in.ExpiresAt.Time.UTC().Round(time.Millisecond)
+	var item imInviteCodeResponse
+	if key := strings.TrimSpace(in.IdempotencyKey); key != "" {
+		batch, codes, createErr := createInviteBatch(ctx, db, scope.TenantId, scope.OperatorId, 1, expiresAt, in.Remark, key)
+		if createErr != nil {
+			err = createErr
+		} else if len(codes) > 0 {
+			item = codes[0]
+		} else {
+			codes, _, err = queryInviteCodes(ctx, db, imInviteListRequest{TenantID: scope.TenantId, BatchID: batch.BatchID}, 1, 0)
+			if err == nil && len(codes) > 0 {
+				item = codes[0]
+			} else if err == nil {
+				err = gerror.New("邀请码生成结果不存在")
+			}
+		}
+	} else {
+		item, err = createSingleInvite(ctx, db, scope.TenantId, scope.OperatorId, expiresAt, in.Remark)
 	}
-	req := imInviteCreateRequest{ExpiresAt: formatRFC3339(in.ExpiresAt), Remark: in.Remark, IdempotencyKey: in.IdempotencyKey}
-	var upstream imInviteCodeResponse
-	err = imadmin.DefaultClient(ctx).CreateCode(ctx, scope, req, &upstream)
-	res = convertInviteCode(upstream)
 	result := "success"
 	if err != nil {
 		result = "failed"
+	} else {
+		res = convertInviteCode(item)
 	}
-	targetId, _ := strconv.ParseInt(res.Id, 10, 64)
-	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_create", "invite_code", targetId, result, g.Map{"expiresAt": in.ExpiresAt, "remark": in.Remark})
-	return
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_create", "invite_code", item.ID, result, g.Map{"expiresAt": in.ExpiresAt, "remark": in.Remark})
+	return res, err
 }
 
 func (s *sSysImInvite) BatchCreate(ctx context.Context, in *sysin.ImInviteBatchCreateInp) (res *sysin.ImInviteBatchModel, err error) {
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return nil, err
 	}
-	req := imInviteBatchCreateRequest{Quantity: in.Quantity, ExpiresAt: formatRFC3339(in.ExpiresAt), Remark: in.Remark, IdempotencyKey: in.IdempotencyKey}
-	var upstream imInviteBatchResponse
-	err = imadmin.DefaultClient(ctx).CreateBatch(ctx, scope, req, &upstream)
-	res = convertInviteBatch(upstream)
+	key := strings.TrimSpace(in.IdempotencyKey)
+	batch, _, err := createInviteBatch(ctx, db, scope.TenantId, scope.OperatorId, in.Quantity, in.ExpiresAt.Time.UTC().Round(time.Millisecond), in.Remark, key)
 	result := "success"
 	if err != nil {
 		result = "failed"
+	} else {
+		res = convertInviteBatch(batch)
 	}
-	targetId, _ := strconv.ParseInt(res.BatchId, 10, 64)
-	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_batch_create", "invite_batch", targetId, result, g.Map{"quantity": in.Quantity, "expiresAt": in.ExpiresAt, "remark": in.Remark})
-	return
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_batch_create", "invite_batch", batchID(batch), result, g.Map{"quantity": in.Quantity, "expiresAt": in.ExpiresAt, "remark": in.Remark})
+	return res, err
 }
 
 func (s *sSysImInvite) BatchView(ctx context.Context, in *sysin.ImInviteBatchViewInp) (res *sysin.ImInviteBatchDetailModel, err error) {
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return nil, err
 	}
-	batchId, err := sysin.ParseOptionalInt64(in.BatchId)
+	id, err := sysin.ParseOptionalInt64(in.BatchId)
 	if err != nil {
-		return
+		return nil, err
 	}
-	var upstream imInviteBatchResponse
-	err = imadmin.DefaultClient(ctx).GetBatch(ctx, scope, batchId, &upstream)
-	res = &sysin.ImInviteBatchDetailModel{ImInviteBatchModel: *convertInviteBatch(upstream)}
-	return
+	batch, err := getInviteBatch(ctx, db, scope.TenantId, "b.id=?", id)
+	if err != nil {
+		return nil, err
+	}
+	codes, _, err := queryInviteCodes(ctx, db, imInviteListRequest{TenantID: scope.TenantId, BatchID: id}, batch.Quantity, 0)
+	if err != nil {
+		return nil, err
+	}
+	return &sysin.ImInviteBatchDetailModel{ImInviteBatchModel: *convertInviteBatch(batch), List: convertInviteCodes(codes)}, nil
 }
 
 func (s *sSysImInvite) Revoke(ctx context.Context, in *sysin.ImInviteRevokeInp) (err error) {
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return err
 	}
 	id, err := sysin.ParseOptionalInt64(in.Id)
 	if err != nil {
-		return
+		return err
 	}
-	err = imadmin.DefaultClient(ctx).RevokeCode(ctx, scope, id)
-	result := "success"
+	now := time.Now().UTC().Round(time.Millisecond)
+	result, err := db.Exec(ctx, `UPDATE im_registration_invite_codes SET status='revoked',updated_at=?
+		WHERE tenant_id=? AND id=? AND status='active' AND expires_at>?`, now, scope.TenantId, id, now)
+	if err == nil {
+		if affected, _ := result.RowsAffected(); affected == 0 {
+			err = gerror.New("有效邀请码不存在")
+		}
+	}
+	auditResult := "success"
 	if err != nil {
-		result = "failed"
+		auditResult = "failed"
 	}
-	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_revoke", "invite_code", id, result, nil)
-	return
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_revoke", "invite_code", id, auditResult, nil)
+	return err
+}
+
+func (s *sSysImInvite) BindUser(ctx context.Context, in *sysin.ImInviteBindUserInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return err
+	}
+	scope, db, err := inviteDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	id, err := sysin.ParseOptionalInt64(in.Id)
+	if err != nil || id <= 0 {
+		return gerror.New("邀请码ID不能为空")
+	}
+	tenant, err := resolveImAdminTenant(ctx, scope.TenantId)
+	if err != nil {
+		return err
+	}
+	label, err := inviteBoundUserLabel(ctx, tenant, in.UserId)
+	if err != nil {
+		return err
+	}
+	now := time.Now().UTC().Round(time.Millisecond)
+	result, err := db.Exec(ctx, `UPDATE im_registration_invite_codes
+		SET bound_user_id=?,bound_user_label=?,updated_at=?
+		WHERE tenant_id=? AND id=? AND status='active' AND usage_count=0 AND (bound_user_id IS NULL OR bound_user_id=0)`,
+		in.UserId, label, now, scope.TenantId, id)
+	if err == nil {
+		if affected, _ := result.RowsAffected(); affected == 0 {
+			err = gerror.New("邀请码不存在、已使用、已绑定或不可绑定")
+		}
+	}
+	auditResult := "success"
+	if err != nil {
+		auditResult = "failed"
+	}
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_bind_user", "invite_code", id, auditResult, g.Map{"user_id": in.UserId})
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 func (s *sSysImInvite) BatchRevoke(ctx context.Context, in *sysin.ImInviteBatchRevokeInp) (res *sysin.ImInviteBatchModel, err error) {
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return nil, err
 	}
-	batchId, err := sysin.ParseOptionalInt64(in.BatchId)
+	id, err := sysin.ParseOptionalInt64(in.BatchId)
 	if err != nil {
-		return
+		return nil, err
 	}
-	var upstream struct {
-		Batch        *imInviteBatchResponse `json:"batch"`
-		RevokedCount int                    `json:"revoked_count"`
+	if _, err = getInviteBatch(ctx, db, scope.TenantId, "b.id=?", id); err == nil {
+		now := time.Now().UTC().Round(time.Millisecond)
+		_, err = db.Exec(ctx, `UPDATE im_registration_invite_codes SET status='revoked',updated_at=?
+			WHERE tenant_id=? AND batch_id=? AND status='active' AND expires_at>?`, now, scope.TenantId, id, now)
 	}
-	err = imadmin.DefaultClient(ctx).RevokeBatch(ctx, scope, batchId, &upstream)
-	if upstream.Batch != nil {
-		res = convertInviteBatch(*upstream.Batch)
+	var batch *imInviteBatchResponse
+	if err == nil {
+		batch, err = getInviteBatch(ctx, db, scope.TenantId, "b.id=?", id)
+	}
+	auditResult := "success"
+	if err != nil {
+		auditResult = "failed"
 	} else {
-		res = &sysin.ImInviteBatchModel{BatchId: strconv.FormatInt(batchId, 10), RevokedCount: upstream.RevokedCount}
+		res = convertInviteBatch(batch)
 	}
-	result := "success"
-	if err != nil {
-		result = "failed"
-	}
-	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_batch_revoke", "invite_batch", batchId, result, nil)
-	return
+	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_batch_revoke", "invite_batch", id, auditResult, nil)
+	return res, err
 }
 
 func (s *sSysImInvite) Export(ctx context.Context, in *sysin.ImInviteListInp) (err error) {
 	if err = in.Filter(ctx); err != nil {
-		return
+		return err
 	}
-	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	scope, db, err := inviteQueryDB(ctx, in.TenantId)
 	if err != nil {
-		return
+		return err
 	}
 	req, err := buildInviteListRequest(in)
-	if err != nil {
-		return
+	if err != nil || !validInviteStatus(req.Status) {
+		return gerror.New("导出条件不正确")
 	}
-	resp, err := imadmin.DefaultClient(ctx).ExportCodes(ctx, scope, req)
-	if err != nil {
-		_ = writeImAdminAudit(ctx, scope.TenantId, "invite_export", "invite_code", 0, "failed", g.Map{"hasInviteCode": in.InviteCode != ""})
-		return
-	}
-	defer resp.Body.Close()
+	req.TenantID = scope.TenantId
 	request := ghttp.RequestFromCtx(ctx)
 	if request == nil {
 		return gerror.New("请求上下文不存在")
 	}
-	filename := resp.Header.Get("Content-Disposition")
-	if filename == "" {
-		filename = `attachment; filename="registration-invite-codes.csv"`
-	}
-	request.Response.Header().Set("Content-Type", resp.Header.Get("Content-Type"))
-	request.Response.Header().Set("Content-Disposition", filename)
-	if _, err = io.Copy(request.Response.Writer, resp.Body); err != nil {
-		return gerror.Wrap(err, "转发导出文件失败")
+	request.Response.Header().Set("Content-Type", "text/csv; charset=utf-8")
+	request.Response.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=registration-invite-codes-%s.csv", time.Now().Format("20060102-150405")))
+	_, _ = request.Response.Writer.Write([]byte{0xef, 0xbb, 0xbf})
+	writer := csv.NewWriter(request.Response.Writer)
+	_ = writer.Write([]string{"tenant_id", "tenant_name", "code", "status", "expires_at", "usage_count", "available_uses", "last_used_at", "created_by", "created_at", "remark"})
+	for offset := 0; ; offset += 100 {
+		items, total, queryErr := queryInviteCodes(ctx, db, req, 100, offset)
+		if queryErr != nil {
+			return gerror.Wrap(queryErr, "导出邀请码失败")
+		}
+		for _, item := range items {
+			_ = writer.Write([]string{strconv.FormatInt(item.TenantID, 10), item.TenantName, item.Code, item.Status, item.ExpiresAt.Format(time.RFC3339), strconv.Itoa(item.UsageCount), formatInviteAvailableUses(item.MaxUses, item.UsageCount), formatTime(item.LastUsedAt), strconv.FormatInt(item.CreatedBy, 10), item.CreatedAt.Format(time.RFC3339), item.Remark})
+		}
+		writer.Flush()
+		if writer.Error() != nil {
+			return writer.Error()
+		}
+		if offset+len(items) >= total || len(items) == 0 {
+			break
+		}
 	}
 	_ = writeImAdminAudit(ctx, scope.TenantId, "invite_export", "invite_code", 0, "success", g.Map{"hasInviteCode": in.InviteCode != ""})
-	fmt.Fprint(request.Response.Writer, "")
-	return
+	return nil
+}
+
+func inviteDB(ctx context.Context, selectedTenantID int64) (imAdminScope, gdb.DB, error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantID)
+	if err != nil {
+		return scope, nil, err
+	}
+	return scope, imtenant.RegistryDB(), nil
+}
+
+func inviteQueryDB(ctx context.Context, selectedTenantID int64) (imAdminScope, gdb.DB, error) {
+	scope, err := resolveImAdminScopeWithAll(ctx, selectedTenantID, true)
+	if err != nil {
+		return scope, nil, err
+	}
+	return scope, imtenant.RegistryDB(), nil
+}
+
+func createSingleInvite(ctx context.Context, db gdb.DB, tenantID, operatorID int64, expiresAt time.Time, remark string) (imInviteCodeResponse, error) {
+	for attempt := 0; attempt < inviteGenerateRetries; attempt++ {
+		id, err := imtenant.NextSnowflakeID(ctx)
+		if err != nil {
+			return imInviteCodeResponse{}, err
+		}
+		code, err := randomInviteCode()
+		if err != nil {
+			return imInviteCodeResponse{}, err
+		}
+		now := time.Now().UTC().Round(time.Millisecond)
+		_, err = db.Exec(ctx, `INSERT INTO im_registration_invite_codes
+			(id,tenant_id,batch_id,code,status,expires_at,max_uses,usage_count,last_used_at,created_by,remark,created_at,updated_at)
+			VALUES(?,?,NULL,?,'active',?,1,0,NULL,?,?,?,?)`, id, tenantID, code, expiresAt, operatorID, remark, now, now)
+		if err == nil {
+			return imInviteCodeResponse{ID: id, TenantID: tenantID, Code: code, Status: "active", ExpiresAt: expiresAt, MaxUses: 1, CreatedBy: operatorID, Remark: remark, CreatedAt: now}, nil
+		}
+		if !isDuplicateError(err) {
+			return imInviteCodeResponse{}, err
+		}
+	}
+	return imInviteCodeResponse{}, gerror.New("无法生成不重复的邀请码，请重试")
+}
+
+func createInviteBatch(ctx context.Context, db gdb.DB, tenantID, operatorID int64, quantity int, expiresAt time.Time, remark, key string) (*imInviteBatchResponse, []imInviteCodeResponse, error) {
+	if existing, err := getInviteBatch(ctx, db, tenantID, "b.idempotency_key=?", key); err == nil {
+		if !sameInviteBatch(existing, quantity, expiresAt, remark) {
+			return nil, nil, gerror.New("幂等键已被其他批量生成请求使用")
+		}
+		return existing, nil, nil
+	} else if !errors.Is(err, errInviteBatchNotFound) {
+		return nil, nil, err
+	}
+	for attempt := 0; attempt < inviteGenerateRetries; attempt++ {
+		batchID, err := imtenant.NextSnowflakeID(ctx)
+		if err != nil {
+			return nil, nil, err
+		}
+		codes := make([]imInviteCodeResponse, quantity)
+		seen := make(map[string]struct{}, quantity)
+		for i := range codes {
+			for {
+				code, randomErr := randomInviteCode()
+				if randomErr != nil {
+					return nil, nil, randomErr
+				}
+				if _, ok := seen[code]; ok {
+					continue
+				}
+				seen[code] = struct{}{}
+				codes[i].Code = code
+				break
+			}
+			codes[i].ID, err = imtenant.NextSnowflakeID(ctx)
+			if err != nil {
+				return nil, nil, err
+			}
+			codes[i].BatchID = &batchID
+		}
+		now := time.Now().UTC().Round(time.Millisecond)
+		err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+			if _, txErr := tx.Exec(`INSERT INTO im_registration_invite_batches
+				(id,tenant_id,quantity,idempotency_key,expires_at,created_by,remark,created_at,updated_at)
+				VALUES(?,?,?,?,?,?,?,?,?)`, batchID, tenantID, quantity, key, expiresAt, operatorID, remark, now, now); txErr != nil {
+				return txErr
+			}
+			for i := range codes {
+				if _, txErr := tx.Exec(`INSERT INTO im_registration_invite_codes
+					(id,tenant_id,batch_id,code,status,expires_at,max_uses,usage_count,last_used_at,created_by,remark,created_at,updated_at)
+					VALUES(?,?,?,?,'active',?,0,0,NULL,?,?,?,?)`, codes[i].ID, tenantID, batchID, codes[i].Code, expiresAt, operatorID, remark, now, now); txErr != nil {
+					return txErr
+				}
+				codes[i].TenantID, codes[i].Status, codes[i].ExpiresAt, codes[i].CreatedBy, codes[i].Remark, codes[i].CreatedAt = tenantID, "active", expiresAt, operatorID, remark, now
+			}
+			return nil
+		})
+		if err == nil {
+			return &imInviteBatchResponse{BatchID: batchID, TenantID: tenantID, Quantity: quantity, IdempotencyKey: key, Remark: remark, ActiveCount: quantity, ExpiresAt: expiresAt, CreatedAt: now}, codes, nil
+		}
+		if !isDuplicateError(err) {
+			return nil, nil, err
+		}
+		if existing, lookupErr := getInviteBatch(ctx, db, tenantID, "b.idempotency_key=?", key); lookupErr == nil {
+			if !sameInviteBatch(existing, quantity, expiresAt, remark) {
+				return nil, nil, gerror.New("幂等键已被其他批量生成请求使用")
+			}
+			return existing, nil, nil
+		} else if !errors.Is(lookupErr, errInviteBatchNotFound) {
+			return nil, nil, lookupErr
+		}
+	}
+	return nil, nil, gerror.New("无法生成不重复的邀请码，请重试")
+}
+
+func queryInviteCodes(ctx context.Context, db gdb.DB, req imInviteListRequest, limit, offset int) ([]imInviteCodeResponse, int, error) {
+	now := time.Now().UTC().Round(time.Millisecond)
+	expireWhere := "status='active' AND expires_at<=?"
+	expireArgs := []any{now, now}
+	if req.TenantID > 0 {
+		expireWhere = "tenant_id=? AND " + expireWhere
+		expireArgs = []any{now, req.TenantID, now}
+	}
+	if _, err := db.Exec(ctx, `UPDATE im_registration_invite_codes SET status='expired',updated_at=? WHERE `+expireWhere, expireArgs...); err != nil {
+		return nil, 0, err
+	}
+	where, args := inviteWhere(req)
+	totalValue, err := db.GetValue(ctx, "SELECT COUNT(*) FROM im_registration_invite_codes c WHERE "+where, args...)
+	if err != nil {
+		return nil, 0, err
+	}
+	queryArgs := append(append([]any{}, args...), limit, offset)
+	items := make([]imInviteCodeResponse, 0)
+	err = db.Raw(`SELECT c.id,c.tenant_id,t.name tenant_name,c.batch_id,c.code,c.status,c.expires_at,c.max_uses,c.bound_user_id,c.bound_user_label,c.created_by,c.remark,c.created_at,
+		c.usage_count,c.last_used_at
+		FROM im_registration_invite_codes c
+		LEFT JOIN im_tenant t ON t.id=c.tenant_id
+		WHERE `+where+` ORDER BY c.created_at DESC,c.id DESC LIMIT ? OFFSET ?`, queryArgs...).Ctx(ctx).Scan(&items)
+	return items, totalValue.Int(), err
+}
+
+func inviteWhere(req imInviteListRequest) (string, []any) {
+	where := []string{"1=1"}
+	args := make([]any, 0, 8)
+	if req.TenantID > 0 {
+		where, args = append(where, "c.tenant_id=?"), append(args, req.TenantID)
+	}
+	if req.InviteCode != "" {
+		where, args = append(where, "c.code=?"), append(args, req.InviteCode)
+	}
+	if req.Status != "" {
+		where, args = append(where, "c.status=?"), append(args, req.Status)
+	}
+	if req.BatchID > 0 {
+		where, args = append(where, "c.batch_id=?"), append(args, req.BatchID)
+	}
+	if req.CreatedBy > 0 {
+		where, args = append(where, "c.created_by=?"), append(args, req.CreatedBy)
+	}
+	if req.CreatedAtStart != nil {
+		where, args = append(where, "c.created_at>=?"), append(args, *req.CreatedAtStart)
+	}
+	if req.CreatedAtEnd != nil {
+		where, args = append(where, "c.created_at<=?"), append(args, *req.CreatedAtEnd)
+	}
+	if req.ExpiresAtStart != nil {
+		where, args = append(where, "c.expires_at>=?"), append(args, *req.ExpiresAtStart)
+	}
+	if req.ExpiresAtEnd != nil {
+		where, args = append(where, "c.expires_at<=?"), append(args, *req.ExpiresAtEnd)
+	}
+	return strings.Join(where, " AND "), args
+}
+
+func getInviteBatch(ctx context.Context, db gdb.DB, tenantID int64, where string, arg any) (*imInviteBatchResponse, error) {
+	items := make([]imInviteBatchResponse, 0, 1)
+	now := time.Now().UTC().Round(time.Millisecond)
+	err := db.Raw(`SELECT b.id batch_id,b.tenant_id,b.quantity,b.idempotency_key,b.expires_at,b.remark,b.created_at,
+		COALESCE(SUM(CASE WHEN c.status='active' AND c.expires_at>? THEN 1 ELSE 0 END),0) active_count,
+		COALESCE(SUM(c.usage_count),0) usage_count,
+		COALESCE(SUM(CASE WHEN (c.status='active' AND c.expires_at<=?) OR c.status='expired' THEN 1 ELSE 0 END),0) expired_count,
+		COALESCE(SUM(CASE WHEN c.status='revoked' THEN 1 ELSE 0 END),0) revoked_count
+		FROM im_registration_invite_batches b LEFT JOIN im_registration_invite_codes c ON c.tenant_id=b.tenant_id AND c.batch_id=b.id
+		WHERE b.tenant_id=? AND `+where+` GROUP BY b.id LIMIT 1`, now, now, tenantID, arg).Ctx(ctx).Scan(&items)
+	if err != nil {
+		return nil, err
+	}
+	if len(items) == 0 {
+		return nil, gerror.Wrap(errInviteBatchNotFound, "邀请码批次不存在")
+	}
+	return &items[0], nil
 }
 
 func buildInviteListRequest(in *sysin.ImInviteListInp) (imInviteListRequest, error) {
-	batchId, err := sysin.ParseOptionalInt64(in.BatchId)
+	batchID, err := sysin.ParseOptionalInt64(in.BatchId)
 	if err != nil {
 		return imInviteListRequest{}, err
 	}
@@ -250,32 +515,120 @@ func buildInviteListRequest(in *sysin.ImInviteListInp) (imInviteListRequest, err
 	if err != nil {
 		return imInviteListRequest{}, err
 	}
-	return imInviteListRequest{
-		Page:           in.Page,
-		PerPage:        in.PerPage,
-		InviteCode:     in.InviteCode,
-		Status:         in.Status,
-		BatchID:        batchId,
-		CreatedBy:      createdBy,
-		CreatedAtStart: formatRFC3339(in.CreatedAtStart),
-		CreatedAtEnd:   formatRFC3339(in.CreatedAtEnd),
-		ExpiresAtStart: formatRFC3339(in.ExpiresAtStart),
-		ExpiresAtEnd:   formatRFC3339(in.ExpiresAtEnd),
-	}, nil
+	return imInviteListRequest{InviteCode: in.InviteCode, Status: in.Status, BatchID: batchID, CreatedBy: createdBy,
+		CreatedAtStart: nativeTime(in.CreatedAtStart), CreatedAtEnd: nativeTime(in.CreatedAtEnd),
+		ExpiresAtStart: nativeTime(in.ExpiresAtStart), ExpiresAtEnd: nativeTime(in.ExpiresAtEnd)}, nil
 }
 
-func formatRFC3339(t *gtime.Time) string {
-	if t == nil {
-		return ""
+func randomInviteCode() (string, error) {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+	result := make([]byte, 5)
+	buffer := make([]byte, 10)
+	for index := 0; index < len(result); {
+		if _, err := cryptorand.Read(buffer); err != nil {
+			return "", err
+		}
+		for _, value := range buffer {
+			if value >= 208 {
+				continue
+			}
+			result[index] = alphabet[int(value)%len(alphabet)]
+			index++
+			if index == len(result) {
+				break
+			}
+		}
 	}
-	return t.Time.UTC().Format(time.RFC3339)
+	return string(result), nil
 }
 
-func convertTime(t *time.Time) *gtime.Time {
-	if t == nil {
+func isDuplicateError(err error) bool {
+	var mysqlErr *mysqldriver.MySQLError
+	return errors.As(err, &mysqlErr) && mysqlErr.Number == 1062
+}
+
+func validInviteStatus(status string) bool {
+	return status == "" || status == "active" || status == "expired" || status == "revoked"
+}
+
+func sameInviteBatch(batch *imInviteBatchResponse, quantity int, expiresAt time.Time, remark string) bool {
+	return batch != nil && batch.Quantity == quantity &&
+		batch.ExpiresAt.UTC().Round(time.Millisecond).Equal(expiresAt.UTC().Round(time.Millisecond)) && batch.Remark == remark
+}
+
+func convertInviteCodes(items []imInviteCodeResponse) []*sysin.ImInviteCodeModel {
+	list := make([]*sysin.ImInviteCodeModel, 0, len(items))
+	for _, item := range items {
+		list = append(list, convertInviteCode(item))
+	}
+	return list
+}
+
+func convertInviteCode(item imInviteCodeResponse) *sysin.ImInviteCodeModel {
+	return &sysin.ImInviteCodeModel{Id: strconv.FormatInt(item.ID, 10), BatchId: formatOptionalInt64(item.BatchID), Code: item.Code,
+		TenantId: strconv.FormatInt(item.TenantID, 10), TenantName: item.TenantName,
+		Status: item.Status, ExpiresAt: gtime.New(item.ExpiresAt), MaxUses: item.MaxUses, UsageCount: item.UsageCount,
+		BoundUserId: formatOptionalInt64(item.BoundUserID), BoundUserLabel: item.BoundUserLabel, LastUsedAt: convertTime(item.LastUsedAt),
+		CreatedBy: strconv.FormatInt(item.CreatedBy, 10), Remark: item.Remark, CreatedAt: gtime.New(item.CreatedAt)}
+}
+
+func inviteBoundUserLabel(ctx context.Context, tenant *entity.ImTenant, userID int64) (string, error) {
+	if tenant == nil || tenant.Code == "" || userID <= 0 {
+		return "", gerror.New("绑定用户不合法")
+	}
+	values := addPageQuery(url.Values{}, 1, 1)
+	values.Set("user_ids", strconv.FormatInt(userID, 10))
+	users, _, err := imAdminQueryList[sysin.ImUserListModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/users",
+		values,
+		map[string]string{
+			"public":  "profileJson",
+			"trusted": "trustedJson",
+			"access":  "accessJson",
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+	if len(users) == 0 {
+		return "", gerror.New("绑定用户不存在")
+	}
+	user := users[0]
+	if user.Nickname != "" {
+		return fmt.Sprintf("%s（%s）", user.Nickname, user.UserId), nil
+	}
+	if user.Username != "" {
+		return fmt.Sprintf("%s（%s）", user.Username, user.UserId), nil
+	}
+	if user.Phone != "" {
+		return fmt.Sprintf("%s（%s）", user.Phone, user.UserId), nil
+	}
+	return user.UserId, nil
+}
+
+func convertInviteBatch(item *imInviteBatchResponse) *sysin.ImInviteBatchModel {
+	if item == nil {
 		return nil
 	}
-	return gtime.New(t)
+	return &sysin.ImInviteBatchModel{BatchId: strconv.FormatInt(item.BatchID, 10), Quantity: item.Quantity, ActiveCount: item.ActiveCount,
+		TenantId:   strconv.FormatInt(item.TenantID, 10),
+		UsageCount: item.UsageCount, RevokedCount: item.RevokedCount, ExpiredCount: item.ExpiredCount,
+		ExpiresAt: gtime.New(item.ExpiresAt), CreatedAt: gtime.New(item.CreatedAt)}
+}
+
+func nativeTime(value *gtime.Time) *time.Time {
+	if value == nil {
+		return nil
+	}
+	t := value.Time.UTC()
+	return &t
+}
+
+func convertTime(value *time.Time) *gtime.Time {
+	if value == nil {
+		return nil
+	}
+	return gtime.New(value)
 }
 
 func formatOptionalInt64(value *int64) string {
@@ -285,31 +638,27 @@ func formatOptionalInt64(value *int64) string {
 	return strconv.FormatInt(*value, 10)
 }
 
-func convertInviteCode(item imInviteCodeResponse) *sysin.ImInviteCodeModel {
-	return &sysin.ImInviteCodeModel{
-		Id:        strconv.FormatInt(item.ID, 10),
-		BatchId:   formatOptionalInt64(item.BatchID),
-		Code:      item.Code,
-		Status:    item.Status,
-		ExpiresAt: convertTime(item.ExpiresAt),
-		UsedBy:    formatOptionalInt64(item.UsedBy),
-		UsedAt:    convertTime(item.UsedAt),
-		RequestId: item.RequestID,
-		CreatedBy: strconv.FormatInt(item.CreatedBy, 10),
-		Remark:    item.Remark,
-		CreatedAt: convertTime(item.CreatedAt),
+func formatTime(value *time.Time) string {
+	if value == nil {
+		return ""
 	}
+	return value.Format(time.RFC3339)
 }
 
-func convertInviteBatch(item imInviteBatchResponse) *sysin.ImInviteBatchModel {
-	return &sysin.ImInviteBatchModel{
-		BatchId:      strconv.FormatInt(item.BatchID, 10),
-		Quantity:     item.Quantity,
-		ActiveCount:  item.ActiveCount,
-		UsedCount:    item.UsedCount,
-		RevokedCount: item.RevokedCount,
-		ExpiredCount: item.ExpiredCount,
-		ExpiresAt:    convertTime(item.ExpiresAt),
-		CreatedAt:    convertTime(item.CreatedAt),
+func formatInviteAvailableUses(maxUses, usageCount int) string {
+	if maxUses <= 0 {
+		return "不限制"
 	}
+	available := maxUses - usageCount
+	if available < 0 {
+		available = 0
+	}
+	return strconv.Itoa(available)
+}
+
+func batchID(batch *imInviteBatchResponse) int64 {
+	if batch == nil {
+		return 0
+	}
+	return batch.BatchID
 }

server/internal/logic/sys/im_kafka_audit.go

@@ -2,11 +2,12 @@ package sys
 
 import (
 	"context"
+	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
+	"strings"
 
 	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/frame/g"
 )
 
 type sSysImKafkaAudit struct{}
@@ -23,64 +24,118 @@ func (s *sSysImKafkaAudit) List(ctx context.Context, in *sysin.ImKafkaAuditListI
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	mod := g.DB().Model("im_audit_events").Safe().Ctx(ctx).
-		Fields("id", "event_id", "tenant_code", "event_type", "biz_type", "biz_id", "actor_type", "actor_id", "action", "resource", "resource_id", "result", "reason", "occurred_at", "received_at")
-	if in.TenantCode != "" {
-		mod = mod.Where("tenant_code", in.TenantCode)
+	where, args := buildImKafkaAuditWhere(in)
+	db := imtenant.RegistryDB()
+	totalValue, err := db.GetValue(ctx, "SELECT COUNT(*) FROM im_audit_events "+where, args...)
+	if err != nil {
+		err = gerror.Wrap(err, "获取IM Kafka审计事件总数失败，请稍后重试！")
+		return
 	}
-	if in.EventId != "" {
-		mod = mod.WhereLike("event_id", "%"+in.EventId+"%")
+	totalCount = totalValue.Int()
+
+	page := in.Page
+	if page <= 0 {
+		page = 1
 	}
-	if in.EventType != "" {
-		mod = mod.WhereLike("event_type", "%"+in.EventType+"%")
+	perPage := in.PerPage
+	if perPage <= 0 {
+		perPage = 20
 	}
-	if in.BizType != "" {
-		mod = mod.Where("biz_type", in.BizType)
-	}
-	if in.BizId != "" {
-		mod = mod.WhereLike("biz_id", "%"+in.BizId+"%")
-	}
-	if in.ActorType != "" {
-		mod = mod.Where("actor_type", in.ActorType)
-	}
-	if in.ActorId != "" {
-		mod = mod.WhereLike("actor_id", "%"+in.ActorId+"%")
-	}
-	if in.Action != "" {
-		mod = mod.WhereLike("action", "%"+in.Action+"%")
-	}
-	if in.Resource != "" {
-		mod = mod.Where("resource", in.Resource)
-	}
-	if in.ResourceId != "" {
-		mod = mod.WhereLike("resource_id", "%"+in.ResourceId+"%")
-	}
-	if in.Result != "" {
-		mod = mod.Where("result", in.Result)
-	}
-	if len(in.CreatedAt) == 2 {
-		mod = mod.WhereBetween("received_at", in.CreatedAt[0], in.CreatedAt[1])
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+	offset := (page - 1) * perPage
+	query := `SELECT id,event_id,tenant_code,event_type,biz_type,biz_id,actor_type,actor_id,
+		action,resource,resource_id,result,reason,occurred_at,received_at
+		FROM im_audit_events ` + where + ` ORDER BY id DESC LIMIT ? OFFSET ?`
+	queryArgs := append(append([]any{}, args...), perPage, offset)
+	rows, err := db.GetAll(ctx, query, queryArgs...)
+	if err != nil {
 		err = gerror.Wrap(err, "获取IM Kafka审计事件列表失败，请稍后重试！")
+		return
+	}
+	if err = rows.Structs(&list); err != nil {
+		err = gerror.Wrap(err, "解析IM Kafka审计事件列表失败，请稍后重试！")
 	}
 	return
 }
 
+func buildImKafkaAuditWhere(in *sysin.ImKafkaAuditListInp) (string, []any) {
+	parts := []string{"1=1"}
+	args := []any{}
+	if in.TenantCode != "" {
+		parts = append(parts, "tenant_code=?")
+		args = append(args, in.TenantCode)
+	}
+	if in.EventId != "" {
+		parts = append(parts, "event_id LIKE ?")
+		args = append(args, "%"+in.EventId+"%")
+	}
+	if in.EventType != "" {
+		parts = append(parts, "event_type LIKE ?")
+		args = append(args, "%"+in.EventType+"%")
+	}
+	if in.BizType != "" {
+		parts = append(parts, "biz_type=?")
+		args = append(args, in.BizType)
+	}
+	if in.BizId != "" {
+		parts = append(parts, "biz_id LIKE ?")
+		args = append(args, "%"+in.BizId+"%")
+	}
+	if in.ActorType != "" {
+		parts = append(parts, "actor_type=?")
+		args = append(args, in.ActorType)
+	}
+	if in.ActorId != "" {
+		parts = append(parts, "actor_id LIKE ?")
+		args = append(args, "%"+in.ActorId+"%")
+	}
+	if in.Action != "" {
+		parts = append(parts, "action LIKE ?")
+		args = append(args, "%"+in.Action+"%")
+	}
+	if in.Resource != "" {
+		parts = append(parts, "resource=?")
+		args = append(args, in.Resource)
+	}
+	if in.ResourceId != "" {
+		parts = append(parts, "resource_id LIKE ?")
+		args = append(args, "%"+in.ResourceId+"%")
+	}
+	if in.Result != "" {
+		parts = append(parts, "result=?")
+		args = append(args, in.Result)
+	}
+	if len(in.CreatedAt) == 2 {
+		parts = append(parts, "received_at BETWEEN ? AND ?")
+		args = append(args, in.CreatedAt[0], in.CreatedAt[1])
+	}
+	return "WHERE " + strings.Join(parts, " AND "), args
+}
+
 func (s *sSysImKafkaAudit) View(ctx context.Context, in *sysin.ImKafkaAuditViewInp) (res *sysin.ImKafkaAuditViewModel, err error) {
 	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	mod := g.DB().Model("im_audit_events").Safe().Ctx(ctx).
-		Fields("id", "event_id", "tenant_code", "event_type", "biz_type", "biz_id", "actor_type", "actor_id", "action", "resource", "resource_id", "result", "reason", "CAST(payload AS CHAR) payload", "CAST(envelope AS CHAR) envelope", "occurred_at", "received_at")
+	query := `SELECT id,event_id,tenant_code,event_type,biz_type,biz_id,actor_type,actor_id,
+		action,resource,resource_id,result,reason,CAST(payload AS CHAR) payload,
+		CAST(envelope AS CHAR) envelope,occurred_at,received_at FROM im_audit_events WHERE `
+	args := []any{}
 	if in.Id > 0 {
-		mod = mod.Where("id", in.Id)
+		query += "id=?"
+		args = append(args, in.Id)
 	} else {
-		mod = mod.Where("event_id", in.EventId)
+		query += "event_id=?"
+		args = append(args, in.EventId)
 	}
-	if err = mod.Scan(&res); err != nil {
+	query += " LIMIT 1"
+	row, err := imtenant.RegistryDB().GetOne(ctx, query, args...)
+	if err != nil {
 		return nil, gerror.Wrap(err, "获取IM Kafka审计事件详情失败，请稍后重试！")
 	}
+	if row.IsEmpty() {
+		return nil, nil
+	}
+	if err = row.Struct(&res); err != nil {
+		return nil, gerror.Wrap(err, "解析IM Kafka审计事件详情失败，请稍后重试！")
+	}
 	return
 }

server/internal/logic/sys/im_kafka_command.go

@@ -10,11 +10,12 @@ import (
 	"hotgo/internal/consts"
 	"hotgo/internal/library/contexts"
 	"hotgo/internal/library/imkafka"
+	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
+	"strings"
 
 	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
@@ -32,53 +33,34 @@ func (s *sSysImKafkaCommand) List(ctx context.Context, in *sysin.ImKafkaCommandL
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	mod := g.DB().Model("im_admin_commands").Safe().Ctx(ctx).
-		Fields(
-			"id",
-			"command_id",
-			"tenant_id",
-			"tenant_code",
-			"event_id",
-			"event_type",
-			"biz_type",
-			"biz_id",
-			"idempotency_key",
-			"status",
-			"reason",
-			"message",
-			"sent_at",
-			"completed_at",
-			"created_by",
-			"created_at",
-			"updated_at",
-		)
-	if in.TenantId > 0 {
-		mod = mod.Where("tenant_id", in.TenantId)
+	where, args := buildImKafkaCommandWhere(in)
+	db := imtenant.RegistryDB()
+	totalValue, err := db.GetValue(ctx, "SELECT COUNT(*) FROM im_admin_commands "+where, args...)
+	if err != nil {
+		err = gerror.Wrap(err, "获取IM后台命令总数失败，请稍后重试！")
+		return
 	}
-	if in.CommandId != "" {
-		mod = mod.WhereLike("command_id", "%"+in.CommandId+"%")
+	totalCount = totalValue.Int()
+	page := in.Page
+	if page <= 0 {
+		page = 1
 	}
-	if in.EventId != "" {
-		mod = mod.WhereLike("event_id", "%"+in.EventId+"%")
+	perPage := in.PerPage
+	if perPage <= 0 {
+		perPage = 20
 	}
-	if in.EventType != "" {
-		mod = mod.WhereLike("event_type", "%"+in.EventType+"%")
-	}
-	if in.BizType != "" {
-		mod = mod.Where("biz_type", in.BizType)
-	}
-	if in.BizId != "" {
-		mod = mod.WhereLike("biz_id", "%"+in.BizId+"%")
-	}
-	if in.Status != "" {
-		mod = mod.Where("status", in.Status)
-	}
-	if len(in.CreatedAt) == 2 {
-		mod = mod.WhereBetween("created_at", in.CreatedAt[0], in.CreatedAt[1])
-	}
-	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
-	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+	offset := (page - 1) * perPage
+	query := `SELECT id,command_id,tenant_id,tenant_code,event_id,event_type,biz_type,biz_id,idempotency_key,
+		status,reason,message,sent_at,completed_at,created_by,created_at,updated_at
+		FROM im_admin_commands ` + where + ` ORDER BY id DESC LIMIT ? OFFSET ?`
+	queryArgs := append(append([]any{}, args...), perPage, offset)
+	rows, err := db.GetAll(ctx, query, queryArgs...)
+	if err != nil {
 		err = gerror.Wrap(err, "获取IM后台命令列表失败，请稍后重试！")
+		return
+	}
+	if err = rows.Structs(&list); err != nil {
+		err = gerror.Wrap(err, "解析IM后台命令列表失败，请稍后重试！")
 	}
 	return
 }
@@ -87,40 +69,69 @@ func (s *sSysImKafkaCommand) View(ctx context.Context, in *sysin.ImKafkaCommandV
 	if err = in.Filter(ctx); err != nil {
 		return nil, err
 	}
-	mod := g.DB().Model("im_admin_commands").Safe().Ctx(ctx).
-		Fields(
-			"id",
-			"command_id",
-			"tenant_id",
-			"tenant_code",
-			"event_id",
-			"event_type",
-			"biz_type",
-			"biz_id",
-			"idempotency_key",
-			"status",
-			"reason",
-			"message",
-			"CAST(payload AS CHAR) payload",
-			"CAST(envelope AS CHAR) envelope",
-			"CAST(result AS CHAR) result",
-			"sent_at",
-			"completed_at",
-			"created_by",
-			"created_at",
-			"updated_at",
-		)
+	query := `SELECT id,command_id,tenant_id,tenant_code,event_id,event_type,biz_type,biz_id,idempotency_key,
+		status,reason,message,CAST(payload AS CHAR) payload,CAST(envelope AS CHAR) envelope,CAST(result AS CHAR) result,
+		sent_at,completed_at,created_by,created_at,updated_at FROM im_admin_commands WHERE `
+	args := []any{}
 	if in.Id > 0 {
-		mod = mod.Where("id", in.Id)
+		query += "id=?"
+		args = append(args, in.Id)
 	} else {
-		mod = mod.Where("command_id", in.CommandId)
+		query += "command_id=?"
+		args = append(args, in.CommandId)
 	}
-	if err = mod.Scan(&res); err != nil {
+	query += " LIMIT 1"
+	row, err := imtenant.RegistryDB().GetOne(ctx, query, args...)
+	if err != nil {
 		return nil, gerror.Wrap(err, "获取IM后台命令详情失败，请稍后重试！")
 	}
+	if row.IsEmpty() {
+		return nil, nil
+	}
+	if err = row.Struct(&res); err != nil {
+		return nil, gerror.Wrap(err, "解析IM后台命令详情失败，请稍后重试！")
+	}
 	return
 }
 
+func buildImKafkaCommandWhere(in *sysin.ImKafkaCommandListInp) (string, []any) {
+	parts := []string{"1=1"}
+	args := []any{}
+	if in.TenantId > 0 {
+		parts = append(parts, "tenant_id=?")
+		args = append(args, in.TenantId)
+	}
+	if in.CommandId != "" {
+		parts = append(parts, "command_id LIKE ?")
+		args = append(args, "%"+in.CommandId+"%")
+	}
+	if in.EventId != "" {
+		parts = append(parts, "event_id LIKE ?")
+		args = append(args, "%"+in.EventId+"%")
+	}
+	if in.EventType != "" {
+		parts = append(parts, "event_type LIKE ?")
+		args = append(args, "%"+in.EventType+"%")
+	}
+	if in.BizType != "" {
+		parts = append(parts, "biz_type=?")
+		args = append(args, in.BizType)
+	}
+	if in.BizId != "" {
+		parts = append(parts, "biz_id LIKE ?")
+		args = append(args, "%"+in.BizId+"%")
+	}
+	if in.Status != "" {
+		parts = append(parts, "status=?")
+		args = append(args, in.Status)
+	}
+	if len(in.CreatedAt) == 2 {
+		parts = append(parts, "created_at BETWEEN ? AND ?")
+		args = append(args, in.CreatedAt[0], in.CreatedAt[1])
+	}
+	return "WHERE " + strings.Join(parts, " AND "), args
+}
+
 func (s *sSysImKafkaCommand) CacheInvalidate(ctx context.Context, in *sysin.ImKafkaCacheInvalidateInp) (res *sysin.ImKafkaEventModel, err error) {
 	if err = in.Filter(ctx); err != nil {
 		return nil, err

server/internal/logic/sys/im_login_audit.go

@@ -0,0 +1,155 @@
+package sys
+
+import (
+	"context"
+	"fmt"
+	"hotgo/internal/consts"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imkafka"
+	"hotgo/internal/model/input/form"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+	"hotgo/utility/convert"
+	"hotgo/utility/excel"
+	"net/url"
+	"strconv"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+type sSysImUserLoginHistory struct{}
+type sSysImLoginFailureLog struct{}
+
+func NewSysImUserLoginHistory() *sSysImUserLoginHistory { return &sSysImUserLoginHistory{} }
+func NewSysImLoginFailureLog() *sSysImLoginFailureLog   { return &sSysImLoginFailureLog{} }
+
+func init() {
+	service.RegisterSysImUserLoginHistory(NewSysImUserLoginHistory())
+	service.RegisterSysImLoginFailureLog(NewSysImLoginFailureLog())
+}
+
+func (s *sSysImUserLoginHistory) List(ctx context.Context, in *sysin.ImUserLoginHistoryListInp) ([]*sysin.ImUserLoginHistoryModel, int, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, 0, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, 0, err
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	setQuery(values, "user_id", in.UserId)
+	setQuery(values, "account", in.Account)
+	setQuery(values, "login_type", in.LoginType)
+	setQuery(values, "event_type", in.EventType)
+	setQuery(values, "platform", in.Platform)
+	setQuery(values, "ip", in.Ip)
+	addTimeRangeQuery(values, "login_at", in.LoginAt)
+	return imAdminQueryList[sysin.ImUserLoginHistoryModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/user-login-logs", values, nil)
+}
+
+func (s *sSysImUserLoginHistory) Export(ctx context.Context, in *sysin.ImUserLoginHistoryListInp) error {
+	list, total, err := s.List(ctx, in)
+	if err != nil {
+		return err
+	}
+	exports := make([]sysin.ImLoginAuditExportModel, 0, len(list))
+	for _, item := range list {
+		exports = append(exports, sysin.ImLoginAuditExportModel{Id: item.Id, UserId: item.UserId, AccountMask: item.AccountMask, EventType: item.EventType, Platform: item.Platform, Ip: item.Ip, Region: item.Region, RiskLevel: item.RiskLevel, OccurredAt: item.LoginAt})
+	}
+	return exportLoginAudit(ctx, exports, total, in.Page, in.PerPage, "用户登录历史")
+}
+
+func (s *sSysImLoginFailureLog) List(ctx context.Context, in *sysin.ImLoginFailureLogListInp) ([]*sysin.ImLoginFailureLogModel, int, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, 0, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, 0, err
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	setQuery(values, "user_id", in.UserId)
+	setQuery(values, "account", in.Account)
+	setQuery(values, "failure_type", in.FailureType)
+	setQuery(values, "platform", in.Platform)
+	setQuery(values, "ip", in.Ip)
+	addTimeRangeQuery(values, "attempt_at", in.AttemptAt)
+	return imAdminQueryList[sysin.ImLoginFailureLogModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/login-failure-logs", values, nil)
+}
+
+func (s *sSysImLoginFailureLog) View(ctx context.Context, in *sysin.ImLoginFailureViewInp) (*sysin.ImLoginFailureLogModel, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	return imAdminQueryOne[sysin.ImLoginFailureLogModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/login-failure-logs/"+strconv.FormatInt(in.Id, 10), nil)
+}
+
+func (s *sSysImLoginFailureLog) Export(ctx context.Context, in *sysin.ImLoginFailureLogListInp) error {
+	list, total, err := s.List(ctx, in)
+	if err != nil {
+		return err
+	}
+	exports := make([]sysin.ImLoginAuditExportModel, 0, len(list))
+	for _, item := range list {
+		exports = append(exports, sysin.ImLoginAuditExportModel{Id: item.Id, UserId: item.UserId, AccountMask: item.AccountMask, EventType: item.FailureType, Platform: item.Platform, Ip: item.Ip, Region: item.Region, RiskLevel: item.RiskLevel, Reason: item.Reason, OccurredAt: item.AttemptAt})
+	}
+	return exportLoginAudit(ctx, exports, total, in.Page, in.PerPage, "登录失败日志")
+}
+
+func exportLoginAudit(ctx context.Context, exports []sysin.ImLoginAuditExportModel, total int, page int, perPage int, label string) error {
+	tags, err := convert.GetEntityDescTags(sysin.ImLoginAuditExportModel{})
+	if err != nil {
+		return err
+	}
+	fileName := "导出" + label + "-" + gctx.CtxId(ctx)
+	sheetName := fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", total, form.CalPageCount(total, perPage), page, len(exports))
+	return excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
+}
+
+func (s *sSysImLoginFailureLog) AddBlacklist(ctx context.Context, in *sysin.ImLoginFailureAddBlacklistInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	remark := in.Remark
+	if remark == "" {
+		remark = "由登录失败日志加入"
+	}
+	return service.SysImSecurityPolicy().IPRuleEdit(ctx, &sysin.ImSecurityIPRuleEditInp{
+		TenantId: in.TenantId, RuleType: "blacklist", IpCidr: in.Ip, Action: "deny",
+		SceneJson: gjson.New([]string{"login"}), RiskLevel: "high", Status: consts.StatusEnabled, Remark: remark,
+	})
+}
+
+func (s *sSysImLoginFailureLog) BanUser(ctx context.Context, in *sysin.ImLoginFailureBanUserInp) (*sysin.ImUserCommandModel, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	user := contexts.GetUser(ctx)
+	actorName := ""
+	if user != nil {
+		actorName = user.RealName
+	}
+	command, err := imkafka.PublishAdminCommand(ctx, imkafka.AdminCommandInput{
+		TenantID: tenant.Id, TenantCode: tenant.Code, EventType: consts.ImAdminCommandUserBan,
+		BizType: "user", BizID: strconv.FormatInt(in.UserId, 10),
+		Actor:     &imkafka.Actor{Type: "admin", ID: strconv.FormatInt(contexts.GetUserId(ctx), 10), DisplayName: actorName},
+		Payload:   map[string]any{"user_id": strconv.FormatInt(in.UserId, 10), "target_user_id": strconv.FormatInt(in.UserId, 10), "reason": in.Reason},
+		CreatedBy: contexts.GetUserId(ctx),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &sysin.ImUserCommandModel{CommandID: command.CommandID, EventID: command.EventID, Status: command.Status, TenantID: command.TenantID, TenantCode: command.TenantCode, EventType: command.EventType, IdempotencyKey: command.IdempotencyKey}, nil
+}

server/internal/logic/sys/im_mailbox_config.go

@@ -0,0 +1,121 @@
+package sys
+
+import (
+	"context"
+	"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"
+)
+
+const imMailboxConfigTable = "im_mailbox_config"
+
+type sSysImMailboxConfig struct{}
+
+func NewSysImMailboxConfig() *sSysImMailboxConfig { return &sSysImMailboxConfig{} }
+
+func init() {
+	service.RegisterSysImMailboxConfig(NewSysImMailboxConfig())
+}
+
+func (s *sSysImMailboxConfig) Get(ctx context.Context, in *sysin.ImMailboxConfigGetInp) (res *sysin.ImMailboxConfigModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = s.ensureDefault(ctx, db); err != nil {
+		return nil, err
+	}
+	if err = s.model(ctx, db).Where("id", 1).Scan(&res); err != nil {
+		return nil, gerror.Wrap(err, "获取IM总经理信箱配置失败，请稍后重试！")
+	}
+	if res != nil {
+		res.TenantId = tenant.Id
+		res.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImMailboxConfig) Update(ctx context.Context, in *sysin.ImMailboxConfigUpdateInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = s.ensureDefault(ctx, db); err != nil {
+		return err
+	}
+	requiredFields := `["subject","content"]`
+	if in.RequiredFields != nil && in.RequiredFields.String() != "" && in.RequiredFields.String() != "null" {
+		requiredFields = in.RequiredFields.String()
+	}
+	attachmentPolicy := `{"max_files":5,"purpose":"executive_mailbox"}`
+	if in.AttachmentPolicy != nil && in.AttachmentPolicy.String() != "" && in.AttachmentPolicy.String() != "null" {
+		attachmentPolicy = in.AttachmentPolicy.String()
+	}
+	if _, err = db.Model(imMailboxConfigTable).Safe().Ctx(ctx).Where("id", 1).Data(g.Map{
+		"enabled":           in.Enabled,
+		"allow_anonymous":   in.AllowAnonymous,
+		"required_fields":   requiredFields,
+		"max_length":        in.MaxLength,
+		"attachment_policy": attachmentPolicy,
+		"notice_title":      in.NoticeTitle,
+		"notice_content":    in.NoticeContent,
+		"notice_updated_at": gtime.Now(),
+		"updated_at":        gtime.Now(),
+	}).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM总经理信箱配置失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_mailbox_config_update", "im_mailbox_config", 1, "success", g.Map{"enabled": in.Enabled})
+	return nil
+}
+
+func (s *sSysImMailboxConfig) model(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model(imMailboxConfigTable).Safe().Ctx(ctx).Fields(
+		"id",
+		"enabled",
+		"allow_anonymous",
+		"CAST(required_fields AS CHAR) required_fields",
+		"max_length",
+		"CAST(attachment_policy AS CHAR) attachment_policy",
+		"notice_title",
+		"notice_content",
+		"notice_updated_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImMailboxConfig) ensureDefault(ctx context.Context, db gdb.DB) (err error) {
+	var count int
+	if count, err = db.Model(imMailboxConfigTable).Safe().Ctx(ctx).Where("id", 1).Count(); err != nil {
+		return gerror.Wrap(err, "检查IM总经理信箱默认配置失败，请稍后重试！")
+	}
+	if count > 0 {
+		return nil
+	}
+	_, err = db.Model(imMailboxConfigTable).Safe().Ctx(ctx).Data(g.Map{
+		"id":                1,
+		"enabled":           1,
+		"allow_anonymous":   1,
+		"required_fields":   `["subject","content"]`,
+		"max_length":        5000,
+		"attachment_policy": `{"max_files":5,"purpose":"executive_mailbox"}`,
+		"notice_title":      "总经理信箱",
+		"notice_content":    "请如实填写诉求，匿名提交将按企业政策保护展示身份。",
+		"notice_updated_at": gtime.Now(),
+		"created_at":        gtime.Now(),
+		"updated_at":        gtime.Now(),
+	}).Insert()
+	if err != nil {
+		return gerror.Wrap(err, "初始化IM总经理信箱默认配置失败，请稍后重试！")
+	}
+	return nil
+}

server/internal/logic/sys/im_message_admin.go

@@ -0,0 +1,179 @@
+package sys
+
+import (
+	"context"
+	"fmt"
+	"hotgo/internal/consts"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imkafka"
+	"hotgo/internal/model/input/form"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+	"hotgo/utility/convert"
+	"hotgo/utility/excel"
+	"net/url"
+	"strconv"
+
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+type sSysImPrivateMessage struct{}
+type sSysImGroupMessage struct{}
+
+func NewSysImPrivateMessage() *sSysImPrivateMessage { return &sSysImPrivateMessage{} }
+func NewSysImGroupMessage() *sSysImGroupMessage     { return &sSysImGroupMessage{} }
+
+func init() {
+	service.RegisterSysImPrivateMessage(NewSysImPrivateMessage())
+	service.RegisterSysImGroupMessage(NewSysImGroupMessage())
+}
+
+func (s *sSysImPrivateMessage) List(ctx context.Context, in *sysin.ImPrivateMessageListInp) ([]*sysin.ImMessageListModel, int, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, 0, err
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	setQuery(values, "topic", in.Topic)
+	setQuery(values, "from_user_id", in.FromUserId)
+	setQuery(values, "to_user_id", in.ToUserId)
+	setQuery(values, "content_type", in.ContentType)
+	setQuery(values, "status", in.Status)
+	setQuery(values, "keyword", in.Keyword)
+	addTimeRangeQuery(values, "created_at", in.CreatedAt)
+	return queryImMessages(ctx, in.TenantId, "private-messages", values)
+}
+
+func (s *sSysImGroupMessage) List(ctx context.Context, in *sysin.ImGroupMessageListInp) ([]*sysin.ImMessageListModel, int, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, 0, err
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	setQuery(values, "topic", in.Topic)
+	if in.SeqId > 0 {
+		values.Set("seq_id", strconv.FormatInt(in.SeqId, 10))
+	}
+	setQuery(values, "sender_user_id", in.SenderUserId)
+	setQuery(values, "sender_username", in.SenderUsername)
+	setQuery(values, "sender_nickname", in.SenderNickname)
+	setQuery(values, "group_name", in.GroupName)
+	setQuery(values, "content_type", in.ContentType)
+	setQuery(values, "status", in.Status)
+	setQuery(values, "keyword", in.Keyword)
+	addTimeRangeQuery(values, "created_at", in.CreatedAt)
+	return queryImMessages(ctx, in.TenantId, "group-messages", values)
+}
+
+func queryImMessages(ctx context.Context, tenantId int64, resource string, values url.Values) ([]*sysin.ImMessageListModel, int, error) {
+	tenant, err := resolveImAdminTenant(ctx, tenantId)
+	if err != nil {
+		return nil, 0, err
+	}
+	return imAdminQueryList[sysin.ImMessageListModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/"+resource, values,
+		map[string]string{"sender_user_id": "fromUserId", "sent_at": "createdAt", "message_type": "contentType", "content_summary": "contentExcerpt"})
+}
+
+func (s *sSysImPrivateMessage) View(ctx context.Context, in *sysin.ImMessageViewInp) (*sysin.ImMessageViewModel, error) {
+	return viewImMessage(ctx, in)
+}
+
+func (s *sSysImGroupMessage) View(ctx context.Context, in *sysin.ImMessageViewInp) (*sysin.ImMessageViewModel, error) {
+	return viewImMessage(ctx, in)
+}
+
+func viewImMessage(ctx context.Context, in *sysin.ImMessageViewInp) (*sysin.ImMessageViewModel, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	path := "/internal/admin-query/tenants/" + url.PathEscape(tenant.Code) + "/messages/" + url.PathEscape(in.Topic) + "/" + strconv.FormatInt(in.SeqId, 10)
+	return imAdminQueryOne[sysin.ImMessageViewModel](ctx, tenant, path,
+		map[string]string{"sender_user_id": "fromUserId", "sent_at": "createdAt", "message_type": "contentType"})
+}
+
+func (s *sSysImPrivateMessage) Hide(ctx context.Context, in *sysin.ImMessageActionInp) (*sysin.ImMessageCommandModel, error) {
+	return publishMessageCommand(ctx, in, "private", consts.ImAdminCommandMessageHide)
+}
+
+func (s *sSysImPrivateMessage) Delete(ctx context.Context, in *sysin.ImMessageActionInp) (*sysin.ImMessageCommandModel, error) {
+	return publishMessageCommand(ctx, in, "private", consts.ImAdminCommandMessageDelete)
+}
+
+func (s *sSysImGroupMessage) Hide(ctx context.Context, in *sysin.ImMessageActionInp) (*sysin.ImMessageCommandModel, error) {
+	return publishMessageCommand(ctx, in, "group", consts.ImAdminCommandMessageHide)
+}
+
+func (s *sSysImGroupMessage) Delete(ctx context.Context, in *sysin.ImMessageActionInp) (*sysin.ImMessageCommandModel, error) {
+	return publishMessageCommand(ctx, in, "group", consts.ImAdminCommandMessageDelete)
+}
+
+func publishMessageCommand(ctx context.Context, in *sysin.ImMessageActionInp, conversationType string, eventType string) (*sysin.ImMessageCommandModel, error) {
+	if err := in.Filter(ctx); err != nil {
+		return nil, err
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	user := contexts.GetUser(ctx)
+	actorName := ""
+	if user != nil {
+		actorName = user.RealName
+	}
+	bizId := in.Topic + ":" + strconv.FormatInt(in.SeqId, 10)
+	command, err := imkafka.PublishAdminCommand(ctx, imkafka.AdminCommandInput{
+		TenantID: tenant.Id, TenantCode: tenant.Code, EventType: eventType, BizType: "message", BizID: bizId,
+		Actor:     &imkafka.Actor{Type: "admin", ID: strconv.FormatInt(contexts.GetUserId(ctx), 10), DisplayName: actorName},
+		Payload:   map[string]any{"conversation_type": conversationType, "topic": in.Topic, "seq_id": in.SeqId, "reason": in.Reason},
+		CreatedBy: contexts.GetUserId(ctx),
+	})
+	result := "success"
+	if err != nil {
+		result = "failed"
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, eventType, "message", in.SeqId, result, map[string]any{"conversation_type": conversationType, "topic": in.Topic, "reason": in.Reason})
+	if err != nil {
+		return nil, err
+	}
+	return &sysin.ImMessageCommandModel{CommandId: command.CommandID, EventId: command.EventID, Status: command.Status}, nil
+}
+
+func (s *sSysImPrivateMessage) Export(ctx context.Context, in *sysin.ImPrivateMessageListInp) error {
+	list, total, err := s.List(ctx, in)
+	if err != nil {
+		return err
+	}
+	return exportImMessages(ctx, list, total, in.Page, in.PerPage, "单聊消息")
+}
+
+func (s *sSysImGroupMessage) Export(ctx context.Context, in *sysin.ImGroupMessageListInp) error {
+	list, total, err := s.List(ctx, in)
+	if err != nil {
+		return err
+	}
+	return exportImMessages(ctx, list, total, in.Page, in.PerPage, "群聊消息")
+}
+
+func exportImMessages(ctx context.Context, list []*sysin.ImMessageListModel, total int, page int, perPage int, label string) error {
+	tags, err := convert.GetEntityDescTags(sysin.ImMessageExportModel{})
+	if err != nil {
+		return err
+	}
+	var exports []sysin.ImMessageExportModel
+	if err = gconv.Scan(list, &exports); err != nil {
+		return err
+	}
+	fileName := "导出" + label + "-" + gctx.CtxId(ctx)
+	sheetName := fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", total, form.CalPageCount(total, perPage), page, len(list))
+	return excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
+}
+
+func setQuery(values url.Values, key string, value string) {
+	if value != "" {
+		values.Set(key, value)
+	}
+}

server/internal/logic/sys/im_notification.go

@@ -0,0 +1,186 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"hotgo/internal/dao"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+
+	"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/os/gtime"
+)
+
+type sSysImNotification struct{}
+
+func NewSysImNotification() *sSysImNotification {
+	return &sSysImNotification{}
+}
+
+func init() {
+	service.RegisterSysImNotification(NewSysImNotification())
+}
+
+func (s *sSysImNotification) TemplateList(ctx context.Context, in *sysin.ImNotificationTemplateListInp) (list []*sysin.ImNotificationTemplateListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	scope, err := resolveImAdminScopeWithAll(ctx, in.TenantId, true)
+	if err != nil {
+		return
+	}
+	tenants, err := s.listTenants(ctx, scope.TenantId, in.TenantId)
+	if err != nil {
+		return
+	}
+	list = []*sysin.ImNotificationTemplateListModel{}
+	for _, tenant := range tenants {
+		if err = s.ensureTemplates(ctx, tenant.Id); err != nil {
+			return
+		}
+		var tenantList []*sysin.ImNotificationTemplateListModel
+		mod := imtenant.RegistryDB().Model("im_notification_template").Safe().Ctx(ctx).
+			Where("tenant_id", tenant.Id)
+		if in.Scene != "" {
+			mod = mod.Where("scene", in.Scene)
+		}
+		if in.Status != nil {
+			mod = mod.Where("status", *in.Status)
+		}
+		if err = mod.OrderAsc("id").Scan(&tenantList); err != nil {
+			return nil, 0, gerror.Wrap(err, "获取IM通知模板失败，请稍后重试！")
+		}
+		for _, item := range tenantList {
+			item.TenantName = tenant.Name
+			if parsed, parseErr := gjson.DecodeToJson(item.PayloadJson); parseErr == nil && parsed != nil {
+				item.PayloadJson = parsed.MustToJsonString()
+			}
+		}
+		list = append(list, tenantList...)
+	}
+	totalCount = len(list)
+	start, end := pageBounds(in.Page, in.PerPage, totalCount)
+	if start >= totalCount {
+		return []*sysin.ImNotificationTemplateListModel{}, totalCount, nil
+	}
+	return list[start:end], totalCount, nil
+}
+
+func (s *sSysImNotification) TemplateUpdate(ctx context.Context, in *sysin.ImNotificationTemplateUpdateInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	scope, err := resolveImAdminScope(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureTemplates(ctx, scope.TenantId); err != nil {
+		return
+	}
+	payload := "{}"
+	if in.PayloadJson != nil {
+		payload = in.PayloadJson.MustToJsonString()
+	}
+	if _, err = imtenant.RegistryDB().Model("im_notification_template").Safe().Ctx(ctx).
+		Where("tenant_id", scope.TenantId).
+		Where("scene", in.Scene).
+		Data(g.Map{
+			"in_app_enabled":   in.InAppEnabled,
+			"push_enabled":     in.PushEnabled,
+			"sms_enabled":      in.SmsEnabled,
+			"status":           in.Status,
+			"title_template":   in.TitleTemplate,
+			"content_template": in.ContentTemplate,
+			"payload_json":     payload,
+			"updated_at":       gtime.Now(),
+		}).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM通知模板失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, scope.TenantId, "im_notification_template_update", "im_notification_template", 0, "success", g.Map{"scene": in.Scene})
+	return nil
+}
+
+func (s *sSysImNotification) listTenants(ctx context.Context, scopeTenantId, requestedTenantId int64) (tenants []*entity.ImTenant, err error) {
+	mod := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx)
+	if scopeTenantId > 0 {
+		mod = mod.WherePri(scopeTenantId)
+	} else if requestedTenantId > 0 {
+		mod = mod.WherePri(requestedTenantId)
+	}
+	if err = mod.OrderAsc(dao.ImTenant.Columns().Id).Scan(&tenants); err != nil {
+		return nil, gerror.Wrap(err, "获取IM租户失败，请稍后重试！")
+	}
+	return tenants, nil
+}
+
+func (s *sSysImNotification) ensureTemplates(ctx context.Context, tenantId int64) error {
+	for _, item := range defaultNotificationTemplates() {
+		count, err := imtenant.RegistryDB().Model("im_notification_template").Safe().Ctx(ctx).
+			Where("tenant_id", tenantId).
+			Where("scene", item.Scene).
+			Count()
+		if err != nil {
+			return gerror.Wrap(err, "检查IM通知模板失败，请稍后重试！")
+		}
+		if count > 0 {
+			continue
+		}
+		if _, err = imtenant.RegistryDB().Model("im_notification_template").Safe().Ctx(ctx).Data(g.Map{
+			"tenant_id":        tenantId,
+			"scene":            item.Scene,
+			"name":             item.Name,
+			"in_app_enabled":   1,
+			"push_enabled":     item.PushEnabled,
+			"sms_enabled":      0,
+			"status":           consts.ImNotificationTemplateEnabled,
+			"title_template":   item.Title,
+			"content_template": item.Content,
+			"payload_json":     gdb.Raw("CAST('{}' AS JSON)"),
+			"created_at":       gtime.Now(),
+			"updated_at":       gtime.Now(),
+		}).Insert(); err != nil {
+			return gerror.Wrap(err, "初始化IM通知模板失败，请稍后重试！")
+		}
+	}
+	return nil
+}
+
+type notificationTemplateSeed struct {
+	Scene       string
+	Name        string
+	Title       string
+	Content     string
+	PushEnabled int
+}
+
+func defaultNotificationTemplates() []*notificationTemplateSeed {
+	return []*notificationTemplateSeed{
+		{Scene: consts.ImNotificationSceneAccountSecurity, Name: "账号安全", Title: "账号安全提醒", Content: "你的账号发生安全事件：{{event}}", PushEnabled: 1},
+		{Scene: consts.ImNotificationSceneFriendRequest, Name: "好友申请", Title: "新的好友申请", Content: "{{user}} 请求添加你为好友", PushEnabled: 1},
+		{Scene: consts.ImNotificationSceneGroupEvent, Name: "群事件", Title: "群通知", Content: "{{group}} 有新的群事件：{{event}}", PushEnabled: 1},
+		{Scene: consts.ImNotificationSceneFileEvent, Name: "文件事件", Title: "文件通知", Content: "{{file}} 状态已更新", PushEnabled: 0},
+		{Scene: consts.ImNotificationSceneMeetingReminder, Name: "会议提醒", Title: "会议提醒", Content: "{{meeting}} 将于 {{time}} 开始", PushEnabled: 1},
+		{Scene: consts.ImNotificationSceneReportReminder, Name: "日报月报提醒", Title: "填报提醒", Content: "请及时提交 {{report_type}}", PushEnabled: 1},
+		{Scene: consts.ImNotificationSceneWorkOrder, Name: "工单处理", Title: "工单状态更新", Content: "你的工单 {{ticket}} 已更新", PushEnabled: 1},
+	}
+}
+
+func pageBounds(page, perPage, total int) (start, end int) {
+	if page <= 0 {
+		page = 1
+	}
+	if perPage <= 0 {
+		perPage = 10
+	}
+	start = (page - 1) * perPage
+	end = start + perPage
+	if end > total {
+		end = total
+	}
+	return
+}

server/internal/logic/sys/im_org.go

@@ -0,0 +1,399 @@
+package sys
+
+import (
+	"context"
+	"fmt"
+	"hotgo/internal/consts"
+	"hotgo/internal/model/input/form"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+	"hotgo/utility/convert"
+	"hotgo/utility/excel"
+	"net/url"
+	"strings"
+
+	"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/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+type sSysImOrg struct{}
+
+func NewSysImOrg() *sSysImOrg {
+	return &sSysImOrg{}
+}
+
+func init() {
+	service.RegisterSysImOrg(NewSysImOrg())
+}
+
+func (s *sSysImOrg) DepartmentList(ctx context.Context, in *sysin.ImOrgDepartmentListInp) (list []*sysin.ImOrgDepartmentModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	if in.DepartmentId != "" {
+		values.Set("department_id", strings.TrimSpace(in.DepartmentId))
+	}
+	if in.ParentId != "" {
+		values.Set("parent_id", strings.TrimSpace(in.ParentId))
+	}
+	if in.Name != "" {
+		values.Set("name", strings.TrimSpace(in.Name))
+	}
+	if in.State != "" {
+		values.Set("state", strings.TrimSpace(in.State))
+	}
+	return imAdminQueryList[sysin.ImOrgDepartmentModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/org/departments",
+		values,
+		nil,
+	)
+}
+
+func (s *sSysImOrg) DepartmentExport(ctx context.Context, in *sysin.ImOrgDepartmentListInp) (err error) {
+	list, totalCount, err := s.DepartmentList(ctx, in)
+	if err != nil {
+		return
+	}
+	tags, err := convert.GetEntityDescTags(sysin.ImOrgDepartmentExportModel{})
+	if err != nil {
+		return
+	}
+	var exports []sysin.ImOrgDepartmentExportModel
+	if err = gconv.Scan(list, &exports); err != nil {
+		return
+	}
+	fileName := "导出IM组织部门-" + gctx.CtxId(ctx)
+	sheetName := fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, form.CalPageCount(totalCount, in.PerPage), in.Page, len(list))
+	if len(list) > 0 {
+		_ = writeImAdminAudit(ctx, list[0].TenantId, "im_org_department_export", "im_org_department", 0, "success", g.Map{"count": len(list)})
+	}
+	return excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
+}
+
+func (s *sSysImOrg) DepartmentEdit(ctx context.Context, in *sysin.ImOrgDepartmentEditInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if in.ParentId != "root" {
+		if exists, err := s.departmentExists(ctx, db, in.ParentId); err != nil {
+			return err
+		} else if !exists {
+			return gerror.New("上级部门不存在")
+		}
+	}
+	if in.Id > 0 {
+		current, err := db.Model("im_org_departments").Safe().Ctx(ctx).Where("id", in.Id).One()
+		if err != nil {
+			return gerror.Wrap(err, "获取IM组织部门失败，请稍后重试！")
+		}
+		if current.IsEmpty() {
+			return gerror.New("部门不存在")
+		}
+		departmentId := current["department_id"].String()
+		if in.ParentId == departmentId {
+			return gerror.New("上级部门不能选择自身")
+		}
+		if err = s.ensureNoDepartmentCycle(ctx, db, departmentId, in.ParentId); err != nil {
+			return err
+		}
+		if _, err = db.Model("im_org_departments").Safe().Ctx(ctx).
+			Where("id", in.Id).
+			Data(g.Map{
+				"name":       in.Name,
+				"parent_id":  in.ParentId,
+				"sort_order": in.SortOrder,
+				"state":      in.State,
+				"version":    gdb.Raw("version+1"),
+				"updated_at": gtime.Now(),
+			}).Update(); err != nil {
+			return gerror.Wrap(err, "更新IM组织部门失败，请稍后重试！")
+		}
+		_ = writeImAdminAudit(ctx, tenant.Id, "im_org_department_update", "im_org_department", in.Id, "success", g.Map{"department_id": departmentId})
+		return nil
+	}
+	departmentId := in.DepartmentId
+	if departmentId == "" {
+		departmentId = "dep_" + strings.ToLower(guid.S())
+	}
+	if exists, err := s.departmentExists(ctx, db, departmentId); err != nil {
+		return err
+	} else if exists {
+		return gerror.New("部门ID已存在")
+	}
+	if _, err = db.Model("im_org_departments").Safe().Ctx(ctx).Data(g.Map{
+		"department_id": departmentId,
+		"name":          in.Name,
+		"parent_id":     in.ParentId,
+		"sort_order":    in.SortOrder,
+		"state":         in.State,
+		"version":       1,
+		"created_at":    gtime.Now(),
+		"updated_at":    gtime.Now(),
+	}).Insert(); err != nil {
+		return gerror.Wrap(err, "创建IM组织部门失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_org_department_create", "im_org_department", 0, "success", g.Map{"department_id": departmentId})
+	return nil
+}
+
+func (s *sSysImOrg) DepartmentDelete(ctx context.Context, in *sysin.ImOrgDepartmentDeleteInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if in.DepartmentId == "root" {
+		return gerror.New("根部门不能删除")
+	}
+	if exists, err := s.departmentExists(ctx, db, in.DepartmentId); err != nil {
+		return err
+	} else if !exists {
+		return gerror.New("部门不存在")
+	}
+	childCount, err := db.Model("im_org_departments").Safe().Ctx(ctx).Where("parent_id", in.DepartmentId).Count()
+	if err != nil {
+		return gerror.Wrap(err, "检查子部门失败，请稍后重试！")
+	}
+	if childCount > 0 {
+		return gerror.New("存在子部门，请先处理后再删除")
+	}
+	memberCount, err := db.Model("im_org_members").Safe().Ctx(ctx).Where("department_id", in.DepartmentId).Count()
+	if err != nil {
+		return gerror.Wrap(err, "检查部门成员失败，请稍后重试！")
+	}
+	if memberCount > 0 {
+		return gerror.New("存在部门成员，请先移除后再删除")
+	}
+	if _, err = db.Model("im_org_departments").Safe().Ctx(ctx).Where("department_id", in.DepartmentId).Delete(); err != nil {
+		return gerror.Wrap(err, "删除IM组织部门失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_org_department_delete", "im_org_department", 0, "success", g.Map{"department_id": in.DepartmentId})
+	return nil
+}
+
+func (s *sSysImOrg) MemberList(ctx context.Context, in *sysin.ImOrgMemberListInp) (list []*sysin.ImOrgMemberModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenant, err := resolveImAdminTenant(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	values := addPageQuery(url.Values{}, in.Page, in.PerPage)
+	if in.DepartmentId != "" {
+		values.Set("department_id", strings.TrimSpace(in.DepartmentId))
+	}
+	if in.UserId > 0 {
+		values.Set("user_id", int64ToString(in.UserId))
+	}
+	if in.EmploymentState != "" {
+		values.Set("employment_state", strings.TrimSpace(in.EmploymentState))
+	}
+	if in.Query != "" {
+		values.Set("q", strings.TrimSpace(in.Query))
+	}
+	return imAdminQueryList[sysin.ImOrgMemberModel](ctx, tenant,
+		"/internal/admin-query/tenants/"+url.PathEscape(tenant.Code)+"/org/members",
+		values,
+		nil,
+	)
+}
+
+func (s *sSysImOrg) MemberExport(ctx context.Context, in *sysin.ImOrgMemberListInp) (err error) {
+	list, totalCount, err := s.MemberList(ctx, in)
+	if err != nil {
+		return
+	}
+	tags, err := convert.GetEntityDescTags(sysin.ImOrgMemberExportModel{})
+	if err != nil {
+		return
+	}
+	var exports []sysin.ImOrgMemberExportModel
+	if err = gconv.Scan(list, &exports); err != nil {
+		return
+	}
+	fileName := "导出IM组织成员-" + gctx.CtxId(ctx)
+	sheetName := fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, form.CalPageCount(totalCount, in.PerPage), in.Page, len(list))
+	if len(list) > 0 {
+		_ = writeImAdminAudit(ctx, list[0].TenantId, "im_org_member_export", "im_org_member", 0, "success", g.Map{"count": len(list), "department_id": in.DepartmentId})
+	}
+	return excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
+}
+
+func (s *sSysImOrg) MemberEdit(ctx context.Context, in *sysin.ImOrgMemberEditInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if exists, err := s.departmentExists(ctx, db, in.DepartmentId); err != nil {
+		return err
+	} else if !exists {
+		return gerror.New("部门不存在")
+	}
+	userCount, err := db.Model("im_users").Safe().Ctx(ctx).Where("id", in.UserId).Count()
+	if err != nil {
+		return gerror.Wrap(err, "检查IM用户失败，请稍后重试！")
+	}
+	if userCount == 0 {
+		return gerror.New("IM用户不存在")
+	}
+	data := g.Map{
+		"department_id":    in.DepartmentId,
+		"user_id":          in.UserId,
+		"display_name":     in.DisplayName,
+		"position":         in.Position,
+		"avatar_file_id":   in.AvatarFileId,
+		"mobile":           in.Mobile,
+		"email":            in.Email,
+		"employment_state": in.EmploymentState,
+		"contactable":      in.Contactable,
+		"sort_order":       in.SortOrder,
+		"updated_at":       gtime.Now(),
+	}
+	if in.Id > 0 {
+		data["version"] = gdb.Raw("version+1")
+		if _, err = db.Model("im_org_members").Safe().Ctx(ctx).Where("id", in.Id).Data(data).Update(); err != nil {
+			return gerror.Wrap(err, "更新IM组织成员失败，请稍后重试！")
+		}
+		_ = writeImAdminAudit(ctx, tenant.Id, "im_org_member_update", "im_org_member", in.Id, "success", g.Map{"department_id": in.DepartmentId, "user_id": in.UserId})
+		return nil
+	}
+	data["version"] = 1
+	data["created_at"] = gtime.Now()
+	if _, err = db.Model("im_org_members").Safe().Ctx(ctx).Data(data).Insert(); err != nil {
+		return gerror.Wrap(err, "添加IM组织成员失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_org_member_create", "im_org_member", 0, "success", g.Map{"department_id": in.DepartmentId, "user_id": in.UserId})
+	return nil
+}
+
+func (s *sSysImOrg) MemberDelete(ctx context.Context, in *sysin.ImOrgMemberDeleteInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	current, err := db.Model("im_org_members").Safe().Ctx(ctx).Where("id", in.Id).One()
+	if err != nil {
+		return gerror.Wrap(err, "获取IM组织成员失败，请稍后重试！")
+	}
+	if current.IsEmpty() {
+		return gerror.New("组织成员不存在")
+	}
+	if _, err = db.Model("im_org_members").Safe().Ctx(ctx).Where("id", in.Id).Delete(); err != nil {
+		return gerror.Wrap(err, "删除IM组织成员失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_org_member_delete", "im_org_member", in.Id, "success", g.Map{"department_id": current["department_id"].String(), "user_id": current["user_id"].Int64()})
+	return nil
+}
+
+func (s *sSysImOrg) Search(ctx context.Context, in *sysin.ImOrgSearchInp) (res *sysin.ImOrgSearchModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	departments, _, err := s.DepartmentList(ctx, &sysin.ImOrgDepartmentListInp{
+		PageReq:  form.PageReq{Page: 1, PerPage: 20, Pagination: true},
+		TenantId: in.TenantId,
+		Name:     in.Query,
+		State:    consts.ImOrgDepartmentStateActive,
+	})
+	if err != nil {
+		return nil, err
+	}
+	members, _, err := s.MemberList(ctx, &sysin.ImOrgMemberListInp{
+		PageReq:         form.PageReq{Page: 1, PerPage: 20, Pagination: true},
+		TenantId:        in.TenantId,
+		Query:           in.Query,
+		EmploymentState: consts.ImOrgEmploymentStateActive,
+	})
+	if err != nil {
+		return nil, err
+	}
+	res = &sysin.ImOrgSearchModel{Departments: departments, Members: members}
+	return
+}
+
+func (s *sSysImOrg) departmentModel(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model("im_org_departments d").Safe().Ctx(ctx).Fields(
+		"d.id",
+		"d.department_id",
+		"d.name",
+		"d.parent_id",
+		"d.sort_order",
+		"d.version",
+		"d.state",
+		"d.created_at",
+		"d.updated_at",
+		"(SELECT COUNT(*) FROM im_org_departments child WHERE child.parent_id=d.department_id AND child.state='active') child_count",
+		"(SELECT COUNT(*) FROM im_org_members m WHERE m.department_id=d.department_id) member_count",
+	)
+}
+
+func (s *sSysImOrg) memberModel(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model("im_org_members m").Safe().Ctx(ctx).
+		LeftJoin("im_org_departments d", "d.department_id=m.department_id").
+		Fields(
+			"m.id",
+			"m.department_id",
+			"COALESCE(d.name,'') department_name",
+			"m.user_id",
+			"m.display_name",
+			"m.position",
+			"m.avatar_file_id",
+			"m.mobile",
+			"m.email",
+			"m.employment_state",
+			"m.contactable",
+			"m.sort_order",
+			"m.version",
+			"m.created_at",
+			"m.updated_at",
+		)
+}
+
+func (s *sSysImOrg) departmentExists(ctx context.Context, db gdb.DB, departmentId string) (bool, error) {
+	count, err := db.Model("im_org_departments").Safe().Ctx(ctx).Where("department_id", strings.TrimSpace(departmentId)).Count()
+	if err != nil {
+		return false, gerror.Wrap(err, "检查IM组织部门失败，请稍后重试！")
+	}
+	return count > 0, nil
+}
+
+func (s *sSysImOrg) ensureNoDepartmentCycle(ctx context.Context, db gdb.DB, departmentId, parentId string) error {
+	next := strings.TrimSpace(parentId)
+	for next != "" && next != "root" {
+		if next == departmentId {
+			return gerror.New("上级部门不能选择自身或下级部门")
+		}
+		row, err := db.Model("im_org_departments").Safe().Ctx(ctx).Fields("parent_id").Where("department_id", next).One()
+		if err != nil {
+			return gerror.Wrap(err, "检查部门层级失败，请稍后重试！")
+		}
+		if row.IsEmpty() {
+			return gerror.New("上级部门不存在")
+		}
+		next = row["parent_id"].String()
+	}
+	return nil
+}

server/internal/logic/sys/im_outbox.go

@@ -0,0 +1,190 @@
+// Package sys
+// @Link  https://github.com/bufanyun/hotgo
+// @Copyright  Copyright (c) 2026 HotGo
+// @Author  Ms <133814250@qq.com>
+// @License  https://github.com/bufanyun/hotgo/blob/master/LICENSE
+package sys
+
+import (
+	"context"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"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 sSysImOutbox struct{}
+
+func NewSysImOutbox() *sSysImOutbox {
+	return &sSysImOutbox{}
+}
+
+func init() {
+	service.RegisterSysImOutbox(NewSysImOutbox())
+}
+
+func (s *sSysImOutbox) List(ctx context.Context, in *sysin.ImOutboxListInp) (list []*sysin.ImOutboxListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := s.tenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+
+	mod := s.model(ctx, db, in.Source)
+	mod = s.applyWhere(mod, in)
+	mod = mod.Page(in.Page, in.PerPage).OrderDesc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM Outbox列表失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantId = tenant.Id
+		item.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImOutbox) View(ctx context.Context, in *sysin.ImOutboxViewInp) (res *sysin.ImOutboxViewModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := s.tenantDB(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = s.model(ctx, db, in.Source).Where("id", in.Id).Scan(&res); err != nil {
+		return nil, gerror.Wrap(err, "获取IM Outbox详情失败，请稍后重试！")
+	}
+	if res == nil {
+		return nil, nil
+	}
+	res.TenantId = tenant.Id
+	res.TenantName = tenant.Name
+	return
+}
+
+func (s *sSysImOutbox) Retry(ctx context.Context, in *sysin.ImOutboxActionInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.updateStatus(ctx, in, sysin.ImOutboxStatusPending)
+}
+
+func (s *sSysImOutbox) Dead(ctx context.Context, in *sysin.ImOutboxActionInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	return s.updateStatus(ctx, in, sysin.ImOutboxStatusDead)
+}
+
+func (s *sSysImOutbox) tenantDB(ctx context.Context, selectedTenantId int64) (db gdb.DB, tenant *entity.ImTenant, err error) {
+	scope, err := resolveImAdminScope(ctx, selectedTenantId)
+	if err != nil {
+		return nil, nil, err
+	}
+	return imtenant.DB(ctx, scope.TenantId)
+}
+
+func (s *sSysImOutbox) model(ctx context.Context, db gdb.DB, source string) *gdb.Model {
+	if source == sysin.ImOutboxSourceGroup {
+		return db.Model("im_group_events_outbox").Safe().Ctx(ctx).Fields(
+			"'group' source",
+			"id",
+			"event_id",
+			"'topic' target_type",
+			"topic target",
+			"actor_user_id",
+			"event_type",
+			"CAST(payload AS CHAR) payload",
+			"status",
+			"attempts",
+			"next_retry_at",
+			"delivered_at",
+			"created_at",
+			"updated_at",
+		)
+	}
+	return db.Model("im_business_events_outbox").Safe().Ctx(ctx).Fields(
+		"'business' source",
+		"id",
+		"event_id",
+		"target_type",
+		"target",
+		"actor_user_id",
+		"event_type",
+		"CAST(payload AS CHAR) payload",
+		"status",
+		"attempts",
+		"next_retry_at",
+		"delivered_at",
+		"created_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImOutbox) applyWhere(mod *gdb.Model, in *sysin.ImOutboxListInp) *gdb.Model {
+	if in.EventId != "" {
+		mod = mod.WhereLike("event_id", "%"+in.EventId+"%")
+	}
+	if in.EventType != "" {
+		mod = mod.Where("event_type", in.EventType)
+	}
+	if in.TargetType != "" && in.Source == sysin.ImOutboxSourceBusiness {
+		mod = mod.Where("target_type", in.TargetType)
+	}
+	if in.Target != "" {
+		if in.Source == sysin.ImOutboxSourceGroup {
+			mod = mod.WhereLike("topic", "%"+in.Target+"%")
+		} else {
+			mod = mod.WhereLike("target", "%"+in.Target+"%")
+		}
+	}
+	if in.Status != "" {
+		mod = mod.Where("status", in.Status)
+	}
+	if len(in.CreatedAt) == 2 {
+		mod = mod.WhereBetween("created_at", in.CreatedAt[0], in.CreatedAt[1])
+	}
+	return mod
+}
+
+func (s *sSysImOutbox) updateStatus(ctx context.Context, in *sysin.ImOutboxActionInp, status string) (err error) {
+	db, _, err := s.tenantDB(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	table := "im_business_events_outbox"
+	if in.Source == sysin.ImOutboxSourceGroup {
+		table = "im_group_events_outbox"
+	}
+	current, err := db.Model(table).Safe().Ctx(ctx).Fields("status").Where("id", in.Id).Value()
+	if err != nil {
+		return gerror.Wrap(err, "获取IM Outbox事件失败，请稍后重试！")
+	}
+	if current.IsNil() {
+		return gerror.New("IM Outbox事件不存在")
+	}
+	if current.String() == sysin.ImOutboxStatusDelivered {
+		return gerror.New("已投递事件不能重新处置")
+	}
+
+	data := g.Map{
+		"status":     status,
+		"updated_at": gtime.Now(),
+	}
+	if status == sysin.ImOutboxStatusPending {
+		data["next_retry_at"] = nil
+		data["delivered_at"] = nil
+	}
+	if _, err = db.Model(table).Safe().Ctx(ctx).Where("id", in.Id).Data(data).Update(); err != nil {
+		return gerror.Wrap(err, "更新IM Outbox事件失败，请稍后重试！")
+	}
+	return
+}

server/internal/logic/sys/im_policy_support.go

@@ -0,0 +1,60 @@
+package sys
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"hotgo/internal/dao"
+	"hotgo/internal/library/contexts"
+	"hotgo/internal/library/imkafka"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"hotgo/internal/service"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+func resolveImPolicyTenant(ctx context.Context, selectedTenantID int64) (tenantID int64, tenantCode string, err error) {
+	operatorID := contexts.GetUserId(ctx)
+	if service.AdminMember().VerifySuperId(ctx, operatorID) && selectedTenantID == 0 {
+		return 0, "*", nil
+	}
+	scope, err := resolveImAdminScope(ctx, selectedTenantID)
+	if err != nil {
+		return 0, "", err
+	}
+	var tenant *entity.ImTenant
+	if err = imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).
+		Where(dao.ImTenant.Columns().Id, scope.TenantId).Scan(&tenant); err != nil {
+		return 0, "", gerror.Wrap(err, "获取IM租户失败")
+	}
+	if tenant == nil {
+		return 0, "", gerror.New("IM租户不存在")
+	}
+	return tenant.Id, tenant.Code, nil
+}
+
+func policyJSON(value *gjson.Json, fallback string) string {
+	if value == nil || value.String() == "" || value.String() == "null" {
+		return fallback
+	}
+	return value.String()
+}
+
+func publishImPolicyEvent(ctx context.Context, tenantID int64, tenantCode, eventType, group string, version uint) error {
+	return imkafka.PublishConfigEvent(ctx, imkafka.ConfigEventInput{
+		TenantID:   tenantID,
+		TenantCode: tenantCode,
+		EventType:  eventType,
+		Group:      group,
+		Keys:       []string{"version", "payload"},
+		BizID:      fmt.Sprintf("%s:%d:%d", group, tenantID, version),
+		Actor: &imkafka.Actor{
+			Type: "admin",
+			ID:   strconv.FormatInt(contexts.GetUserId(ctx), 10),
+		},
+		CreatedBy: contexts.GetUserId(ctx),
+	})
+}

server/internal/logic/sys/im_realname.go

@@ -8,7 +8,6 @@ package sys
 import (
 	"context"
 	"hotgo/internal/consts"
-	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
 
@@ -33,7 +32,7 @@ func (s *sSysImRealname) List(ctx context.Context, in *sysin.ImRealnameListInp)
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}
@@ -91,7 +90,7 @@ func (s *sSysImRealname) View(ctx context.Context, in *sysin.ImRealnameViewInp)
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return nil, err
 	}
@@ -129,7 +128,7 @@ func (s *sSysImRealname) Review(ctx context.Context, in *sysin.ImRealnameReviewI
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}

server/internal/logic/sys/im_security_policy.go

@@ -0,0 +1,331 @@
+package sys
+
+import (
+	"context"
+	"net"
+
+	"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/encoding/gjson"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type sSysImSecurityPolicy struct{}
+
+func NewSysImSecurityPolicy() *sSysImSecurityPolicy { return &sSysImSecurityPolicy{} }
+func init()                                         { service.RegisterSysImSecurityPolicy(NewSysImSecurityPolicy()) }
+
+func securityPolicyFields(alias string) []any {
+	c := dao.ImSecurityPolicy.Columns()
+	p := alias
+	if p != "" {
+		p += "."
+	}
+	return []any{p + c.Id, p + c.TenantId, p + c.PolicyVersion, p + c.PolicyName, p + c.PublishStatus, "CAST(" + p + c.PasswordPolicy + " AS CHAR) password_policy", "CAST(" + p + c.LoginRateLimit + " AS CHAR) login_rate_limit", "CAST(" + p + c.SensitiveWordPolicy + " AS CHAR) sensitive_word_policy", "CAST(" + p + c.FileReviewPolicy + " AS CHAR) file_review_policy", "CAST(" + p + c.RealnamePolicy + " AS CHAR) realname_policy", "CAST(" + p + c.RiskChallengePolicy + " AS CHAR) risk_challenge_policy", p + c.GlobalFriendEnabled, "CAST(" + p + c.FriendDisabledPolicy + " AS CHAR) friend_disabled_policy", p + c.MessageCurfewEnabled, p + c.Remark, p + c.PublishedAt, p + c.PublishedBy, p + c.CreatedAt, p + c.UpdatedAt}
+}
+
+func (s *sSysImSecurityPolicy) List(ctx context.Context, in *sysin.ImSecurityPolicyListInp) (list []*sysin.ImSecurityPolicyModel, 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.ImSecurityPolicy.Columns()
+	model := imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Fields(securityPolicyFields("")...).Where(c.TenantId, tenantID).WhereNull(c.DeletedAt)
+	if in.PublishStatus != "" {
+		model = model.Where(c.PublishStatus, in.PublishStatus)
+	}
+	err = model.Page(in.Page, in.PerPage).OrderDesc(c.PolicyVersion).ScanAndCount(&list, &total, false)
+	return
+}
+
+func (s *sSysImSecurityPolicy) View(ctx context.Context, in *sysin.ImSecurityPolicyViewInp) (res *sysin.ImSecurityPolicyModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	c := dao.ImSecurityPolicy.Columns()
+	baseModel := imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Fields(securityPolicyFields("")...).WhereNull(c.DeletedAt)
+	if in.Id > 0 {
+		err = baseModel.Where(c.Id, in.Id).Scan(&res)
+	} else {
+		tenantID, _, resolveErr := resolveImPolicyTenant(ctx, in.TenantId)
+		if resolveErr != nil {
+			return nil, resolveErr
+		}
+		err = baseModel.Where(c.TenantId, tenantID).
+			Where(c.PublishStatus, consts.ImSecurityPublishPublished).
+			OrderDesc(c.PolicyVersion).Scan(&res)
+		if err == nil && res == nil {
+			err = baseModel.Where(c.TenantId, tenantID).OrderDesc(c.PolicyVersion).Scan(&res)
+		}
+	}
+	if err != nil {
+		return nil, gerror.Wrap(err, "获取安全策略失败")
+	}
+	if res == nil {
+		return nil, gerror.New("安全策略不存在")
+	}
+	if _, _, err = resolveImPolicyTenant(ctx, res.TenantId); err != nil {
+		return nil, err
+	}
+	res.CurfewRules, err = s.curfewRules(ctx, res.Id)
+	return
+}
+
+func (s *sSysImSecurityPolicy) curfewRules(ctx context.Context, policyID int64) (list []*sysin.ImMessageCurfewRuleModel, err error) {
+	c := dao.ImMessageCurfewRules.Columns()
+	err = imtenant.RegistryDB().Model(dao.ImMessageCurfewRules.Table()).Safe().Ctx(ctx).Fields(c.Id, c.RuleCode, c.RuleName, c.DateType, "CAST("+c.CustomDates+" AS CHAR) custom_dates", "CAST("+c.Weekdays+" AS CHAR) weekdays", c.Timezone, "TIME_FORMAT("+c.StartTime+",'%H:%i') start_time", "TIME_FORMAT("+c.EndTime+",'%H:%i') end_time", c.Scope, "CAST("+c.WhitelistUserIds+" AS CHAR) whitelist_user_ids", "CAST("+c.WhitelistGroupIds+" AS CHAR) whitelist_group_ids", c.Message, c.Status, c.Sort).Where(c.PolicyId, policyID).WhereNull(c.DeletedAt).OrderAsc(c.Sort).OrderAsc(c.Id).Scan(&list)
+	return
+}
+
+func (s *sSysImSecurityPolicy) Save(ctx context.Context, in *sysin.ImSecurityPolicySaveInp) (id int64, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return 0, err
+	}
+	db := imtenant.RegistryDB()
+	c := dao.ImSecurityPolicy.Columns()
+	rc := dao.ImMessageCurfewRules.Columns()
+	operator := contexts.GetUserId(ctx)
+	now := gtime.Now()
+	err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		version := uint(0)
+		if in.Id > 0 {
+			current, readErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One()
+			if readErr != nil {
+				return readErr
+			}
+			if current.IsEmpty() || current[c.TenantId].Int64() != tenantID {
+				return gerror.New("安全策略不存在")
+			}
+			if current[c.PublishStatus].String() != consts.ImSecurityPublishDraft {
+				return gerror.New("只有草稿状态的安全策略可以编辑")
+			}
+			version = current[c.PolicyVersion].Uint()
+			id = in.Id
+		} else {
+			maxValue, maxErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.TenantId, tenantID).Max(c.PolicyVersion)
+			if maxErr != nil {
+				return maxErr
+			}
+			version = uint(maxValue) + 1
+		}
+		data := g.Map{c.TenantId: tenantID, c.PolicyVersion: version, c.PolicyName: in.PolicyName, c.PublishStatus: consts.ImSecurityPublishDraft, c.PasswordPolicy: policyJSON(in.PasswordPolicy, "{}"), c.LoginRateLimit: policyJSON(in.LoginRateLimit, "{}"), c.SensitiveWordPolicy: policyJSON(in.SensitiveWordPolicy, "{}"), c.FileReviewPolicy: policyJSON(in.FileReviewPolicy, "{}"), c.RealnamePolicy: policyJSON(in.RealnamePolicy, "{}"), c.RiskChallengePolicy: policyJSON(in.RiskChallengePolicy, "{}"), c.GlobalFriendEnabled: in.GlobalFriendEnabled, c.FriendDisabledPolicy: policyJSON(in.FriendDisabledPolicy, `{"hide_profile":true,"block_qrcode":true,"block_group_member_entry":true,"blocked_entries":["search","profile_card","group_member","qrcode","invite_auto_add","recommendation"],"message":"当前时段暂不允许添加好友"}`), c.MessageCurfewEnabled: in.MessageCurfewEnabled, c.Remark: in.Remark, c.UpdatedAt: now, c.UpdatedBy: operator}
+		if in.Id > 0 {
+			if _, updateErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(data).Update(); updateErr != nil {
+				return updateErr
+			}
+		} else {
+			data[c.CreatedAt] = now
+			data[c.CreatedBy] = operator
+			result, insertErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Data(data).Insert()
+			if insertErr != nil {
+				return insertErr
+			}
+			id, insertErr = result.LastInsertId()
+			if insertErr != nil {
+				return insertErr
+			}
+		}
+		if _, deleteErr := tx.Model(dao.ImMessageCurfewRules.Table()).Safe().Ctx(ctx).Where(rc.PolicyId, id).Delete(); deleteErr != nil {
+			return deleteErr
+		}
+		for _, rule := range in.CurfewRules {
+			_, insertErr := tx.Model(dao.ImMessageCurfewRules.Table()).Safe().Ctx(ctx).Data(g.Map{rc.TenantId: tenantID, rc.PolicyId: id, rc.RuleCode: rule.RuleCode, rc.RuleName: rule.RuleName, rc.DateType: rule.DateType, rc.CustomDates: policyJSON(rule.CustomDates, "[]"), rc.Weekdays: policyJSON(rule.Weekdays, "[]"), rc.Timezone: rule.Timezone, rc.StartTime: rule.StartTime, rc.EndTime: rule.EndTime, rc.Scope: rule.Scope, rc.WhitelistUserIds: policyJSON(rule.WhitelistUserIds, "[]"), rc.WhitelistGroupIds: policyJSON(rule.WhitelistGroupIds, "[]"), rc.Message: rule.Message, rc.Status: rule.Status, rc.Sort: rule.Sort, rc.CreatedAt: now, rc.CreatedBy: operator, rc.UpdatedAt: now, rc.UpdatedBy: operator}).Insert()
+			if insertErr != nil {
+				return insertErr
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return 0, gerror.Wrap(err, "保存安全策略草稿失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_security_policy_save", "im_security_policy", id, "success", g.Map{"global_friend_enabled": in.GlobalFriendEnabled, "message_curfew_enabled": in.MessageCurfewEnabled})
+	return id, nil
+}
+
+func (s *sSysImSecurityPolicy) Publish(ctx context.Context, in *sysin.ImSecurityPolicyPublishInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	db := imtenant.RegistryDB()
+	c := dao.ImSecurityPolicy.Columns()
+	var row gdb.Record
+	var err error
+	if row, err = db.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
+		return err
+	}
+	if row.IsEmpty() {
+		return gerror.New("安全策略不存在")
+	}
+	if row[c.PublishStatus].String() != consts.ImSecurityPublishDraft {
+		return gerror.New("只有草稿状态可以发布")
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, row[c.TenantId].Int64())
+	if err != nil {
+		return err
+	}
+	operator := contexts.GetUserId(ctx)
+	now := gtime.Now()
+	err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		if _, updateErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.TenantId, tenantID).Where(c.PublishStatus, consts.ImSecurityPublishPublished).WhereNot(c.Id, in.Id).WhereNull(c.DeletedAt).Data(g.Map{c.PublishStatus: consts.ImSecurityPublishArchived, c.UpdatedAt: now, c.UpdatedBy: operator}).Update(); updateErr != nil {
+			return updateErr
+		}
+		if _, updateErr := tx.Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(g.Map{c.PublishStatus: consts.ImSecurityPublishPublished, c.PublishedAt: now, c.PublishedBy: operator, c.UpdatedAt: now, c.UpdatedBy: operator}).Update(); updateErr != nil {
+			return updateErr
+		}
+		if tenantID > 0 {
+			tc := dao.ImTenantConfig.Columns()
+			if _, updateErr := tx.Model(dao.ImTenantConfig.Table()).Safe().Ctx(ctx).Where(tc.TenantId, tenantID).Data(g.Map{tc.SecurityPolicyVersion: row[c.PolicyVersion].Uint(), tc.GlobalFriendEnabled: row[c.GlobalFriendEnabled].Int(), tc.MessageCurfewEnabled: row[c.MessageCurfewEnabled].Int(), tc.UpdatedAt: now, tc.UpdatedBy: operator}).Update(); updateErr != nil {
+				return updateErr
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return gerror.Wrap(err, "发布安全策略失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_security_policy_publish", "im_security_policy", in.Id, "success", g.Map{"reason": in.Reason, "version": row[c.PolicyVersion].Uint()})
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "security.policy.updated", "security_policy", row[c.PolicyVersion].Uint())
+}
+
+func (s *sSysImSecurityPolicy) RestoreDefault(ctx context.Context, in *sysin.ImSecurityPolicyRestoreInp) (int64, error) {
+	if err := in.Filter(ctx); err != nil {
+		return 0, err
+	}
+	tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return 0, err
+	}
+	c := dao.ImSecurityPolicy.Columns()
+	var source *sysin.ImSecurityPolicyModel
+	err = imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).
+		Fields(securityPolicyFields("")...).Where(c.TenantId, 0).
+		Where(c.PublishStatus, consts.ImSecurityPublishPublished).WhereNull(c.DeletedAt).
+		OrderDesc(c.PolicyVersion).Scan(&source)
+	if err != nil {
+		return 0, gerror.Wrap(err, "读取全局默认安全策略失败")
+	}
+	if source == nil {
+		return 0, gerror.New("全局默认安全策略不存在")
+	}
+	source.CurfewRules, err = s.curfewRules(ctx, source.Id)
+	if err != nil {
+		return 0, err
+	}
+	rules := make([]*sysin.ImMessageCurfewRuleInp, 0, len(source.CurfewRules))
+	for _, rule := range source.CurfewRules {
+		rules = append(rules, &sysin.ImMessageCurfewRuleInp{RuleCode: rule.RuleCode, RuleName: rule.RuleName, DateType: rule.DateType, CustomDates: gjson.New(rule.CustomDates), Weekdays: gjson.New(rule.Weekdays), Timezone: rule.Timezone, StartTime: rule.StartTime, EndTime: rule.EndTime, Scope: rule.Scope, WhitelistUserIds: gjson.New(rule.WhitelistUserIds), WhitelistGroupIds: gjson.New(rule.WhitelistGroupIds), Message: rule.Message, Status: rule.Status, Sort: rule.Sort})
+	}
+	id, err := s.Save(ctx, &sysin.ImSecurityPolicySaveInp{TenantId: tenantID, PolicyName: "恢复默认安全策略", PasswordPolicy: gjson.New(source.PasswordPolicy), LoginRateLimit: gjson.New(source.LoginRateLimit), SensitiveWordPolicy: gjson.New(source.SensitiveWordPolicy), FileReviewPolicy: gjson.New(source.FileReviewPolicy), RealnamePolicy: gjson.New(source.RealnamePolicy), RiskChallengePolicy: gjson.New(source.RiskChallengePolicy), GlobalFriendEnabled: source.GlobalFriendEnabled, FriendDisabledPolicy: gjson.New(source.FriendDisabledPolicy), MessageCurfewEnabled: source.MessageCurfewEnabled, Remark: in.Reason, CurfewRules: rules})
+	if err == nil {
+		_ = writeImAdminAudit(ctx, tenantID, "im_security_policy_restore_default", "im_security_policy", id, "success", g.Map{"reason": in.Reason})
+	}
+	return id, err
+}
+
+func (s *sSysImSecurityPolicy) IPRuleList(ctx context.Context, in *sysin.ImSecurityIPRuleListInp) (list []*sysin.ImSecurityIPRuleModel, 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.ImSecurityIpRules.Columns()
+	model := imtenant.RegistryDB().Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Fields(c.Id, c.TenantId, c.RuleType, c.IpCidr, c.Action, "CAST("+c.SceneJson+" AS CHAR) scene_json", c.RiskLevel, c.Status, c.ExpiresAt, c.Remark, c.CreatedAt, c.UpdatedAt).Where(c.TenantId, tenantID).WhereNull(c.DeletedAt)
+	if in.RuleType != "" {
+		model = model.Where(c.RuleType, in.RuleType)
+	}
+	if in.IpCidr != "" {
+		model = model.WhereLike(c.IpCidr, "%"+in.IpCidr+"%")
+	}
+	if in.Status != 0 {
+		model = model.Where(c.Status, in.Status)
+	}
+	err = model.Page(in.Page, in.PerPage).OrderDesc(c.Id).ScanAndCount(&list, &total, false)
+	return
+}
+
+func (s *sSysImSecurityPolicy) IPRuleEdit(ctx context.Context, in *sysin.ImSecurityIPRuleEditInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	if net.ParseIP(in.IpCidr) == nil {
+		if _, _, err := net.ParseCIDR(in.IpCidr); err != nil {
+			return gerror.New("IP或CIDR格式不合法")
+		}
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	c := dao.ImSecurityIpRules.Columns()
+	db := imtenant.RegistryDB()
+	now := gtime.Now()
+	data := g.Map{c.TenantId: tenantID, c.RuleType: in.RuleType, c.IpCidr: in.IpCidr, c.Action: in.Action, c.SceneJson: policyJSON(in.SceneJson, "[]"), c.RiskLevel: in.RiskLevel, c.Status: in.Status, c.ExpiresAt: in.ExpiresAt, c.Remark: in.Remark, c.UpdatedAt: now, c.UpdatedBy: contexts.GetUserId(ctx)}
+	targetID := in.Id
+	if in.Id > 0 {
+		var row gdb.Record
+		if row, err = db.Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
+			return err
+		}
+		if row.IsEmpty() || row[c.TenantId].Int64() != tenantID {
+			return gerror.New("IP规则不存在")
+		}
+		_, err = db.Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(data).Update()
+	} else {
+		data[c.CreatedAt] = now
+		data[c.CreatedBy] = contexts.GetUserId(ctx)
+		result, insertErr := db.Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Data(data).Insert()
+		err = insertErr
+		if err == nil {
+			targetID, err = result.LastInsertId()
+		}
+	}
+	if err != nil {
+		return gerror.Wrap(err, "保存IP规则失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_security_ip_rule_edit", "im_security_ip_rule", targetID, "success", g.Map{"ip_cidr": in.IpCidr, "rule_type": in.RuleType})
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "security.policy.updated", "security_policy", uint(targetID))
+}
+
+func (s *sSysImSecurityPolicy) IPRuleDelete(ctx context.Context, in *sysin.ImSecurityIPRuleDeleteInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	c := dao.ImSecurityIpRules.Columns()
+	db := imtenant.RegistryDB()
+	var row gdb.Record
+	var err error
+	if row, err = db.Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
+		return err
+	}
+	if row.IsEmpty() {
+		return gerror.New("IP规则不存在")
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, row[c.TenantId].Int64())
+	if err != nil {
+		return err
+	}
+	_, err = db.Model(dao.ImSecurityIpRules.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(g.Map{c.Status: consts.StatusDisable, c.DeletedAt: gtime.Now(), c.DeletedBy: contexts.GetUserId(ctx), c.UpdatedAt: gtime.Now(), c.UpdatedBy: contexts.GetUserId(ctx)}).Update()
+	if err != nil {
+		return gerror.Wrap(err, "删除IP规则失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_security_ip_rule_delete", "im_security_ip_rule", in.Id, "success", nil)
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "security.policy.updated", "security_policy", uint(in.Id))
+}

server/internal/logic/sys/im_sensitive_word.go

@@ -0,0 +1,266 @@
+package sys
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"strings"
+
+	"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 sSysImSensitiveWord struct{}
+
+func NewSysImSensitiveWord() *sSysImSensitiveWord { return &sSysImSensitiveWord{} }
+func init()                                       { service.RegisterSysImSensitiveWord(NewSysImSensitiveWord()) }
+
+func normalizedSensitiveWord(value string) (string, string) {
+	normalized := strings.ToLower(strings.TrimSpace(value))
+	sum := sha256.Sum256([]byte(normalized))
+	return normalized, hex.EncodeToString(sum[:])
+}
+
+func (s *sSysImSensitiveWord) List(ctx context.Context, in *sysin.ImSensitiveWordListInp) (list []*sysin.ImSensitiveWordListModel, 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.ImSensitiveWords.Columns()
+	gc := dao.ImSensitiveWordGroups.Columns()
+	model := imtenant.RegistryDB().Model(dao.ImSensitiveWords.Table()+" w").Safe().Ctx(ctx).LeftJoin(dao.ImSensitiveWordGroups.Table()+" g", "g."+gc.Id+"=w."+c.GroupId).Fields("w."+c.Id, "w."+c.TenantId, "w."+c.GroupId, "g."+gc.GroupName, "w."+c.Word, "w."+c.MatchType, "CAST(w."+c.SceneJson+" AS CHAR) scene_json", "w."+c.Action, "w."+c.Replacement, "w."+c.RiskLevel, "w."+c.Priority, "w."+c.Status, "w."+c.Remark, "w."+c.CreatedAt, "w."+c.UpdatedAt).Where("w."+c.TenantId, tenantID).WhereNull("w." + c.DeletedAt)
+	if in.GroupId > 0 {
+		model = model.Where("w."+c.GroupId, in.GroupId)
+	}
+	if in.Word != "" {
+		model = model.WhereLike("w."+c.Word, "%"+in.Word+"%")
+	}
+	if in.MatchType != "" {
+		model = model.Where("w."+c.MatchType, in.MatchType)
+	}
+	if in.Action != "" {
+		model = model.Where("w."+c.Action, in.Action)
+	}
+	if in.RiskLevel != "" {
+		model = model.Where("w."+c.RiskLevel, in.RiskLevel)
+	}
+	if in.Status != 0 {
+		model = model.Where("w."+c.Status, in.Status)
+	}
+	err = model.Page(in.Page, in.PerPage).OrderDesc("w."+c.Priority).OrderDesc("w."+c.Id).ScanAndCount(&list, &total, false)
+	if err != nil {
+		err = gerror.Wrap(err, "获取敏感词列表失败")
+	}
+	return
+}
+
+func (s *sSysImSensitiveWord) Edit(ctx context.Context, in *sysin.ImSensitiveWordEditInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	if err = validateSensitiveWordGroup(ctx, tenantID, in.GroupId); err != nil {
+		return err
+	}
+	_, hash := normalizedSensitiveWord(in.Word)
+	c := dao.ImSensitiveWords.Columns()
+	db := imtenant.RegistryDB()
+	now := gtime.Now()
+	data := g.Map{c.TenantId: tenantID, c.GroupId: in.GroupId, c.Word: in.Word, c.WordHash: hash, c.MatchType: in.MatchType, c.SceneJson: policyJSON(in.SceneJson, "[]"), c.Action: in.Action, c.Replacement: in.Replacement, c.RiskLevel: in.RiskLevel, c.Priority: in.Priority, c.Status: in.Status, c.Remark: in.Remark, c.UpdatedAt: now, c.UpdatedBy: contexts.GetUserId(ctx)}
+	targetID := in.Id
+	if in.Id > 0 {
+		var row gdb.Record
+		if row, err = db.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
+			return err
+		}
+		if row.IsEmpty() || row[c.TenantId].Int64() != tenantID {
+			return gerror.New("敏感词不存在")
+		}
+		_, err = db.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(data).Update()
+	} else {
+		data[c.CreatedAt] = now
+		data[c.CreatedBy] = contexts.GetUserId(ctx)
+		result, insertErr := db.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Data(data).Insert()
+		err = insertErr
+		if err == nil {
+			targetID, err = result.LastInsertId()
+		}
+	}
+	if err != nil {
+		return gerror.Wrap(err, "保存敏感词失败，请检查是否重复")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_sensitive_word_edit", "im_sensitive_word", targetID, "success", g.Map{"group_id": in.GroupId, "action": in.Action})
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "sensitive_words.updated", "sensitive_words", uint(targetID))
+}
+
+func (s *sSysImSensitiveWord) Delete(ctx context.Context, in *sysin.ImSensitiveWordDeleteInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	return s.updateWordState(ctx, in.Id, consts.StatusDisable, true, "im_sensitive_word_delete")
+}
+func (s *sSysImSensitiveWord) Status(ctx context.Context, in *sysin.ImSensitiveWordStatusInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	return s.updateWordState(ctx, in.Id, in.Status, false, "im_sensitive_word_status")
+}
+func (s *sSysImSensitiveWord) updateWordState(ctx context.Context, id int64, status int, deleted bool, action string) error {
+	c := dao.ImSensitiveWords.Columns()
+	db := imtenant.RegistryDB()
+	var row gdb.Record
+	var err error
+	if row, err = db.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Where(c.Id, 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
+	}
+	data := g.Map{c.Status: status, c.UpdatedAt: gtime.Now(), c.UpdatedBy: contexts.GetUserId(ctx)}
+	if deleted {
+		data[c.DeletedAt] = gtime.Now()
+		data[c.DeletedBy] = contexts.GetUserId(ctx)
+	}
+	if _, err = db.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Where(c.Id, id).Data(data).Update(); err != nil {
+		return gerror.Wrap(err, "更新敏感词失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, action, "im_sensitive_word", id, "success", g.Map{"status": status})
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "sensitive_words.updated", "sensitive_words", uint(id))
+}
+
+func (s *sSysImSensitiveWord) BatchImport(ctx context.Context, in *sysin.ImSensitiveWordBatchImportInp) (res *sysin.ImSensitiveWordBatchImportModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	if err = validateSensitiveWordGroup(ctx, tenantID, in.GroupId); err != nil {
+		return nil, err
+	}
+	res = &sysin.ImSensitiveWordBatchImportModel{}
+	db := imtenant.RegistryDB()
+	c := dao.ImSensitiveWords.Columns()
+	seen := map[string]struct{}{}
+	err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		for _, raw := range in.Words {
+			word, hash := normalizedSensitiveWord(raw)
+			if word == "" {
+				res.Skipped++
+				continue
+			}
+			if _, ok := seen[hash]; ok {
+				res.Skipped++
+				continue
+			}
+			seen[hash] = struct{}{}
+			count, countErr := tx.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Where(c.TenantId, tenantID).Where(c.GroupId, in.GroupId).Where(c.WordHash, hash).WhereNull(c.DeletedAt).Count()
+			if countErr != nil {
+				return countErr
+			}
+			if count > 0 {
+				res.Skipped++
+				continue
+			}
+			now := gtime.Now()
+			_, insertErr := tx.Model(dao.ImSensitiveWords.Table()).Safe().Ctx(ctx).Data(g.Map{c.TenantId: tenantID, c.GroupId: in.GroupId, c.Word: strings.TrimSpace(raw), c.WordHash: hash, c.MatchType: in.MatchType, c.SceneJson: policyJSON(in.SceneJson, "[]"), c.Action: in.Action, c.Replacement: in.Replacement, c.RiskLevel: in.RiskLevel, c.Status: consts.StatusEnabled, c.CreatedAt: now, c.CreatedBy: contexts.GetUserId(ctx), c.UpdatedAt: now, c.UpdatedBy: contexts.GetUserId(ctx)}).Insert()
+			if insertErr != nil {
+				return insertErr
+			}
+			res.Inserted++
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, gerror.Wrap(err, "批量导入敏感词失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_sensitive_word_batch_import", "im_sensitive_word", 0, "success", g.Map{"inserted": res.Inserted, "skipped": res.Skipped})
+	err = publishImPolicyEvent(ctx, tenantID, tenantCode, "sensitive_words.updated", "sensitive_words", uint(res.Inserted))
+	return
+}
+
+func (s *sSysImSensitiveWord) GroupList(ctx context.Context, in *sysin.ImSensitiveWordGroupListInp) (list []*sysin.ImSensitiveWordGroupModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	tenantID, _, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return nil, err
+	}
+	c := dao.ImSensitiveWordGroups.Columns()
+	err = imtenant.RegistryDB().Model(dao.ImSensitiveWordGroups.Table()).Safe().Ctx(ctx).Fields(c.Id, c.TenantId, c.GroupCode, c.GroupName, c.Priority, c.Status, c.Remark, c.CreatedAt).Where(c.TenantId, tenantID).WhereNull(c.DeletedAt).OrderDesc(c.Priority).OrderAsc(c.GroupName).Scan(&list)
+	return
+}
+
+func (s *sSysImSensitiveWord) GroupEdit(ctx context.Context, in *sysin.ImSensitiveWordGroupEditInp) error {
+	if err := in.Filter(ctx); err != nil {
+		return err
+	}
+	tenantID, tenantCode, err := resolveImPolicyTenant(ctx, in.TenantId)
+	if err != nil {
+		return err
+	}
+	c := dao.ImSensitiveWordGroups.Columns()
+	db := imtenant.RegistryDB()
+	now := gtime.Now()
+	data := g.Map{c.TenantId: tenantID, c.GroupCode: in.GroupCode, c.GroupName: in.GroupName, c.Priority: in.Priority, c.Status: in.Status, c.Remark: in.Remark, c.UpdatedAt: now, c.UpdatedBy: contexts.GetUserId(ctx)}
+	targetID := in.Id
+	if in.Id > 0 {
+		var row gdb.Record
+		if row, err = db.Model(dao.ImSensitiveWordGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).WhereNull(c.DeletedAt).One(); err != nil {
+			return err
+		}
+		if row.IsEmpty() || row[c.TenantId].Int64() != tenantID {
+			return gerror.New("敏感词分组不存在")
+		}
+		if row[c.GroupCode].String() != in.GroupCode {
+			return gerror.New("分组编码创建后不能修改")
+		}
+		_, err = db.Model(dao.ImSensitiveWordGroups.Table()).Safe().Ctx(ctx).Where(c.Id, in.Id).Data(data).Update()
+	} else {
+		data[c.CreatedAt] = now
+		data[c.CreatedBy] = contexts.GetUserId(ctx)
+		result, insertErr := db.Model(dao.ImSensitiveWordGroups.Table()).Safe().Ctx(ctx).Data(data).Insert()
+		err = insertErr
+		if err == nil {
+			targetID, err = result.LastInsertId()
+		}
+	}
+	if err != nil {
+		return gerror.Wrap(err, "保存敏感词分组失败")
+	}
+	_ = writeImAdminAudit(ctx, tenantID, "im_sensitive_word_group_edit", "im_sensitive_word_group", targetID, "success", nil)
+	return publishImPolicyEvent(ctx, tenantID, tenantCode, "sensitive_words.updated", "sensitive_words", uint(targetID))
+}
+
+func validateSensitiveWordGroup(ctx context.Context, tenantID, groupID int64) error {
+	c := dao.ImSensitiveWordGroups.Columns()
+	count, err := imtenant.RegistryDB().Model(dao.ImSensitiveWordGroups.Table()).Safe().Ctx(ctx).Where(c.Id, groupID).Where(c.TenantId, tenantID).WhereNull(c.DeletedAt).Count()
+	if err != nil {
+		return gerror.Wrap(err, "检查敏感词分组失败")
+	}
+	if count == 0 {
+		return gerror.New("敏感词分组不存在")
+	}
+	return nil
+}

server/internal/logic/sys/im_task_dashboard.go

@@ -0,0 +1,117 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"hotgo/internal/dao"
+	"hotgo/internal/library/imtenant"
+	"hotgo/internal/model/entity"
+	"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/os/gtime"
+)
+
+type sSysImTaskDashboard struct{}
+
+func NewSysImTaskDashboard() *sSysImTaskDashboard { return &sSysImTaskDashboard{} }
+
+func init() {
+	service.RegisterSysImTaskDashboard(NewSysImTaskDashboard())
+}
+
+func (s *sSysImTaskDashboard) List(ctx context.Context, in *sysin.ImTaskDashboardListInp) (list []*sysin.ImTaskDashboardListModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	scope, err := resolveImAdminScopeWithAll(ctx, in.TenantId, true)
+	if err != nil {
+		return
+	}
+	mod := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx)
+	if scope.TenantId > 0 {
+		mod = mod.WherePri(scope.TenantId)
+	}
+	if in.TenantId > 0 {
+		mod = mod.WherePri(in.TenantId)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc(dao.ImTenant.Columns().Id)
+
+	var tenants []*entity.ImTenant
+	if err = mod.ScanAndCount(&tenants, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM任务看板租户失败，请稍后重试！")
+		return
+	}
+	list = make([]*sysin.ImTaskDashboardListModel, 0, len(tenants))
+	for _, tenant := range tenants {
+		item := s.buildTenantSummary(ctx, tenant)
+		if in.Status != "" && item.Status != in.Status {
+			continue
+		}
+		list = append(list, item)
+	}
+	if in.Status != "" {
+		totalCount = len(list)
+	}
+	return
+}
+
+func (s *sSysImTaskDashboard) buildTenantSummary(ctx context.Context, tenant *entity.ImTenant) *sysin.ImTaskDashboardListModel {
+	item := &sysin.ImTaskDashboardListModel{
+		TenantId:              tenant.Id,
+		TenantName:            tenant.Name,
+		TenantCode:            tenant.Code,
+		TenantState:           tenant.State,
+		DbStatus:              "ok",
+		Status:                consts.ImTaskDashboardStatusHealthy,
+		RecommendedNextAction: "无需处理",
+	}
+	db, _, err := imtenant.DB(ctx, tenant.Id)
+	if err != nil {
+		item.DbStatus = "error"
+		item.Status = consts.ImTaskDashboardStatusError
+		item.RecommendedNextAction = "检查租户数据库连接"
+		return item
+	}
+	item.OutboxPendingCount, _ = s.count(ctx, db, "im_business_events_outbox", "status='pending'")
+	item.OutboxFailedCount, _ = s.count(ctx, db, "im_business_events_outbox", "status='failed'")
+	item.GroupOutboxPending, _ = s.count(ctx, db, "im_group_events_outbox", "status='pending'")
+	item.GroupOutboxFailed, _ = s.count(ctx, db, "im_group_events_outbox", "status='failed'")
+	item.OrphanFileCount, _ = s.countOrphanFiles(ctx, db)
+	item.DeletedFileCount, _ = s.count(ctx, db, "im_fileuploads", "status=3")
+	item.LastOutboxCreatedAt, _ = s.maxTime(ctx, db, "im_business_events_outbox", "created_at")
+	item.LastGroupEventAt, _ = s.maxTime(ctx, db, "im_group_events_outbox", "created_at")
+	item.LastFileUpdatedAt, _ = s.maxTime(ctx, db, "im_fileuploads", "updatedat")
+	if item.OutboxFailedCount > 0 || item.GroupOutboxFailed > 0 {
+		item.Status = consts.ImTaskDashboardStatusError
+		item.RecommendedNextAction = "处理失败Outbox事件"
+	} else if item.OutboxPendingCount > 0 || item.GroupOutboxPending > 0 || item.OrphanFileCount > 0 || item.DeletedFileCount > 0 {
+		item.Status = consts.ImTaskDashboardStatusWarning
+		item.RecommendedNextAction = "检查待处理任务和文件清理"
+	}
+	return item
+}
+
+func (s *sSysImTaskDashboard) count(ctx context.Context, db gdb.DB, table string, where string) (int, error) {
+	return db.Model(table).Safe().Ctx(ctx).Where(where).Count()
+}
+
+func (s *sSysImTaskDashboard) countOrphanFiles(ctx context.Context, db gdb.DB) (int, error) {
+	return db.Model("im_fileuploads fu").Safe().Ctx(ctx).
+		LeftJoin("im_filemsglinks fml", "fml.fileid=fu.id").
+		Where("fml.id IS NULL").
+		WhereNotIn("fu.status", []int{consts.ImFileStatusDeleted, consts.ImFileStatusQuarantined}).
+		Count()
+}
+
+func (s *sSysImTaskDashboard) maxTime(ctx context.Context, db gdb.DB, table string, field string) (res *gtime.Time, err error) {
+	var row struct {
+		Value *gtime.Time `orm:"value"`
+	}
+	if err = db.Model(table).Safe().Ctx(ctx).Fields("MAX(" + field + ") value").Scan(&row); err != nil {
+		return nil, err
+	}
+	return row.Value, nil
+}

server/internal/logic/sys/im_tenant.go

@@ -7,12 +7,12 @@ package sys
 
 import (
 	"context"
+	"fmt"
 	"hotgo/internal/consts"
 	"hotgo/internal/dao"
 	"hotgo/internal/library/contexts"
 	"hotgo/internal/library/hgorm/handler"
 	"hotgo/internal/library/hgorm/hook"
-	"hotgo/internal/library/imkafka"
 	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/entity"
 	"hotgo/internal/model/input/sysin"
@@ -21,7 +21,6 @@ import (
 	"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/util/gconv"
 )
 
 type sSysImTenant struct{}
@@ -36,11 +35,11 @@ func init() {
 
 // Model IM租户ORM模型
 func (s *sSysImTenant) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
-	return handler.Model(imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx), option...)
+	return handler.Model(imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx), option...)
 }
 
 func (s *sSysImTenant) configModel(ctx context.Context) *gdb.Model {
-	return imtenant.RegistryDB(ctx).Model(dao.ImTenantConfig.Table()).Safe().Ctx(ctx)
+	return imtenant.RegistryDB().Model(dao.ImTenantConfig.Table()).Safe().Ctx(ctx)
 }
 
 // List 获取IM租户列表
@@ -145,7 +144,7 @@ func (s *sSysImTenant) Edit(ctx context.Context, in *sysin.ImTenantEditInp) (err
 		return
 	}
 
-	err = imtenant.RegistryDB(ctx).Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
+	return imtenant.RegistryDB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
 		if err = s.checkCodeUnique(ctx, in.Id, in.Code); err != nil {
 			return
 		}
@@ -170,12 +169,6 @@ func (s *sSysImTenant) Edit(ctx context.Context, in *sysin.ImTenantEditInp) (err
 		}
 		return s.saveConfig(ctx, id, in.MaxUsers, in.MaxGroups, in.MaxGroupMembers, userId)
 	})
-	if err != nil {
-		return err
-	}
-	s.publishTenantConfigEvent(ctx, in.Code, in.Id, consts.ImConfigEventTenantUpdated, "tenant")
-	s.publishTenantConfigEvent(ctx, in.Code, in.Id, consts.ImConfigEventTenantLimitsUpdated, "tenant_limits")
-	return nil
 }
 
 func (s *sSysImTenant) checkCodeUnique(ctx context.Context, id int64, code string) (err error) {
@@ -278,33 +271,139 @@ func (s *sSysImTenant) Status(ctx context.Context, in *sysin.ImTenantStatusInp)
 		err = gerror.Wrap(err, "更新IM租户状态失败，请稍后重试！")
 		return
 	}
+	return
+}
+
+func (s *sSysImTenant) Usage(ctx context.Context, in *sysin.ImTenantUsageInp) (res *sysin.ImTenantUsageModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+
 	var tenant *entity.ImTenant
-	if scanErr := s.Model(ctx).Fields(dao.ImTenant.Columns().Id, dao.ImTenant.Columns().Code).WherePri(in.Id).Scan(&tenant); scanErr == nil && tenant != nil {
-		s.publishTenantConfigEvent(ctx, tenant.Code, tenant.Id, consts.ImConfigEventTenantStatusChanged, "tenant_status")
+	if err = s.Model(ctx).WherePri(in.Id).Scan(&tenant); err != nil {
+		return nil, gerror.Wrap(err, "获取IM租户信息失败，请稍后重试！")
+	}
+	if tenant == nil || tenant.Id <= 0 {
+		return nil, gerror.New("IM租户不存在")
+	}
+
+	res = &sysin.ImTenantUsageModel{
+		Id:              tenant.Id,
+		Code:            tenant.Code,
+		Name:            tenant.Name,
+		DbName:          tenant.DbName,
+		DbDsnConfigured: tenant.DbDsn != "",
+		Warnings:        []string{},
+	}
+
+	db, _, dbErr := imtenant.DB(ctx, tenant.Id)
+	if dbErr != nil {
+		res.DbReachable = false
+		res.DbCheckError = dbErr.Error()
+		return res, nil
+	}
+	if _, pingErr := db.GetValue(ctx, "SELECT 1"); pingErr != nil {
+		res.DbReachable = false
+		res.DbCheckError = pingErr.Error()
+		return res, nil
+	}
+	res.DbReachable = true
+
+	res.SchemaVersion = s.queryScalarString(ctx, db, "kvmeta.version", "SELECT value FROM kvmeta WHERE key_='version' LIMIT 1", &res.Warnings)
+	res.UserCount = s.queryScalarInt64(ctx, db, "im_users.total", "SELECT COUNT(*) FROM im_users", &res.Warnings)
+	res.ActiveUserCount = s.queryScalarInt64(ctx, db, "im_users.active", "SELECT COUNT(*) FROM im_users WHERE state=0", &res.Warnings)
+	res.GroupCount = s.queryScalarInt64(ctx, db, "im_group_settings", "SELECT COUNT(*) FROM im_group_settings WHERE group_status<>'dissolved'", &res.Warnings)
+	res.DeviceCount = s.queryScalarInt64(ctx, db, "im_devices", "SELECT COUNT(*) FROM im_devices", &res.Warnings)
+	res.PushTokenCount = s.queryScalarInt64(ctx, db, "im_device_push_tokens", "SELECT COUNT(*) FROM im_device_push_tokens", &res.Warnings)
+	res.InviteUseCount = s.queryScalarInt64(ctx, db, "im_registration_invite_uses", "SELECT COUNT(*) FROM im_registration_invite_uses", &res.Warnings)
+	res.OutboxPendingCount = s.queryScalarInt64(ctx, db, "im_business_events_outbox", "SELECT COUNT(*) FROM im_business_events_outbox WHERE status='pending'", &res.Warnings)
+	return
+}
+
+func (s *sSysImTenant) queryScalarInt64(ctx context.Context, db gdb.DB, label, sql string, warnings *[]string) int64 {
+	value, err := db.GetValue(ctx, sql)
+	if err != nil {
+		*warnings = append(*warnings, label+": "+err.Error())
+		return 0
+	}
+	return value.Int64()
+}
+
+func (s *sSysImTenant) queryScalarString(ctx context.Context, db gdb.DB, label, sql string, warnings *[]string) string {
+	value, err := db.GetValue(ctx, sql)
+	if err != nil {
+		*warnings = append(*warnings, label+": "+err.Error())
+		return ""
+	}
+	return value.String()
+}
+
+func (s *sSysImTenant) DeletionCheck(ctx context.Context, in *sysin.ImTenantDeletionCheckInp) (res *sysin.ImTenantDeletionCheckModel, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	usage, err := s.Usage(ctx, &sysin.ImTenantUsageInp{Id: in.Id})
+	if err != nil {
+		return nil, err
+	}
+	res = &sysin.ImTenantDeletionCheckModel{
+		Id:            usage.Id,
+		Code:          usage.Code,
+		Name:          usage.Name,
+		Blockers:      []string{},
+		Warnings:      usage.Warnings,
+		UserCount:     usage.UserCount,
+		GroupCount:    usage.GroupCount,
+		PendingOutbox: usage.OutboxPendingCount,
+	}
+	if !usage.DbReachable {
+		res.Blockers = append(res.Blockers, "租户业务库不可达："+usage.DbCheckError)
+	}
+	if usage.UserCount > 0 {
+		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 个用户", usage.UserCount))
+	}
+	if usage.GroupCount > 0 {
+		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 个群", usage.GroupCount))
+	}
+	if usage.OutboxPendingCount > 0 {
+		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 条待处理 Outbox", usage.OutboxPendingCount))
+	}
+	res.CanEnterDeleting = len(res.Blockers) == 0
+	return
+}
+
+func (s *sSysImTenant) EnterDeleting(ctx context.Context, in *sysin.ImTenantLifecycleInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	check, err := s.DeletionCheck(ctx, &sysin.ImTenantDeletionCheckInp{Id: in.Id})
+	if err != nil {
+		return err
+	}
+	if !check.CanEnterDeleting {
+		return gerror.New("租户未通过删除前检查，不能进入删除流程")
+	}
+	if _, err = s.Model(ctx).WherePri(in.Id).Data(g.Map{
+		dao.ImTenant.Columns().State:     consts.ImTenantStateDeleting,
+		dao.ImTenant.Columns().UpdatedBy: contexts.GetUserId(ctx),
+	}).Update(); err != nil {
+		return gerror.Wrap(err, "设置IM租户删除流程失败，请稍后重试！")
 	}
 	return
 }
 
-func (s *sSysImTenant) publishTenantConfigEvent(ctx context.Context, tenantCode string, tenantId int64, eventType string, bizId string) {
-	user := contexts.GetUser(ctx)
-	actorName := ""
-	if user != nil {
-		actorName = user.RealName
+func (s *sSysImTenant) Restore(ctx context.Context, in *sysin.ImTenantLifecycleInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
 	}
-	if err := imkafka.PublishConfigEvent(ctx, imkafka.ConfigEventInput{
-		TenantID:   tenantId,
-		TenantCode: tenantCode,
-		EventType:  eventType,
-		BizID:      bizId,
-		Group:      "tenant",
-		Keys:       []string{"tenant", "limits", "features"},
-		Actor: &imkafka.Actor{
-			Type:        "admin",
-			ID:          gconv.String(contexts.GetUserId(ctx)),
-			DisplayName: actorName,
-		},
-		CreatedBy: contexts.GetUserId(ctx),
-	}); err != nil {
-		g.Log().Warningf(ctx, "发送IM租户配置Kafka事件失败 tenant:%s type:%s err:%+v", tenantCode, eventType, err)
+	if _, err = s.Model(ctx).
+		WherePri(in.Id).
+		WhereIn(dao.ImTenant.Columns().State, []int{consts.ImTenantStateSuspended, consts.ImTenantStateDeleting}).
+		Data(g.Map{
+			dao.ImTenant.Columns().State:     consts.ImTenantStateActive,
+			dao.ImTenant.Columns().UpdatedBy: contexts.GetUserId(ctx),
+		}).Update(); err != nil {
+		return gerror.Wrap(err, "恢复IM租户失败，请稍后重试！")
 	}
+	return
 }

server/internal/logic/sys/im_user_policy_group.go

@@ -0,0 +1,374 @@
+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
+}

server/internal/logic/sys/im_work_order.go

@@ -7,7 +7,6 @@ package sys
 
 import (
 	"context"
-	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
 
@@ -32,7 +31,7 @@ func (s *sSysImWorkOrder) List(ctx context.Context, in *sysin.ImWorkOrderListInp
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}
@@ -112,7 +111,7 @@ func (s *sSysImWorkOrder) View(ctx context.Context, in *sysin.ImWorkOrderViewInp
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, tenant, err := imtenant.DB(ctx, in.TenantId)
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return nil, err
 	}
@@ -190,7 +189,7 @@ func (s *sSysImWorkOrder) Status(ctx context.Context, in *sysin.ImWorkOrderStatu
 	if err = in.Filter(ctx); err != nil {
 		return
 	}
-	db, _, err := imtenant.DB(ctx, in.TenantId)
+	db, _, err := resolveImTenantDB(ctx, in.TenantId)
 	if err != nil {
 		return
 	}

server/internal/logic/sys/im_workbench.go

@@ -0,0 +1,194 @@
+package sys
+
+import (
+	"context"
+	"hotgo/internal/consts"
+	"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"
+)
+
+const imWorkbenchAppsTable = "im_workbench_apps"
+
+type sSysImWorkbench struct{}
+
+func NewSysImWorkbench() *sSysImWorkbench { return &sSysImWorkbench{} }
+
+func init() {
+	service.RegisterSysImWorkbench(NewSysImWorkbench())
+}
+
+func (s *sSysImWorkbench) List(ctx context.Context, in *sysin.ImWorkbenchAppListInp) (list []*sysin.ImWorkbenchAppModel, totalCount int, err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaultApps(ctx, db); err != nil {
+		return
+	}
+	mod := s.model(ctx, db)
+	if in.Code != "" {
+		mod = mod.WhereLike("code", "%"+in.Code+"%")
+	}
+	if in.Name != "" {
+		mod = mod.WhereLike("name", "%"+in.Name+"%")
+	}
+	if in.Enabled != nil {
+		mod = mod.Where("enabled", *in.Enabled)
+	}
+	mod = mod.Page(in.Page, in.PerPage).OrderAsc("sort_order").OrderAsc("id")
+	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
+		err = gerror.Wrap(err, "获取IM工作台模块失败，请稍后重试！")
+		return
+	}
+	for _, item := range list {
+		item.TenantId = tenant.Id
+		item.TenantName = tenant.Name
+	}
+	return
+}
+
+func (s *sSysImWorkbench) Edit(ctx context.Context, in *sysin.ImWorkbenchAppEditInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaultApps(ctx, db); err != nil {
+		return
+	}
+	data := g.Map{
+		"code":         in.Code,
+		"name":         in.Name,
+		"icon_file_id": in.IconFileId,
+		"route":        in.Route,
+		"sort_order":   in.SortOrder,
+		"unread_key":   in.UnreadKey,
+		"enabled":      in.Enabled,
+		"permission":   in.Permission,
+		"updated_at":   gtime.Now(),
+	}
+	action := "im_workbench_app_create"
+	targetId := in.Id
+	if in.Id > 0 {
+		if _, err = db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).WherePri(in.Id).Data(data).Update(); err != nil {
+			return gerror.Wrap(err, "更新IM工作台模块失败，请稍后重试！")
+		}
+		action = "im_workbench_app_update"
+	} else {
+		data["created_at"] = gtime.Now()
+		if _, err = db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Data(data).Insert(); err != nil {
+			return gerror.Wrap(err, "新增IM工作台模块失败，请稍后重试！")
+		}
+		idValue, err := db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Fields("id").Where("code", in.Code).Value()
+		if err != nil {
+			return gerror.Wrap(err, "获取IM工作台模块ID失败，请稍后重试！")
+		}
+		targetId = idValue.Int64()
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, action, "im_workbench_app", targetId, "success", g.Map{
+		"code": in.Code, "route": in.Route, "enabled": in.Enabled, "permission": in.Permission,
+	})
+	return nil
+}
+
+func (s *sSysImWorkbench) Delete(ctx context.Context, in *sysin.ImWorkbenchAppDeleteInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaultApps(ctx, db); err != nil {
+		return
+	}
+	mod := db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx)
+	if in.Id > 0 {
+		mod = mod.WherePri(in.Id)
+	} else {
+		mod = mod.Where("code", in.Code)
+	}
+	if _, err = mod.Data(g.Map{"enabled": consts.ImWorkbenchAppDisabled, "updated_at": gtime.Now()}).Update(); err != nil {
+		return gerror.Wrap(err, "禁用IM工作台模块失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_workbench_app_disable", "im_workbench_app", in.Id, "success", g.Map{"code": in.Code})
+	return nil
+}
+
+func (s *sSysImWorkbench) Reorder(ctx context.Context, in *sysin.ImWorkbenchAppReorderInp) (err error) {
+	if err = in.Filter(ctx); err != nil {
+		return
+	}
+	db, tenant, err := resolveImTenantDB(ctx, in.TenantId)
+	if err != nil {
+		return
+	}
+	if err = s.ensureDefaultApps(ctx, db); err != nil {
+		return
+	}
+	if err = db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		for _, item := range in.Items {
+			if _, e := tx.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Where("code", item.Code).
+				Data(g.Map{"sort_order": item.SortOrder, "updated_at": gtime.Now()}).Update(); e != nil {
+				return e
+			}
+		}
+		return nil
+	}); err != nil {
+		return gerror.Wrap(err, "调整IM工作台模块排序失败，请稍后重试！")
+	}
+	_ = writeImAdminAudit(ctx, tenant.Id, "im_workbench_app_reorder", "im_workbench_app", 0, "success", g.Map{"count": len(in.Items)})
+	return nil
+}
+
+func (s *sSysImWorkbench) model(ctx context.Context, db gdb.DB) *gdb.Model {
+	return db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Fields(
+		"id",
+		"code",
+		"name",
+		"icon_file_id",
+		"route",
+		"sort_order",
+		"unread_key",
+		"enabled",
+		"permission",
+		"created_at",
+		"updated_at",
+	)
+}
+
+func (s *sSysImWorkbench) ensureDefaultApps(ctx context.Context, db gdb.DB) (err error) {
+	defaults := []g.Map{
+		{"code": "organization", "name": "组织架构", "route": consts.ImWorkbenchRouteOrganization, "sort_order": 10, "unread_key": "organization", "enabled": consts.ImWorkbenchAppEnabled, "permission": consts.ImWorkbenchPermissionEnabled},
+		{"code": "meetings", "name": "会议通知", "route": consts.ImWorkbenchRouteMeetings, "sort_order": 20, "unread_key": "meetings", "enabled": consts.ImWorkbenchAppEnabled, "permission": consts.ImWorkbenchPermissionEnabled},
+		{"code": "daily_reports", "name": "日报", "route": consts.ImWorkbenchRouteDailyReports, "sort_order": 30, "unread_key": "daily_reports", "enabled": consts.ImWorkbenchAppEnabled, "permission": consts.ImWorkbenchPermissionEnabled},
+		{"code": "monthly_reports", "name": "月报", "route": consts.ImWorkbenchRouteMonthlyReports, "sort_order": 40, "unread_key": "monthly_reports", "enabled": consts.ImWorkbenchAppEnabled, "permission": consts.ImWorkbenchPermissionEnabled},
+		{"code": "executive_mailbox", "name": "总经理信箱", "route": consts.ImWorkbenchRouteExecutiveMailbox, "sort_order": 50, "unread_key": "executive_mailbox", "enabled": consts.ImWorkbenchAppEnabled, "permission": consts.ImWorkbenchPermissionEnabled},
+	}
+	now := gtime.Now()
+	for _, item := range defaults {
+		var count int
+		if count, err = db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Where("code", item["code"]).Count(); err != nil {
+			return gerror.Wrap(err, "检查IM工作台默认模块失败，请稍后重试！")
+		}
+		if count > 0 {
+			continue
+		}
+		item["created_at"] = now
+		item["updated_at"] = now
+		if _, err = db.Model(imWorkbenchAppsTable).Safe().Ctx(ctx).Data(item).Insert(); err != nil {
+			return gerror.Wrap(err, "初始化IM工作台默认模块失败，请稍后重试！")
+		}
+	}
+	return nil
+}