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

feat: add IM admin P2 configuration modules

Browse Source
This commit is contained in:
richjohnrambo
2026-08-22 00:36:38 +08:00
parent 5c3f6ae58d
commit d53b0c1b62
49 changed files with 3574 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/logic/sys/im_abuse_reason.go
+166
View File
@@ -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_app_release.go
+150
View File
@@ -0,0 +1,150 @@
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 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, 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.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
}
for _, item := range list {
item.TenantId = tenant.Id
item.TenantName = tenant.Name
}
return
}
func (s *sSysImAppRelease) Edit(ctx context.Context, in *sysin.ImAppReleaseEditInp) (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{
"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, tenant.Id, action, "im_app_release", targetId, "success", g.Map{
"platform": in.Platform, "channel": in.Channel, "update_type": in.UpdateType,
})
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_feedback_config.go
+112
View File
@@ -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_mailbox_config.go
+121
View File
@@ -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_workbench.go
+194
View File
@@ -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
}