chore: seed migration objects batch 5

2026-10-18 13:37:24 +08:00
parent 53c9c0afd8
commit c8c40b1dd2
239 changed files with 16941 additions and 1544 deletions
@@ -0,0 +1,36 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imabusereason"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImAbuseReason = cImAbuseReason{}
+
+type cImAbuseReason struct{}
+
+func (c *cImAbuseReason) List(ctx context.Context, req *imabusereason.ListReq) (res *imabusereason.ListRes, err error) {
+	list, totalCount, err := service.SysImAbuseReason().List(ctx, &req.ImAbuseReasonListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImAbuseReasonModel{}
+	}
+	res = new(imabusereason.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImAbuseReason) Edit(ctx context.Context, req *imabusereason.EditReq) (res *imabusereason.EditRes, err error) {
+	err = service.SysImAbuseReason().Edit(ctx, &req.ImAbuseReasonEditInp)
+	return
+}
+
+func (c *cImAbuseReason) Delete(ctx context.Context, req *imabusereason.DeleteReq) (res *imabusereason.DeleteRes, err error) {
+	err = service.SysImAbuseReason().Delete(ctx, &req.ImAbuseReasonDeleteInp)
+	return
+}
@@ -0,0 +1,31 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imapprelease"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImAppRelease = cImAppRelease{}
+
+type cImAppRelease struct{}
+
+func (c *cImAppRelease) List(ctx context.Context, req *imapprelease.ListReq) (res *imapprelease.ListRes, err error) {
+	list, totalCount, err := service.SysImAppRelease().List(ctx, &req.ImAppReleaseListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImAppReleaseModel{}
+	}
+	res = new(imapprelease.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImAppRelease) Edit(ctx context.Context, req *imapprelease.EditReq) (res *imapprelease.EditRes, err error) {
+	err = service.SysImAppRelease().Edit(ctx, &req.ImAppReleaseEditInp)
+	return
+}
@@ -31,6 +31,12 @@ func (c *cImAuditLog) List(ctx context.Context, req *imauditlog.ListReq) (res *i
 	return
 }

+// Export 导出IM审计日志列表
+func (c *cImAuditLog) Export(ctx context.Context, req *imauditlog.ExportReq) (res *imauditlog.ExportRes, err error) {
+	err = service.SysImAuditLog().Export(ctx, &req.ImAuditLogListInp)
+	return
+}
+
 // View 获取指定IM审计日志信息
 func (c *cImAuditLog) View(ctx context.Context, req *imauditlog.ViewReq) (res *imauditlog.ViewRes, err error) {
 	data, err := service.SysImAuditLog().View(ctx, &req.ImAuditLogViewInp)
@@ -0,0 +1,31 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imdashboard"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImDashboard = cImDashboard{}
+
+type cImDashboard struct{}
+
+func (c *cImDashboard) Overview(ctx context.Context, req *imdashboard.OverviewReq) (res *imdashboard.OverviewRes, err error) {
+	data, err := service.SysImDashboard().Overview(ctx, &req.ImDashboardOverviewInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imdashboard.OverviewRes{ImDashboardOverviewModel: data}, nil
+}
+
+func (c *cImDashboard) Trends(ctx context.Context, req *imdashboard.TrendsReq) (res *imdashboard.TrendsRes, err error) {
+	list, err := service.SysImDashboard().Trends(ctx, &req.ImDashboardTrendsInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImDashboardTrendModel{}
+	}
+	return &imdashboard.TrendsRes{List: list}, nil
+}
@@ -0,0 +1,46 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imexternalconfig"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImExternalConfig = cImExternalConfig{}
+
+type cImExternalConfig struct{}
+
+func (c *cImExternalConfig) List(ctx context.Context, req *imexternalconfig.ListReq) (res *imexternalconfig.ListRes, err error) {
+	list, totalCount, err := service.SysImExternalConfig().List(ctx, &req.ImExternalConfigListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImExternalConfigListModel{}
+	}
+	res = new(imexternalconfig.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImExternalConfig) View(ctx context.Context, req *imexternalconfig.ViewReq) (res *imexternalconfig.ViewRes, err error) {
+	data, err := service.SysImExternalConfig().View(ctx, &req.ImExternalConfigViewInp)
+	if err != nil {
+		return
+	}
+	res = new(imexternalconfig.ViewRes)
+	res.ImExternalConfigViewModel = data
+	return
+}
+
+func (c *cImExternalConfig) Update(ctx context.Context, req *imexternalconfig.UpdateReq) (res *imexternalconfig.UpdateRes, err error) {
+	err = service.SysImExternalConfig().Update(ctx, &req.ImExternalConfigUpdateInp)
+	return
+}
+
+func (c *cImExternalConfig) Check(ctx context.Context, req *imexternalconfig.CheckReq) (res *imexternalconfig.CheckRes, err error) {
+	err = service.SysImExternalConfig().Check(ctx, &req.ImExternalConfigCheckInp)
+	return
+}
@@ -0,0 +1,25 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imfeedbackconfig"
+	"hotgo/internal/service"
+)
+
+var ImFeedbackConfig = cImFeedbackConfig{}
+
+type cImFeedbackConfig struct{}
+
+func (c *cImFeedbackConfig) Get(ctx context.Context, req *imfeedbackconfig.GetReq) (res *imfeedbackconfig.GetRes, err error) {
+	data, err := service.SysImFeedbackConfig().Get(ctx, &req.ImFeedbackConfigGetInp)
+	if err != nil {
+		return
+	}
+	res = &imfeedbackconfig.GetRes{ImFeedbackConfigModel: data}
+	return
+}
+
+func (c *cImFeedbackConfig) Update(ctx context.Context, req *imfeedbackconfig.UpdateReq) (res *imfeedbackconfig.UpdateRes, err error) {
+	err = service.SysImFeedbackConfig().Update(ctx, &req.ImFeedbackConfigUpdateInp)
+	return
+}
@@ -0,0 +1,68 @@
+// 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/api/admin/imfile"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var (
+	ImFile = cImFile{}
+)
+
+type cImFile struct{}
+
+// List 查看IM文件列表
+func (c *cImFile) List(ctx context.Context, req *imfile.ListReq) (res *imfile.ListRes, err error) {
+	list, totalCount, err := service.SysImFile().List(ctx, &req.ImFileListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImFileListModel{}
+	}
+	res = new(imfile.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+// View 获取IM文件详情
+func (c *cImFile) View(ctx context.Context, req *imfile.ViewReq) (res *imfile.ViewRes, err error) {
+	data, err := service.SysImFile().View(ctx, &req.ImFileViewInp)
+	if err != nil {
+		return
+	}
+	res = new(imfile.ViewRes)
+	res.ImFileViewModel = data
+	return
+}
+
+// Quarantine 隔离IM文件
+func (c *cImFile) Quarantine(ctx context.Context, req *imfile.QuarantineReq) (res *imfile.QuarantineRes, err error) {
+	err = service.SysImFile().Quarantine(ctx, &req.ImFileActionInp)
+	return
+}
+
+// Delete 删除IM文件
+func (c *cImFile) Delete(ctx context.Context, req *imfile.DeleteReq) (res *imfile.DeleteRes, err error) {
+	err = service.SysImFile().Delete(ctx, &req.ImFileActionInp)
+	return
+}
+
+// CleanupOrphan 清理IM孤儿文件
+func (c *cImFile) CleanupOrphan(ctx context.Context, req *imfile.CleanupOrphanReq) (res *imfile.CleanupOrphanRes, err error) {
+	data, err := service.SysImFile().CleanupOrphan(ctx, &req.ImFileCleanupOrphanInp)
+	if err != nil {
+		return
+	}
+	res = new(imfile.CleanupOrphanRes)
+	res.ImFileCleanupOrphanModel = data
+	return
+}
@@ -0,0 +1,31 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imfilepolicy"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImFilePolicy = cImFilePolicy{}
+
+type cImFilePolicy struct{}
+
+func (c *cImFilePolicy) List(ctx context.Context, req *imfilepolicy.ListReq) (res *imfilepolicy.ListRes, err error) {
+	list, totalCount, err := service.SysImFilePolicy().List(ctx, &req.ImFilePolicyListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImFilePolicyListModel{}
+	}
+	res = new(imfilepolicy.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImFilePolicy) Update(ctx context.Context, req *imfilepolicy.UpdateReq) (res *imfilepolicy.UpdateRes, err error) {
+	err = service.SysImFilePolicy().Update(ctx, &req.ImFilePolicyUpdateInp)
+	return
+}
@@ -75,6 +75,150 @@ func (c *cImGroup) Governance(ctx context.Context, req *imgroup.GovernanceReq) (
 	return
 }

+// GovernanceUpdate 更新IM群治理配置
+func (c *cImGroup) GovernanceUpdate(ctx context.Context, req *imgroup.GovernanceUpdateReq) (res *imgroup.GovernanceUpdateRes, err error) {
+	data, err := service.SysImGroup().GovernanceUpdate(ctx, &req.ImGroupGovernanceUpdateInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.GovernanceUpdateRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// ProfileUpdate 修改IM群资料
+func (c *cImGroup) ProfileUpdate(ctx context.Context, req *imgroup.ProfileUpdateReq) (res *imgroup.ProfileUpdateRes, err error) {
+	data, err := service.SysImGroup().ProfileUpdate(ctx, &req.ImGroupProfileUpdateInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.ProfileUpdateRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// Dissolve 解散IM群
+func (c *cImGroup) Dissolve(ctx context.Context, req *imgroup.DissolveReq) (res *imgroup.DissolveRes, err error) {
+	data, err := service.SysImGroup().Dissolve(ctx, &req.ImGroupDissolveInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.DissolveRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// Mute 禁言IM群成员
+func (c *cImGroup) Mute(ctx context.Context, req *imgroup.MuteReq) (res *imgroup.MuteRes, err error) {
+	data, err := service.SysImGroup().Mute(ctx, &req.ImGroupMuteInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.MuteRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// MemberMute Kafka禁言IM群成员
+func (c *cImGroup) MemberMute(ctx context.Context, req *imgroup.MemberMuteReq) (res *imgroup.MemberMuteRes, err error) {
+	data, err := service.SysImGroup().MemberMute(ctx, &req.ImGroupMuteInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.MemberMuteRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// Unmute 解除IM群成员禁言
+func (c *cImGroup) Unmute(ctx context.Context, req *imgroup.UnmuteReq) (res *imgroup.UnmuteRes, err error) {
+	data, err := service.SysImGroup().Unmute(ctx, &req.ImGroupUnmuteInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.UnmuteRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// MemberUnmute Kafka解除IM群成员禁言
+func (c *cImGroup) MemberUnmute(ctx context.Context, req *imgroup.MemberUnmuteReq) (res *imgroup.MemberUnmuteRes, err error) {
+	data, err := service.SysImGroup().MemberUnmute(ctx, &req.ImGroupUnmuteInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.MemberUnmuteRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// MemberRemove 移出IM群成员
+func (c *cImGroup) MemberRemove(ctx context.Context, req *imgroup.MemberRemoveReq) (res *imgroup.MemberRemoveRes, err error) {
+	data, err := service.SysImGroup().MemberRemove(ctx, &req.ImGroupMemberRemoveInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.MemberRemoveRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// JoinRequestApprove 通过IM入群申请
+func (c *cImGroup) JoinRequestApprove(ctx context.Context, req *imgroup.JoinRequestApproveReq) (res *imgroup.JoinRequestApproveRes, err error) {
+	err = service.SysImGroup().JoinRequestApprove(ctx, &req.ImGroupJoinRequestResolveInp)
+	return
+}
+
+// JoinRequestReject 拒绝IM入群申请
+func (c *cImGroup) JoinRequestReject(ctx context.Context, req *imgroup.JoinRequestRejectReq) (res *imgroup.JoinRequestRejectRes, err error) {
+	err = service.SysImGroup().JoinRequestReject(ctx, &req.ImGroupJoinRequestResolveInp)
+	return
+}
+
+// RoleUpdate 更新IM群成员角色
+func (c *cImGroup) RoleUpdate(ctx context.Context, req *imgroup.RoleUpdateReq) (res *imgroup.RoleUpdateRes, err error) {
+	data, err := service.SysImGroup().RoleUpdate(ctx, &req.ImGroupRoleUpdateInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.RoleUpdateRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// AdminSet 设置IM群管理员
+func (c *cImGroup) AdminSet(ctx context.Context, req *imgroup.AdminSetReq) (res *imgroup.AdminSetRes, err error) {
+	data, err := service.SysImGroup().AdminSet(ctx, &req.ImGroupRoleUpdateInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.AdminSetRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// AdminRemove 删除IM群管理员
+func (c *cImGroup) AdminRemove(ctx context.Context, req *imgroup.AdminRemoveReq) (res *imgroup.AdminRemoveRes, err error) {
+	data, err := service.SysImGroup().AdminRemove(ctx, &req.ImGroupRoleUpdateInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.AdminRemoveRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
+// OwnerTransfer 转让IM群主
+func (c *cImGroup) OwnerTransfer(ctx context.Context, req *imgroup.OwnerTransferReq) (res *imgroup.OwnerTransferRes, err error) {
+	data, err := service.SysImGroup().OwnerTransfer(ctx, &req.ImGroupOwnerTransferInp)
+	if err != nil {
+		return
+	}
+	res = new(imgroup.OwnerTransferRes)
+	res.ImGroupCommandModel = data
+	return
+}
+
 // JoinRequestList 查看IM入群申请列表
 func (c *cImGroup) JoinRequestList(ctx context.Context, req *imgroup.JoinRequestListReq) (res *imgroup.JoinRequestListRes, err error) {
 	list, totalCount, err := service.SysImGroup().JoinRequestList(ctx, &req.ImGroupJoinRequestListInp)
@@ -90,6 +234,27 @@ func (c *cImGroup) JoinRequestList(ctx context.Context, req *imgroup.JoinRequest
 	return
 }

+// FileList 查看IM群文件列表
+func (c *cImGroup) FileList(ctx context.Context, req *imgroup.FileListReq) (res *imgroup.FileListRes, err error) {
+	list, totalCount, err := service.SysImGroup().FileList(ctx, &req.ImGroupFileListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImGroupFileListModel{}
+	}
+	res = new(imgroup.FileListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+// FileDelete 删除IM群文件
+func (c *cImGroup) FileDelete(ctx context.Context, req *imgroup.FileDeleteReq) (res *imgroup.FileDeleteRes, err error) {
+	err = service.SysImGroup().FileDelete(ctx, &req.ImGroupFileDeleteInp)
+	return
+}
+
 // InvitationList 查看IM群邀请列表
 func (c *cImGroup) InvitationList(ctx context.Context, req *imgroup.InvitationListReq) (res *imgroup.InvitationListRes, err error) {
 	list, totalCount, err := service.SysImGroup().InvitationList(ctx, &req.ImGroupInvitationListInp)
@@ -0,0 +1,40 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imgroupmessage"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImGroupMessage = cImGroupMessage{}
+
+type cImGroupMessage struct{}
+
+func (c *cImGroupMessage) List(ctx context.Context, req *imgroupmessage.ListReq) (res *imgroupmessage.ListRes, err error) {
+	list, total, err := service.SysImGroupMessage().List(ctx, &req.ImGroupMessageListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImMessageListModel{}
+	}
+	res = &imgroupmessage.ListRes{List: list}
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImGroupMessage) View(ctx context.Context, req *imgroupmessage.ViewReq) (*imgroupmessage.ViewRes, error) {
+	data, err := service.SysImGroupMessage().View(ctx, &req.ImMessageViewInp)
+	return &imgroupmessage.ViewRes{ImMessageViewModel: data}, err
+}
+func (c *cImGroupMessage) Hide(ctx context.Context, req *imgroupmessage.HideReq) (*imgroupmessage.HideRes, error) {
+	data, err := service.SysImGroupMessage().Hide(ctx, &req.ImMessageActionInp)
+	return &imgroupmessage.HideRes{ImMessageCommandModel: data}, err
+}
+func (c *cImGroupMessage) Delete(ctx context.Context, req *imgroupmessage.DeleteReq) (*imgroupmessage.DeleteRes, error) {
+	data, err := service.SysImGroupMessage().Delete(ctx, &req.ImMessageActionInp)
+	return &imgroupmessage.DeleteRes{ImMessageCommandModel: data}, err
+}
+func (c *cImGroupMessage) Export(ctx context.Context, req *imgroupmessage.ExportReq) (*imgroupmessage.ExportRes, error) {
+	return &imgroupmessage.ExportRes{}, service.SysImGroupMessage().Export(ctx, &req.ImGroupMessageListInp)
+}
@@ -60,6 +60,11 @@ func (c *cImInvite) Revoke(ctx context.Context, req *iminvite.RevokeReq) (res *i
 	return
 }

+func (c *cImInvite) BindUser(ctx context.Context, req *iminvite.BindUserReq) (res *iminvite.BindUserRes, err error) {
+	err = service.SysImInvite().BindUser(ctx, &req.ImInviteBindUserInp)
+	return
+}
+
 func (c *cImInvite) BatchRevoke(ctx context.Context, req *iminvite.BatchRevokeReq) (res *iminvite.BatchRevokeRes, err error) {
 	data, err := service.SysImInvite().BatchRevoke(ctx, &req.ImInviteBatchRevokeInp)
 	if err != nil {
@@ -0,0 +1,39 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imloginfailurelog"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImLoginFailureLog = cImLoginFailureLog{}
+
+type cImLoginFailureLog struct{}
+
+func (c *cImLoginFailureLog) List(ctx context.Context, req *imloginfailurelog.ListReq) (res *imloginfailurelog.ListRes, err error) {
+	list, total, err := service.SysImLoginFailureLog().List(ctx, &req.ImLoginFailureLogListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImLoginFailureLogModel{}
+	}
+	res = &imloginfailurelog.ListRes{List: list}
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImLoginFailureLog) View(ctx context.Context, req *imloginfailurelog.ViewReq) (*imloginfailurelog.ViewRes, error) {
+	data, err := service.SysImLoginFailureLog().View(ctx, &req.ImLoginFailureViewInp)
+	return &imloginfailurelog.ViewRes{ImLoginFailureLogModel: data}, err
+}
+func (c *cImLoginFailureLog) Export(ctx context.Context, req *imloginfailurelog.ExportReq) (*imloginfailurelog.ExportRes, error) {
+	return &imloginfailurelog.ExportRes{}, service.SysImLoginFailureLog().Export(ctx, &req.ImLoginFailureLogListInp)
+}
+func (c *cImLoginFailureLog) AddBlacklist(ctx context.Context, req *imloginfailurelog.AddBlacklistReq) (*imloginfailurelog.AddBlacklistRes, error) {
+	return &imloginfailurelog.AddBlacklistRes{}, service.SysImLoginFailureLog().AddBlacklist(ctx, &req.ImLoginFailureAddBlacklistInp)
+}
+func (c *cImLoginFailureLog) BanUser(ctx context.Context, req *imloginfailurelog.BanUserReq) (*imloginfailurelog.BanUserRes, error) {
+	data, err := service.SysImLoginFailureLog().BanUser(ctx, &req.ImLoginFailureBanUserInp)
+	return &imloginfailurelog.BanUserRes{ImUserCommandModel: data}, err
+}
@@ -0,0 +1,25 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/immailboxconfig"
+	"hotgo/internal/service"
+)
+
+var ImMailboxConfig = cImMailboxConfig{}
+
+type cImMailboxConfig struct{}
+
+func (c *cImMailboxConfig) Get(ctx context.Context, req *immailboxconfig.GetReq) (res *immailboxconfig.GetRes, err error) {
+	data, err := service.SysImMailboxConfig().Get(ctx, &req.ImMailboxConfigGetInp)
+	if err != nil {
+		return
+	}
+	res = &immailboxconfig.GetRes{ImMailboxConfigModel: data}
+	return
+}
+
+func (c *cImMailboxConfig) Update(ctx context.Context, req *immailboxconfig.UpdateReq) (res *immailboxconfig.UpdateRes, err error) {
+	err = service.SysImMailboxConfig().Update(ctx, &req.ImMailboxConfigUpdateInp)
+	return
+}
@@ -0,0 +1,31 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imnotification"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImNotification = cImNotification{}
+
+type cImNotification struct{}
+
+func (c *cImNotification) TemplateList(ctx context.Context, req *imnotification.TemplateListReq) (res *imnotification.TemplateListRes, err error) {
+	list, totalCount, err := service.SysImNotification().TemplateList(ctx, &req.ImNotificationTemplateListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImNotificationTemplateListModel{}
+	}
+	res = new(imnotification.TemplateListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImNotification) TemplateUpdate(ctx context.Context, req *imnotification.TemplateUpdateReq) (res *imnotification.TemplateUpdateRes, err error) {
+	err = service.SysImNotification().TemplateUpdate(ctx, &req.ImNotificationTemplateUpdateInp)
+	return
+}
@@ -0,0 +1,79 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imorg"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImOrg = cImOrg{}
+
+type cImOrg struct{}
+
+func (c *cImOrg) DepartmentList(ctx context.Context, req *imorg.DepartmentListReq) (res *imorg.DepartmentListRes, err error) {
+	list, totalCount, err := service.SysImOrg().DepartmentList(ctx, &req.ImOrgDepartmentListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImOrgDepartmentModel{}
+	}
+	res = new(imorg.DepartmentListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImOrg) DepartmentEdit(ctx context.Context, req *imorg.DepartmentEditReq) (res *imorg.DepartmentEditRes, err error) {
+	err = service.SysImOrg().DepartmentEdit(ctx, &req.ImOrgDepartmentEditInp)
+	return
+}
+
+func (c *cImOrg) DepartmentExport(ctx context.Context, req *imorg.DepartmentExportReq) (res *imorg.DepartmentExportRes, err error) {
+	err = service.SysImOrg().DepartmentExport(ctx, &req.ImOrgDepartmentListInp)
+	return
+}
+
+func (c *cImOrg) DepartmentDelete(ctx context.Context, req *imorg.DepartmentDeleteReq) (res *imorg.DepartmentDeleteRes, err error) {
+	err = service.SysImOrg().DepartmentDelete(ctx, &req.ImOrgDepartmentDeleteInp)
+	return
+}
+
+func (c *cImOrg) MemberList(ctx context.Context, req *imorg.MemberListReq) (res *imorg.MemberListRes, err error) {
+	list, totalCount, err := service.SysImOrg().MemberList(ctx, &req.ImOrgMemberListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImOrgMemberModel{}
+	}
+	res = new(imorg.MemberListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImOrg) MemberEdit(ctx context.Context, req *imorg.MemberEditReq) (res *imorg.MemberEditRes, err error) {
+	err = service.SysImOrg().MemberEdit(ctx, &req.ImOrgMemberEditInp)
+	return
+}
+
+func (c *cImOrg) MemberExport(ctx context.Context, req *imorg.MemberExportReq) (res *imorg.MemberExportRes, err error) {
+	err = service.SysImOrg().MemberExport(ctx, &req.ImOrgMemberListInp)
+	return
+}
+
+func (c *cImOrg) MemberDelete(ctx context.Context, req *imorg.MemberDeleteReq) (res *imorg.MemberDeleteRes, err error) {
+	err = service.SysImOrg().MemberDelete(ctx, &req.ImOrgMemberDeleteInp)
+	return
+}
+
+func (c *cImOrg) Search(ctx context.Context, req *imorg.SearchReq) (res *imorg.SearchRes, err error) {
+	data, err := service.SysImOrg().Search(ctx, &req.ImOrgSearchInp)
+	if err != nil {
+		return
+	}
+	res = &imorg.SearchRes{ImOrgSearchModel: data}
+	return
+}
@@ -0,0 +1,55 @@
+// 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/api/admin/imoutbox"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var (
+	ImOutbox = cImOutbox{}
+)
+
+type cImOutbox struct{}
+
+func (c *cImOutbox) List(ctx context.Context, req *imoutbox.ListReq) (res *imoutbox.ListRes, err error) {
+	list, totalCount, err := service.SysImOutbox().List(ctx, &req.ImOutboxListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImOutboxListModel{}
+	}
+
+	res = new(imoutbox.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImOutbox) View(ctx context.Context, req *imoutbox.ViewReq) (res *imoutbox.ViewRes, err error) {
+	data, err := service.SysImOutbox().View(ctx, &req.ImOutboxViewInp)
+	if err != nil {
+		return
+	}
+
+	res = new(imoutbox.ViewRes)
+	res.ImOutboxViewModel = data
+	return
+}
+
+func (c *cImOutbox) Retry(ctx context.Context, req *imoutbox.RetryReq) (res *imoutbox.RetryRes, err error) {
+	err = service.SysImOutbox().Retry(ctx, &req.ImOutboxActionInp)
+	return
+}
+
+func (c *cImOutbox) Dead(ctx context.Context, req *imoutbox.DeadReq) (res *imoutbox.DeadRes, err error) {
+	err = service.SysImOutbox().Dead(ctx, &req.ImOutboxActionInp)
+	return
+}
@@ -0,0 +1,40 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imprivatemessage"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImPrivateMessage = cImPrivateMessage{}
+
+type cImPrivateMessage struct{}
+
+func (c *cImPrivateMessage) List(ctx context.Context, req *imprivatemessage.ListReq) (res *imprivatemessage.ListRes, err error) {
+	list, total, err := service.SysImPrivateMessage().List(ctx, &req.ImPrivateMessageListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImMessageListModel{}
+	}
+	res = &imprivatemessage.ListRes{List: list}
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImPrivateMessage) View(ctx context.Context, req *imprivatemessage.ViewReq) (*imprivatemessage.ViewRes, error) {
+	data, err := service.SysImPrivateMessage().View(ctx, &req.ImMessageViewInp)
+	return &imprivatemessage.ViewRes{ImMessageViewModel: data}, err
+}
+func (c *cImPrivateMessage) Hide(ctx context.Context, req *imprivatemessage.HideReq) (*imprivatemessage.HideRes, error) {
+	data, err := service.SysImPrivateMessage().Hide(ctx, &req.ImMessageActionInp)
+	return &imprivatemessage.HideRes{ImMessageCommandModel: data}, err
+}
+func (c *cImPrivateMessage) Delete(ctx context.Context, req *imprivatemessage.DeleteReq) (*imprivatemessage.DeleteRes, error) {
+	data, err := service.SysImPrivateMessage().Delete(ctx, &req.ImMessageActionInp)
+	return &imprivatemessage.DeleteRes{ImMessageCommandModel: data}, err
+}
+func (c *cImPrivateMessage) Export(ctx context.Context, req *imprivatemessage.ExportReq) (*imprivatemessage.ExportRes, error) {
+	return &imprivatemessage.ExportRes{}, service.SysImPrivateMessage().Export(ctx, &req.ImPrivateMessageListInp)
+}
@@ -0,0 +1,72 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imsecuritypolicy"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImSecurityPolicy = cImSecurityPolicy{}
+
+type cImSecurityPolicy struct{}
+
+func (c *cImSecurityPolicy) List(ctx context.Context, req *imsecuritypolicy.ListReq) (res *imsecuritypolicy.ListRes, err error) {
+	list, total, err := service.SysImSecurityPolicy().List(ctx, &req.ImSecurityPolicyListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImSecurityPolicyModel{}
+	}
+	res = new(imsecuritypolicy.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImSecurityPolicy) View(ctx context.Context, req *imsecuritypolicy.ViewReq) (res *imsecuritypolicy.ViewRes, err error) {
+	data, err := service.SysImSecurityPolicy().View(ctx, &req.ImSecurityPolicyViewInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imsecuritypolicy.ViewRes{ImSecurityPolicyModel: data}, nil
+}
+func (c *cImSecurityPolicy) Save(ctx context.Context, req *imsecuritypolicy.SaveReq) (res *imsecuritypolicy.SaveRes, err error) {
+	id, err := service.SysImSecurityPolicy().Save(ctx, &req.ImSecurityPolicySaveInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imsecuritypolicy.SaveRes{Id: id}, nil
+}
+func (c *cImSecurityPolicy) Publish(ctx context.Context, req *imsecuritypolicy.PublishReq) (res *imsecuritypolicy.PublishRes, err error) {
+	err = service.SysImSecurityPolicy().Publish(ctx, &req.ImSecurityPolicyPublishInp)
+	return
+}
+func (c *cImSecurityPolicy) RestoreDefault(ctx context.Context, req *imsecuritypolicy.RestoreDefaultReq) (res *imsecuritypolicy.RestoreDefaultRes, err error) {
+	id, err := service.SysImSecurityPolicy().RestoreDefault(ctx, &req.ImSecurityPolicyRestoreInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imsecuritypolicy.RestoreDefaultRes{Id: id}, nil
+}
+func (c *cImSecurityPolicy) IPRuleList(ctx context.Context, req *imsecuritypolicy.IPRuleListReq) (res *imsecuritypolicy.IPRuleListRes, err error) {
+	list, total, err := service.SysImSecurityPolicy().IPRuleList(ctx, &req.ImSecurityIPRuleListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImSecurityIPRuleModel{}
+	}
+	res = new(imsecuritypolicy.IPRuleListRes)
+	res.List = list
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImSecurityPolicy) IPRuleEdit(ctx context.Context, req *imsecuritypolicy.IPRuleEditReq) (res *imsecuritypolicy.IPRuleEditRes, err error) {
+	err = service.SysImSecurityPolicy().IPRuleEdit(ctx, &req.ImSecurityIPRuleEditInp)
+	return
+}
+func (c *cImSecurityPolicy) IPRuleDelete(ctx context.Context, req *imsecuritypolicy.IPRuleDeleteReq) (res *imsecuritypolicy.IPRuleDeleteRes, err error) {
+	err = service.SysImSecurityPolicy().IPRuleDelete(ctx, &req.ImSecurityIPRuleDeleteInp)
+	return
+}
@@ -0,0 +1,59 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imsensitiveword"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImSensitiveWord = cImSensitiveWord{}
+
+type cImSensitiveWord struct{}
+
+func (c *cImSensitiveWord) List(ctx context.Context, req *imsensitiveword.ListReq) (res *imsensitiveword.ListRes, err error) {
+	list, total, err := service.SysImSensitiveWord().List(ctx, &req.ImSensitiveWordListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImSensitiveWordListModel{}
+	}
+	res = new(imsensitiveword.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImSensitiveWord) Edit(ctx context.Context, req *imsensitiveword.EditReq) (res *imsensitiveword.EditRes, err error) {
+	err = service.SysImSensitiveWord().Edit(ctx, &req.ImSensitiveWordEditInp)
+	return
+}
+func (c *cImSensitiveWord) Delete(ctx context.Context, req *imsensitiveword.DeleteReq) (res *imsensitiveword.DeleteRes, err error) {
+	err = service.SysImSensitiveWord().Delete(ctx, &req.ImSensitiveWordDeleteInp)
+	return
+}
+func (c *cImSensitiveWord) Status(ctx context.Context, req *imsensitiveword.StatusReq) (res *imsensitiveword.StatusRes, err error) {
+	err = service.SysImSensitiveWord().Status(ctx, &req.ImSensitiveWordStatusInp)
+	return
+}
+func (c *cImSensitiveWord) BatchImport(ctx context.Context, req *imsensitiveword.BatchImportReq) (res *imsensitiveword.BatchImportRes, err error) {
+	data, err := service.SysImSensitiveWord().BatchImport(ctx, &req.ImSensitiveWordBatchImportInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imsensitiveword.BatchImportRes{ImSensitiveWordBatchImportModel: data}, nil
+}
+func (c *cImSensitiveWord) GroupList(ctx context.Context, req *imsensitiveword.GroupListReq) (res *imsensitiveword.GroupListRes, err error) {
+	list, err := service.SysImSensitiveWord().GroupList(ctx, &req.ImSensitiveWordGroupListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImSensitiveWordGroupModel{}
+	}
+	return &imsensitiveword.GroupListRes{List: list}, nil
+}
+func (c *cImSensitiveWord) GroupEdit(ctx context.Context, req *imsensitiveword.GroupEditReq) (res *imsensitiveword.GroupEditRes, err error) {
+	err = service.SysImSensitiveWord().GroupEdit(ctx, &req.ImSensitiveWordGroupEditInp)
+	return
+}
@@ -0,0 +1,26 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imtaskdashboard"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImTaskDashboard = cImTaskDashboard{}
+
+type cImTaskDashboard struct{}
+
+func (c *cImTaskDashboard) List(ctx context.Context, req *imtaskdashboard.ListReq) (res *imtaskdashboard.ListRes, err error) {
+	list, totalCount, err := service.SysImTaskDashboard().List(ctx, &req.ImTaskDashboardListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImTaskDashboardListModel{}
+	}
+	res = new(imtaskdashboard.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
@@ -58,3 +58,35 @@ func (c *cImTenant) Status(ctx context.Context, req *imtenant.StatusReq) (res *i
 	err = service.SysImTenant().Status(ctx, &req.ImTenantStatusInp)
 	return
 }
+
+func (c *cImTenant) Usage(ctx context.Context, req *imtenant.UsageReq) (res *imtenant.UsageRes, err error) {
+	data, err := service.SysImTenant().Usage(ctx, &req.ImTenantUsageInp)
+	if err != nil {
+		return
+	}
+
+	res = new(imtenant.UsageRes)
+	res.ImTenantUsageModel = data
+	return
+}
+
+func (c *cImTenant) DeletionCheck(ctx context.Context, req *imtenant.DeletionCheckReq) (res *imtenant.DeletionCheckRes, err error) {
+	data, err := service.SysImTenant().DeletionCheck(ctx, &req.ImTenantDeletionCheckInp)
+	if err != nil {
+		return
+	}
+
+	res = new(imtenant.DeletionCheckRes)
+	res.ImTenantDeletionCheckModel = data
+	return
+}
+
+func (c *cImTenant) EnterDeleting(ctx context.Context, req *imtenant.EnterDeletingReq) (res *imtenant.EnterDeletingRes, err error) {
+	err = service.SysImTenant().EnterDeleting(ctx, &req.ImTenantLifecycleInp)
+	return
+}
+
+func (c *cImTenant) Restore(ctx context.Context, req *imtenant.RestoreReq) (res *imtenant.RestoreRes, err error) {
+	err = service.SysImTenant().Restore(ctx, &req.ImTenantLifecycleInp)
+	return
+}
@@ -10,6 +10,8 @@ import (
 	"hotgo/api/admin/imuser"
 	"hotgo/internal/model/input/sysin"
 	"hotgo/internal/service"
+
+	"github.com/gogf/gf/v2/errors/gerror"
 )

 var (
@@ -18,6 +20,40 @@ var (

 type cImUser struct{}

+func (c *cImUser) Create(ctx context.Context, req *imuser.CreateReq) (res *imuser.CreateRes, err error) {
+	data, err := service.SysImUser().Create(ctx, &req.ImUserCreateInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imuser.CreateRes{ImUserCreateModel: data}, nil
+}
+
+func (c *cImUser) BatchCreate(ctx context.Context, req *imuser.BatchCreateReq) (res *imuser.BatchCreateRes, err error) {
+	data, err := service.SysImUser().BatchCreate(ctx, &req.ImUserBatchCreateInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imuser.BatchCreateRes{ImUserBatchCreateModel: data}, nil
+}
+
+func (c *cImUser) Import(ctx context.Context, req *imuser.ImportReq) (res *imuser.ImportRes, err error) {
+	file, err := req.File.Open()
+	if err != nil {
+		return nil, gerror.Wrap(err, "打开Excel文件失败")
+	}
+	defer file.Close()
+	data, err := service.SysImUser().ImportExcel(ctx, req.TenantId, req.GroupId, file)
+	if err != nil {
+		return nil, err
+	}
+	return &imuser.ImportRes{ImUserBatchCreateModel: data}, nil
+}
+
+func (c *cImUser) DownloadTemplate(ctx context.Context, req *imuser.DownloadTemplateReq) (res *imuser.DownloadTemplateRes, err error) {
+	err = service.SysImUser().DownloadTemplate(ctx)
+	return
+}
+
 // List 查看IM用户列表
 func (c *cImUser) List(ctx context.Context, req *imuser.ListReq) (res *imuser.ListRes, err error) {
 	list, totalCount, err := service.SysImUser().List(ctx, &req.ImUserListInp)
@@ -47,6 +83,60 @@ func (c *cImUser) View(ctx context.Context, req *imuser.ViewReq) (res *imuser.Vi
 	return
 }

+func (c *cImUser) ResetPassword(ctx context.Context, req *imuser.ResetPasswordReq) (res *imuser.ResetPasswordRes, err error) {
+	data, err := service.SysImUser().ResetPassword(ctx, &req.ImUserPasswordResetInp)
+	if err != nil {
+		return
+	}
+	res = new(imuser.ResetPasswordRes)
+	res.ImUserCommandModel = data
+	return
+}
+
+func (c *cImUser) RevokeSessions(ctx context.Context, req *imuser.RevokeSessionsReq) (res *imuser.RevokeSessionsRes, err error) {
+	err = service.SysImUser().RevokeSessions(ctx, &req.ImUserRevokeSessionsInp)
+	return
+}
+
+func (c *cImUser) Status(ctx context.Context, req *imuser.StatusReq) (res *imuser.StatusRes, err error) {
+	err = service.SysImUser().Status(ctx, &req.ImUserStatusInp)
+	return
+}
+
+func (c *cImUser) AdjustGroup(ctx context.Context, req *imuser.AdjustGroupReq) (res *imuser.AdjustGroupRes, err error) {
+	err = service.SysImUser().AdjustGroup(ctx, &req.ImUserAdjustGroupInp)
+	return
+}
+
+func (c *cImUser) IPWhitelist(ctx context.Context, req *imuser.IPWhitelistReq) (res *imuser.IPWhitelistRes, err error) {
+	data, err := service.SysImUser().IPWhitelist(ctx, &req.ImUserIPWhitelistInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imuser.IPWhitelistRes{ImUserIPWhitelistModel: data}, nil
+}
+
+func (c *cImUser) IPWhitelistSave(ctx context.Context, req *imuser.IPWhitelistSaveReq) (res *imuser.IPWhitelistSaveRes, err error) {
+	err = service.SysImUser().IPWhitelistSave(ctx, &req.ImUserIPWhitelistInp)
+	return
+}
+
+func (c *cImUser) Devices(ctx context.Context, req *imuser.DevicesReq) (res *imuser.DevicesRes, err error) {
+	list, totalCount, err := service.SysImUser().Devices(ctx, &req.ImUserDeviceListInp)
+	if err != nil {
+		return
+	}
+
+	if list == nil {
+		list = []*sysin.ImUserDeviceListModel{}
+	}
+
+	res = new(imuser.DevicesRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
 func (c *cImUser) Ban(ctx context.Context, req *imuser.BanReq) (res *imuser.BanRes, err error) {
 	data, err := service.SysImUser().Ban(ctx, &req.ImUserGovernanceInp)
 	if err != nil {
@@ -0,0 +1,28 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imuserloginhistory"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImUserLoginHistory = cImUserLoginHistory{}
+
+type cImUserLoginHistory struct{}
+
+func (c *cImUserLoginHistory) List(ctx context.Context, req *imuserloginhistory.ListReq) (res *imuserloginhistory.ListRes, err error) {
+	list, total, err := service.SysImUserLoginHistory().List(ctx, &req.ImUserLoginHistoryListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImUserLoginHistoryModel{}
+	}
+	res = &imuserloginhistory.ListRes{List: list}
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImUserLoginHistory) Export(ctx context.Context, req *imuserloginhistory.ExportReq) (*imuserloginhistory.ExportRes, error) {
+	return &imuserloginhistory.ExportRes{}, service.SysImUserLoginHistory().Export(ctx, &req.ImUserLoginHistoryListInp)
+}
@@ -0,0 +1,79 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imuserpolicygroup"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImUserPolicyGroup = cImUserPolicyGroup{}
+
+type cImUserPolicyGroup struct{}
+
+func (c *cImUserPolicyGroup) List(ctx context.Context, req *imuserpolicygroup.ListReq) (res *imuserpolicygroup.ListRes, err error) {
+	list, total, err := service.SysImUserPolicyGroup().List(ctx, &req.ImUserPolicyGroupListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImUserPolicyGroupListModel{}
+	}
+	res = new(imuserpolicygroup.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImUserPolicyGroup) View(ctx context.Context, req *imuserpolicygroup.ViewReq) (res *imuserpolicygroup.ViewRes, err error) {
+	data, err := service.SysImUserPolicyGroup().View(ctx, &req.ImUserPolicyGroupViewInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imuserpolicygroup.ViewRes{ImUserPolicyGroupViewModel: data}, nil
+}
+func (c *cImUserPolicyGroup) Edit(ctx context.Context, req *imuserpolicygroup.EditReq) (res *imuserpolicygroup.EditRes, err error) {
+	err = service.SysImUserPolicyGroup().Edit(ctx, &req.ImUserPolicyGroupEditInp)
+	return
+}
+func (c *cImUserPolicyGroup) Delete(ctx context.Context, req *imuserpolicygroup.DeleteReq) (res *imuserpolicygroup.DeleteRes, err error) {
+	err = service.SysImUserPolicyGroup().Delete(ctx, &req.ImUserPolicyGroupDeleteInp)
+	return
+}
+func (c *cImUserPolicyGroup) Status(ctx context.Context, req *imuserpolicygroup.StatusReq) (res *imuserpolicygroup.StatusRes, err error) {
+	err = service.SysImUserPolicyGroup().Status(ctx, &req.ImUserPolicyGroupStatusInp)
+	return
+}
+func (c *cImUserPolicyGroup) MemberList(ctx context.Context, req *imuserpolicygroup.MemberListReq) (res *imuserpolicygroup.MemberListRes, err error) {
+	list, total, err := service.SysImUserPolicyGroup().MemberList(ctx, &req.ImUserPolicyGroupMemberListInp)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*sysin.ImUserPolicyGroupMemberModel{}
+	}
+	res = new(imuserpolicygroup.MemberListRes)
+	res.List = list
+	res.PageRes.Pack(req, total)
+	return
+}
+func (c *cImUserPolicyGroup) MemberAdd(ctx context.Context, req *imuserpolicygroup.MemberAddReq) (res *imuserpolicygroup.MemberAddRes, err error) {
+	err = service.SysImUserPolicyGroup().MemberAdd(ctx, &req.ImUserPolicyGroupMemberAddInp)
+	return
+}
+func (c *cImUserPolicyGroup) MemberRemove(ctx context.Context, req *imuserpolicygroup.MemberRemoveReq) (res *imuserpolicygroup.MemberRemoveRes, err error) {
+	err = service.SysImUserPolicyGroup().MemberRemove(ctx, &req.ImUserPolicyGroupMemberRemoveInp)
+	return
+}
+
+func (c *cImUserPolicyGroup) LoginIPWhitelist(ctx context.Context, req *imuserpolicygroup.LoginIPWhitelistReq) (res *imuserpolicygroup.LoginIPWhitelistRes, err error) {
+	data, err := service.SysImUserPolicyGroup().LoginIPWhitelist(ctx, &req.ImTenantLoginIPWhitelistInp)
+	if err != nil {
+		return nil, err
+	}
+	return &imuserpolicygroup.LoginIPWhitelistRes{ImTenantLoginIPWhitelistModel: data}, nil
+}
+
+func (c *cImUserPolicyGroup) LoginIPWhitelistSave(ctx context.Context, req *imuserpolicygroup.LoginIPWhitelistSaveReq) (res *imuserpolicygroup.LoginIPWhitelistSaveRes, err error) {
+	err = service.SysImUserPolicyGroup().LoginIPWhitelistSave(ctx, &req.ImTenantLoginIPWhitelistSaveInp)
+	return
+}
@@ -0,0 +1,41 @@
+package sys
+
+import (
+	"context"
+	"hotgo/api/admin/imworkbench"
+	"hotgo/internal/model/input/sysin"
+	"hotgo/internal/service"
+)
+
+var ImWorkbench = cImWorkbench{}
+
+type cImWorkbench struct{}
+
+func (c *cImWorkbench) List(ctx context.Context, req *imworkbench.ListReq) (res *imworkbench.ListRes, err error) {
+	list, totalCount, err := service.SysImWorkbench().List(ctx, &req.ImWorkbenchAppListInp)
+	if err != nil {
+		return
+	}
+	if list == nil {
+		list = []*sysin.ImWorkbenchAppModel{}
+	}
+	res = new(imworkbench.ListRes)
+	res.List = list
+	res.PageRes.Pack(req, totalCount)
+	return
+}
+
+func (c *cImWorkbench) Edit(ctx context.Context, req *imworkbench.EditReq) (res *imworkbench.EditRes, err error) {
+	err = service.SysImWorkbench().Edit(ctx, &req.ImWorkbenchAppEditInp)
+	return
+}
+
+func (c *cImWorkbench) Delete(ctx context.Context, req *imworkbench.DeleteReq) (res *imworkbench.DeleteRes, err error) {
+	err = service.SysImWorkbench().Delete(ctx, &req.ImWorkbenchAppDeleteInp)
+	return
+}
+
+func (c *cImWorkbench) Reorder(ctx context.Context, req *imworkbench.ReorderReq) (res *imworkbench.ReorderRes, err error) {
+	err = service.SysImWorkbench().Reorder(ctx, &req.ImWorkbenchAppReorderInp)
+	return
+}
@@ -0,0 +1,69 @@
+package health
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"hotgo/internal/library/queue"
+)
+
+type response struct {
+	Status string            `json:"status"`
+	Checks map[string]string `json:"checks"`
+}
+
+// Serve exposes an unauthenticated dependency health endpoint for container probes.
+func Serve(r *ghttp.Request) {
+	if r.Method != http.MethodGet && r.Method != http.MethodHead {
+		r.Response.Header().Set("Allow", http.MethodGet+", "+http.MethodHead)
+		r.Response.WriteStatusExit(http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
+	defer cancel()
+	checks := map[string]string{}
+	statusCode := http.StatusOK
+
+	if err := g.DB().Ctx(ctx).Raw("SELECT 1").Scan(new(int)); err != nil {
+		checks["mysql"] = err.Error()
+		statusCode = http.StatusServiceUnavailable
+	} else {
+		checks["mysql"] = "ok"
+	}
+
+	if _, err := g.Redis().Do(ctx, "PING"); err != nil {
+		checks["redis"] = err.Error()
+		statusCode = http.StatusServiceUnavailable
+	} else {
+		checks["redis"] = "ok"
+	}
+
+	if strings.EqualFold(strings.TrimSpace(g.Cfg().MustGet(ctx, "queue.driver").String()), "kafka") {
+		if err := queue.KafkaHealthCheck(ctx); err != nil {
+			checks["kafka"] = err.Error()
+			statusCode = http.StatusServiceUnavailable
+		} else {
+			checks["kafka"] = "ok"
+		}
+	} else {
+		checks["kafka"] = "disabled"
+	}
+
+	body := response{Status: "ok", Checks: checks}
+	if statusCode != http.StatusOK {
+		body.Status = "error"
+	}
+	r.Response.Header().Set("Content-Type", "application/json; charset=utf-8")
+	r.Response.WriteHeader(statusCode)
+	if r.Method != http.MethodHead {
+		r.Response.WriteJsonExit(body)
+		return
+	}
+	r.Exit()
+}
@@ -6,10 +6,10 @@ import (
 	"hotgo/internal/dao"
 	"hotgo/internal/library/imtenant"
 	"hotgo/internal/model/entity"
+	"hotgo/internal/service"
 	"strings"

 	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/util/gconv"
 )
@@ -39,7 +39,7 @@ func (c *cConfig) TenantList(ctx context.Context, req *api.TenantListReq) (res *
 	if limit <= 0 || limit > 1000 {
 		limit = 1000
 	}
-	mod := imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Limit(limit)
+	mod := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Limit(limit)
 	if req.State != "" {
 		if req.State == "active" {
 			mod = mod.Where(dao.ImTenant.Columns().State, 1)
@@ -59,7 +59,7 @@ func (c *cConfig) TenantList(ctx context.Context, req *api.TenantListReq) (res *
 }

 func (c *cConfig) RegistrationSms(ctx context.Context, req *api.RegistrationSmsReq) (res *api.RegistrationSmsRes, err error) {
-	var record g.Map
+	var record *entity.SysConfig
 	if err = dao.SysConfig.Ctx(ctx).
 		Where(dao.SysConfig.Columns().Group, "im").
 		Where(dao.SysConfig.Columns().Key, "register_sms_enabled").
@@ -69,7 +69,7 @@ func (c *cConfig) RegistrationSms(ctx context.Context, req *api.RegistrationSmsR
 	}
 	enabled := true
 	if record != nil {
-		enabled = gconv.String(record[dao.SysConfig.Columns().Value]) != "0"
+		enabled = gconv.String(record.Value) != "0"
 	}
 	return &api.RegistrationSmsRes{Enabled: enabled}, nil
 }
@@ -91,9 +91,65 @@ func (c *cConfig) ThirdParty(ctx context.Context, req *api.ThirdPartyReq) (res *
 	return &api.ThirdPartyRes{Values: values}, nil
 }

+func (c *cConfig) TenantLoginIPWhitelist(ctx context.Context, req *api.TenantLoginIPWhitelistReq) (res *api.TenantLoginIPWhitelistRes, err error) {
+	if _, err = getTenant(ctx, dao.ImTenant.Columns().Id, req.Id); err != nil {
+		return nil, err
+	}
+	data, err := service.SysImUserPolicyGroup().LoginIPWhitelistByTenant(ctx, req.Id)
+	if err != nil {
+		return nil, err
+	}
+	return &api.TenantLoginIPWhitelistRes{TenantId: data.TenantId, AppList: data.AppList, WebList: data.WebList}, nil
+}
+
+func (c *cConfig) AppReleaseLatest(ctx context.Context, req *api.AppReleaseLatestReq) (res *api.AppReleaseLatestRes, err error) {
+	platform := strings.ToLower(strings.TrimSpace(req.Platform))
+	channel := strings.ToLower(strings.TrimSpace(req.Channel))
+	if platform != "ios" && platform != "android" {
+		return nil, gerror.New("客户端平台不合法")
+	}
+	if channel == "" {
+		channel = "stable"
+	}
+	if strings.ContainsAny(channel, " \t\r\n/") || len(channel) > 32 {
+		return nil, gerror.New("客户端渠道不合法")
+	}
+	var row struct {
+		ID                  int64       `json:"id"`
+		Platform            string      `json:"platform"`
+		Channel             string      `json:"channel"`
+		LatestVersion       string      `json:"latest_version"`
+		MinSupportedVersion string      `json:"min_supported_version"`
+		UpdateType          string      `json:"update_type"`
+		ReleaseNotes        string      `json:"release_notes"`
+		StoreURL            string      `json:"store_url"`
+		PackageURL          string      `json:"package_url"`
+		Checksum            string      `json:"checksum"`
+		RemindAfterSeconds  int         `json:"remind_after_seconds"`
+		PublishedAt         *gtime.Time `json:"published_at"`
+		CreatedAt           *gtime.Time `json:"created_at"`
+		UpdatedAt           *gtime.Time `json:"updated_at"`
+	}
+	err = imtenant.RegistryDB().Model("im_app_releases").Safe().Ctx(ctx).
+		Where("platform", platform).Where("channel", channel).Limit(1).Scan(&row)
+	if err != nil {
+		return nil, gerror.Wrap(err, "获取IM客户端版本策略失败")
+	}
+	if row.ID <= 0 {
+		return nil, gerror.New("IM客户端版本策略不存在")
+	}
+	return &api.AppReleaseLatestRes{
+		ID: row.ID, Platform: row.Platform, Channel: row.Channel,
+		LatestVersion: row.LatestVersion, MinSupportedVersion: row.MinSupportedVersion,
+		UpdateType: row.UpdateType, ReleaseNotes: row.ReleaseNotes, StoreURL: row.StoreURL,
+		PackageURL: row.PackageURL, Checksum: row.Checksum, RemindAfterSeconds: row.RemindAfterSeconds,
+		PublishedAt: gtimeToRFC3339(row.PublishedAt), CreatedAt: gtimeToRFC3339(row.CreatedAt), UpdatedAt: gtimeToRFC3339(row.UpdatedAt),
+	}, nil
+}
+
 func getTenant(ctx context.Context, field string, value any) (*entity.ImTenant, error) {
 	var tenant *entity.ImTenant
-	if err := imtenant.RegistryDB(ctx).Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Where(field, value).Scan(&tenant); err != nil {
+	if err := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Where(field, value).Scan(&tenant); err != nil {
 		return nil, gerror.Wrap(err, "获取IM租户配置失败")
 	}
 	if tenant == nil || tenant.Id <= 0 {