564 lines
22 KiB
Go
564 lines
22 KiB
Go
package imconfig
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
api "hotgo/api/admin/imconfiginternal"
|
|
"hotgo/internal/consts"
|
|
"hotgo/internal/dao"
|
|
"hotgo/internal/library/immoderation"
|
|
"hotgo/internal/library/imtenant"
|
|
"hotgo/internal/model/entity"
|
|
"hotgo/internal/model/input/sysin"
|
|
"hotgo/internal/service"
|
|
"strings"
|
|
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"github.com/gogf/gf/v2/util/gconv"
|
|
)
|
|
|
|
const defaultModerationTenantCode = "default"
|
|
|
|
var defaultModerationScenes = map[string]bool{
|
|
"user_nickname": true, "user_signature": true, "group_name": true,
|
|
"group_nickname": true, "private_message": true, "group_message": true,
|
|
"group_announcement": true,
|
|
}
|
|
|
|
var defaultModerationRiskActions = map[string]string{
|
|
"high": "block", "medium": "block", "low": "audit_only", "none": "allow",
|
|
}
|
|
|
|
var Config = cConfig{}
|
|
|
|
type cConfig struct{}
|
|
|
|
func (c *cConfig) Tenant(ctx context.Context, req *api.TenantReq) (res *api.TenantRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, req.Code)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &api.TenantRes{TenantModel: tenantToModel(tenant)}, nil
|
|
}
|
|
|
|
func (c *cConfig) TenantByID(ctx context.Context, req *api.TenantByIDReq) (res *api.TenantRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Id, req.Id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &api.TenantRes{TenantModel: tenantToModel(tenant)}, nil
|
|
}
|
|
|
|
func (c *cConfig) TenantList(ctx context.Context, req *api.TenantListReq) (res *api.TenantListRes, err error) {
|
|
limit := req.Limit
|
|
if limit <= 0 || limit > 1000 {
|
|
limit = 1000
|
|
}
|
|
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)
|
|
} else {
|
|
mod = mod.Where(dao.ImTenant.Columns().State, req.State)
|
|
}
|
|
}
|
|
var tenants []*entity.ImTenant
|
|
if err = mod.OrderAsc(dao.ImTenant.Columns().Id).Scan(&tenants); err != nil {
|
|
return nil, gerror.Wrap(err, "获取IM租户配置失败")
|
|
}
|
|
res = &api.TenantListRes{Items: make([]*api.TenantModel, 0, len(tenants))}
|
|
for _, tenant := range tenants {
|
|
res.Items = append(res.Items, tenantToModel(tenant))
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) RegistrationSms(ctx context.Context, req *api.RegistrationSmsReq) (res *api.RegistrationSmsRes, err error) {
|
|
var record *entity.SysConfig
|
|
if err = dao.SysConfig.Ctx(ctx).
|
|
Where(dao.SysConfig.Columns().Group, "im").
|
|
Where(dao.SysConfig.Columns().Key, "register_sms_enabled").
|
|
Where(dao.SysConfig.Columns().Status, 1).
|
|
Scan(&record); err != nil {
|
|
return nil, gerror.Wrap(err, "获取IM注册短信配置失败")
|
|
}
|
|
enabled := true
|
|
if record != nil {
|
|
enabled = gconv.String(record.Value) != "0"
|
|
}
|
|
return &api.RegistrationSmsRes{Enabled: enabled}, nil
|
|
}
|
|
|
|
func (c *cConfig) ThirdParty(ctx context.Context, req *api.ThirdPartyReq) (res *api.ThirdPartyRes, err error) {
|
|
values := map[string]string{}
|
|
keys := splitKeys(req.Keys)
|
|
mod := dao.SysConfig.Ctx(ctx).Where(dao.SysConfig.Columns().Group, req.Group).Where(dao.SysConfig.Columns().Status, 1)
|
|
if len(keys) > 0 {
|
|
mod = mod.WhereIn(dao.SysConfig.Columns().Key, keys)
|
|
}
|
|
var rows []*entity.SysConfig
|
|
if err = mod.Scan(&rows); err != nil {
|
|
return nil, gerror.Wrap(err, "获取IM第三方配置失败")
|
|
}
|
|
for _, row := range rows {
|
|
values[row.Key] = row.Value
|
|
}
|
|
return &api.ThirdPartyRes{Values: values}, nil
|
|
}
|
|
|
|
func (c *cConfig) Dictionary(ctx context.Context, req *api.DictionaryReq) (res *api.DictionaryRes, err error) {
|
|
dictType := strings.TrimSpace(req.Type)
|
|
if dictType == "" || dictType == consts.ImInternalSecretDictType {
|
|
return nil, gerror.New("字典类型不合法")
|
|
}
|
|
var rows []*entity.SysDictData
|
|
if err = dao.SysDictData.Ctx(ctx).
|
|
Where(dao.SysDictData.Columns().Type, dictType).
|
|
Where(dao.SysDictData.Columns().Status, consts.StatusEnabled).
|
|
Order(dao.SysDictData.Columns().Sort + " asc, " + dao.SysDictData.Columns().Id + " desc").
|
|
Scan(&rows); err != nil {
|
|
return nil, gerror.Wrap(err, "获取IM字典配置失败")
|
|
}
|
|
res = &api.DictionaryRes{Items: make([]*api.DictionaryItemModel, 0, len(rows))}
|
|
for _, row := range rows {
|
|
res.Items = append(res.Items, &api.DictionaryItemModel{
|
|
Label: row.Label,
|
|
Value: row.Value,
|
|
Sort: row.Sort,
|
|
})
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) ModerationProvider(ctx context.Context, req *api.ModerationProviderReq) (res *api.ModerationProviderRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, defaultModerationTenantCode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var row struct {
|
|
Provider string `json:"provider"`
|
|
Enabled int `json:"enabled"`
|
|
ConfigJSON string `json:"config_json"`
|
|
}
|
|
record, err := imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
|
|
Fields("provider", "enabled", "CAST(config_json AS CHAR) config_json").
|
|
Where("tenant_id", tenant.Id).Where("service", consts.ImExternalServiceModeration).One()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取内容审核服务配置失败")
|
|
}
|
|
if !record.IsEmpty() {
|
|
if err = record.Struct(&row); err != nil {
|
|
return nil, gerror.Wrap(err, "解析内容审核服务配置失败")
|
|
}
|
|
}
|
|
globalConfig, err := immoderation.LoadAliyunGlobalConfig(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
config := map[string]any{}
|
|
_ = json.Unmarshal([]byte(row.ConfigJSON), &config)
|
|
res = &api.ModerationProviderRes{
|
|
Provider: stringValue(map[string]any{"provider": row.Provider}, "provider", "aliyun_green"),
|
|
Endpoint: globalConfig.Endpoint, Enabled: row.Enabled == 1,
|
|
RegionID: globalConfig.RegionID,
|
|
NicknameService: stringValue(config, "nickname_service", "nickname_detection_pro"),
|
|
ChatService: stringValue(config, "chat_service", "chat_detection_pro"),
|
|
TimeoutMS: intValue(config, "timeout_ms", 1500),
|
|
FailureMode: moderationFailureMode(stringValue(config, "failure_mode", "allow")),
|
|
AccessKeyID: globalConfig.AccessKeyID,
|
|
AccessKeySecret: globalConfig.AccessKeySecret,
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) ModerationPolicy(ctx context.Context, req *api.ModerationPolicyReq) (res *api.ModerationPolicyRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, strings.TrimSpace(req.Code))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res = defaultModerationPolicy(tenant)
|
|
res.AliyunEnabled = tenant.AliyunModerationEnabled == 1
|
|
res.LocalWordsEnabled = tenant.LocalModerationEnabled == 1
|
|
res.Enabled = res.AliyunEnabled || res.LocalWordsEnabled
|
|
columns := dao.ImSecurityPolicy.Columns()
|
|
var row struct {
|
|
PolicyVersion uint `json:"policy_version"`
|
|
SensitiveWordPolicy string `json:"sensitive_word_policy"`
|
|
}
|
|
record, err := imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).
|
|
Fields(columns.PolicyVersion, "CAST("+columns.SensitiveWordPolicy+" AS CHAR) sensitive_word_policy").
|
|
Where(columns.TenantId, tenant.Id).Where(columns.PublishStatus, consts.ImSecurityPublishPublished).
|
|
WhereNull(columns.DeletedAt).OrderDesc(columns.PolicyVersion).One()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取商户内容审核策略失败")
|
|
}
|
|
if record.IsEmpty() {
|
|
return res, nil
|
|
}
|
|
if err = record.Struct(&row); err != nil {
|
|
return nil, gerror.Wrap(err, "解析商户内容审核策略失败")
|
|
}
|
|
if row.PolicyVersion == 0 || strings.TrimSpace(row.SensitiveWordPolicy) == "" {
|
|
return res, nil
|
|
}
|
|
var policy struct {
|
|
Scenes map[string]bool `json:"scenes"`
|
|
RiskActions map[string]string `json:"risk_actions"`
|
|
FailureMode string `json:"failure_mode"`
|
|
BlockMessage string `json:"block_message"`
|
|
}
|
|
if err = json.Unmarshal([]byte(row.SensitiveWordPolicy), &policy); err != nil {
|
|
return nil, gerror.Wrap(err, "商户内容审核策略格式错误")
|
|
}
|
|
res.PolicyVersion = row.PolicyVersion
|
|
for scene, enabled := range policy.Scenes {
|
|
res.Scenes[scene] = enabled
|
|
}
|
|
for risk, action := range policy.RiskActions {
|
|
if action == "allow" || action == "block" || action == "audit_only" {
|
|
res.RiskActions[risk] = action
|
|
}
|
|
}
|
|
res.FailureMode = moderationFailureMode(policy.FailureMode)
|
|
if strings.TrimSpace(policy.BlockMessage) != "" {
|
|
res.BlockMessage = strings.TrimSpace(policy.BlockMessage)
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) SecurityPolicy(ctx context.Context, req *api.SecurityPolicyReq) (res *api.SecurityPolicyRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, strings.TrimSpace(req.Code))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res = &api.SecurityPolicyRes{
|
|
TenantID: tenant.Id,
|
|
TenantCode: tenant.Code,
|
|
GlobalFriendEnabled: true,
|
|
FriendDisabledPolicy: map[string]interface{}{},
|
|
MessageCurfewEnabled: false,
|
|
CurfewRules: []*api.SecurityCurfewRuleRes{},
|
|
}
|
|
columns := dao.ImSecurityPolicy.Columns()
|
|
record, err := imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).
|
|
Fields(columns.Id, columns.PolicyVersion, columns.GlobalFriendEnabled, columns.MessageCurfewEnabled, "CAST("+columns.LoginRateLimit+" AS CHAR) login_rate_limit", "CAST("+columns.FriendDisabledPolicy+" AS CHAR) friend_disabled_policy").
|
|
Where(columns.TenantId, tenant.Id).Where(columns.PublishStatus, consts.ImSecurityPublishPublished).
|
|
WhereNull(columns.DeletedAt).OrderDesc(columns.PolicyVersion).One()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取商户安全策略失败")
|
|
}
|
|
if record.IsEmpty() {
|
|
return res, nil
|
|
}
|
|
policyID := record[columns.Id].Int64()
|
|
res.PolicyVersion = record[columns.PolicyVersion].Uint()
|
|
res.GlobalFriendEnabled = record[columns.GlobalFriendEnabled].Int() == 1
|
|
res.MessageCurfewEnabled = record[columns.MessageCurfewEnabled].Int() == 1
|
|
if raw := strings.TrimSpace(record["login_rate_limit"].String()); raw != "" && raw != "null" {
|
|
var limit struct {
|
|
Enabled bool `json:"enabled"`
|
|
PasswordMaxAttempts int `json:"password_max_attempts"`
|
|
LockSeconds int `json:"lock_seconds"`
|
|
WindowSeconds int `json:"window_seconds"`
|
|
}
|
|
if json.Unmarshal([]byte(raw), &limit) == nil && limit.Enabled {
|
|
res.LoginRateLimit = &api.SecurityLoginRateLimitRes{
|
|
Enabled: true,
|
|
PasswordMaxAttempts: limit.PasswordMaxAttempts,
|
|
LockSeconds: limit.LockSeconds,
|
|
WindowSeconds: limit.WindowSeconds,
|
|
}
|
|
}
|
|
}
|
|
if raw := strings.TrimSpace(record["friend_disabled_policy"].String()); raw != "" && raw != "null" {
|
|
_ = json.Unmarshal([]byte(raw), &res.FriendDisabledPolicy)
|
|
}
|
|
ruleColumns := dao.ImMessageCurfewRules.Columns()
|
|
var rows []struct {
|
|
RuleCode string `json:"rule_code"`
|
|
RuleName string `json:"rule_name"`
|
|
DateType string `json:"date_type"`
|
|
CustomDates string `json:"custom_dates"`
|
|
Weekdays string `json:"weekdays"`
|
|
Timezone string `json:"timezone"`
|
|
StartTime string `json:"start_time"`
|
|
EndTime string `json:"end_time"`
|
|
Scope string `json:"scope"`
|
|
WhitelistUserIds string `json:"whitelist_user_ids"`
|
|
WhitelistGroupIds string `json:"whitelist_group_ids"`
|
|
Message string `json:"message"`
|
|
Status int `json:"status"`
|
|
Sort int `json:"sort"`
|
|
}
|
|
if err = imtenant.RegistryDB().Model(dao.ImMessageCurfewRules.Table()).Safe().Ctx(ctx).
|
|
Fields(ruleColumns.RuleCode, ruleColumns.RuleName, ruleColumns.DateType, "CAST("+ruleColumns.CustomDates+" AS CHAR) custom_dates", "CAST("+ruleColumns.Weekdays+" AS CHAR) weekdays", ruleColumns.Timezone, "TIME_FORMAT("+ruleColumns.StartTime+",'%H:%i') start_time", "TIME_FORMAT("+ruleColumns.EndTime+",'%H:%i') end_time", ruleColumns.Scope, "CAST("+ruleColumns.WhitelistUserIds+" AS CHAR) whitelist_user_ids", "CAST("+ruleColumns.WhitelistGroupIds+" AS CHAR) whitelist_group_ids", ruleColumns.Message, ruleColumns.Status, ruleColumns.Sort).
|
|
Where(ruleColumns.PolicyId, policyID).Where(ruleColumns.Status, consts.StatusEnabled).
|
|
WhereNull(ruleColumns.DeletedAt).OrderAsc(ruleColumns.Sort).OrderAsc(ruleColumns.Id).Scan(&rows); err != nil {
|
|
return nil, gerror.Wrap(err, "获取商户宵禁规则失败")
|
|
}
|
|
for _, row := range rows {
|
|
res.CurfewRules = append(res.CurfewRules, &api.SecurityCurfewRuleRes{
|
|
RuleCode: row.RuleCode,
|
|
RuleName: row.RuleName,
|
|
DateType: row.DateType,
|
|
CustomDates: parseStringArray(row.CustomDates),
|
|
Weekdays: parseIntArray(row.Weekdays),
|
|
Timezone: row.Timezone,
|
|
StartTime: row.StartTime,
|
|
EndTime: row.EndTime,
|
|
Scope: row.Scope,
|
|
WhitelistUserIds: parseStringArray(row.WhitelistUserIds),
|
|
WhitelistGroupIds: parseStringArray(row.WhitelistGroupIds),
|
|
Message: row.Message,
|
|
Status: row.Status,
|
|
Sort: row.Sort,
|
|
})
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) RealnamePolicy(ctx context.Context, req *api.RealnamePolicyReq) (res *api.RealnamePolicyRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Id, req.Id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res = defaultRealnamePolicy(tenant.Id)
|
|
if tenant.RealnameReviewPolicy == 1 {
|
|
res.RealnameReviewPolicy = 1
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func parseStringArray(raw string) []string {
|
|
values := []string{}
|
|
if strings.TrimSpace(raw) == "" {
|
|
return values
|
|
}
|
|
_ = json.Unmarshal([]byte(raw), &values)
|
|
return values
|
|
}
|
|
|
|
func parseIntArray(raw string) []int {
|
|
values := []int{}
|
|
if strings.TrimSpace(raw) == "" {
|
|
return values
|
|
}
|
|
_ = json.Unmarshal([]byte(raw), &values)
|
|
return values
|
|
}
|
|
|
|
func (c *cConfig) SensitiveWords(ctx context.Context, req *api.SensitiveWordsReq) (res *api.SensitiveWordsRes, err error) {
|
|
tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, strings.TrimSpace(req.Code))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res = &api.SensitiveWordsRes{TenantID: tenant.Id, TenantCode: tenant.Code, Items: []*api.SensitiveWordModel{}}
|
|
columns := dao.ImSensitiveWords.Columns()
|
|
groupColumns := dao.ImSensitiveWordGroups.Columns()
|
|
var rows []struct {
|
|
ID int64 `json:"id"`
|
|
Word string `json:"word"`
|
|
MatchType string `json:"match_type"`
|
|
SceneJSON string `json:"scene_json"`
|
|
Action string `json:"action"`
|
|
Replacement string `json:"replacement"`
|
|
RiskLevel string `json:"risk_level"`
|
|
Priority int `json:"priority"`
|
|
UpdatedAt *gtime.Time `json:"updated_at"`
|
|
}
|
|
err = imtenant.RegistryDB().Model(dao.ImSensitiveWords.Table()+" w").Safe().Ctx(ctx).
|
|
LeftJoin(dao.ImSensitiveWordGroups.Table()+" g", "g."+groupColumns.Id+"=w."+columns.GroupId).
|
|
Fields("w."+columns.Id, "w."+columns.Word, "w."+columns.MatchType, "CAST(w."+columns.SceneJson+" AS CHAR) scene_json", "w."+columns.Action, "w."+columns.Replacement, "w."+columns.RiskLevel, "w."+columns.Priority, "w."+columns.UpdatedAt).
|
|
Where("w."+columns.TenantId, tenant.Id).Where("w."+columns.Status, consts.StatusEnabled).WhereNull("w."+columns.DeletedAt).
|
|
Where("g."+groupColumns.Status, consts.StatusEnabled).WhereNull("g." + groupColumns.DeletedAt).
|
|
OrderDesc("w." + columns.Priority).OrderAsc("w." + columns.Id).Scan(&rows)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "获取商户有效敏感词失败")
|
|
}
|
|
for _, row := range rows {
|
|
var scenes []string
|
|
_ = json.Unmarshal([]byte(row.SceneJSON), &scenes)
|
|
res.Items = append(res.Items, &api.SensitiveWordModel{ID: row.ID, Word: row.Word, MatchType: row.MatchType, Scenes: scenes, Action: row.Action, Replacement: row.Replacement, RiskLevel: row.RiskLevel, Priority: row.Priority})
|
|
if row.UpdatedAt != nil && row.UpdatedAt.TimestampMilli() > res.Version {
|
|
res.Version = row.UpdatedAt.TimestampMilli()
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (c *cConfig) MessageKeyActive(ctx context.Context, req *api.MessageKeyActiveReq) (res *api.MessageKeyActiveRes, err error) {
|
|
key, err := service.SysImMessageEncryption().GetKey(ctx, &sysin.ImMessageKeyGetInp{TenantCode: req.TenantCode})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &api.MessageKeyActiveRes{ImMessageKeyModel: key}, nil
|
|
}
|
|
|
|
func (c *cConfig) MessageKeyVersion(ctx context.Context, req *api.MessageKeyVersionReq) (res *api.MessageKeyVersionRes, err error) {
|
|
key, err := service.SysImMessageEncryption().GetKey(ctx, &sysin.ImMessageKeyGetInp{TenantCode: req.TenantCode, Version: req.Version})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &api.MessageKeyVersionRes{ImMessageKeyModel: key}, nil
|
|
}
|
|
|
|
func (c *cConfig) MessageKeyAck(ctx context.Context, req *api.MessageKeyAckReq) (res *api.MessageKeyAckRes, err error) {
|
|
err = service.SysImMessageEncryption().Ack(ctx, &sysin.ImMessageKeyAckInp{TenantCode: req.TenantCode, Version: req.Version})
|
|
return
|
|
}
|
|
|
|
func defaultModerationPolicy(tenant *entity.ImTenant) *api.ModerationPolicyRes {
|
|
return &api.ModerationPolicyRes{TenantID: tenant.Id, TenantCode: tenant.Code, Enabled: false,
|
|
AliyunEnabled: false, LocalWordsEnabled: false, Scenes: cloneBoolMap(defaultModerationScenes),
|
|
RiskActions: cloneStringMap(defaultModerationRiskActions), FailureMode: "allow",
|
|
BlockMessage: "内容不符合平台规范，请修改后重试"}
|
|
}
|
|
|
|
func defaultRealnamePolicy(tenantID int64) *api.RealnamePolicyRes {
|
|
return &api.RealnamePolicyRes{
|
|
TenantID: tenantID,
|
|
RealnameReviewPolicy: 0,
|
|
}
|
|
}
|
|
|
|
func cloneBoolMap(src map[string]bool) map[string]bool {
|
|
dst := make(map[string]bool, len(src))
|
|
for k, v := range src {
|
|
dst[k] = v
|
|
}
|
|
return dst
|
|
}
|
|
func cloneStringMap(src map[string]string) map[string]string {
|
|
dst := make(map[string]string, len(src))
|
|
for k, v := range src {
|
|
dst[k] = v
|
|
}
|
|
return dst
|
|
}
|
|
func stringValue(values map[string]any, key, fallback string) string {
|
|
if value, ok := values[key].(string); ok && strings.TrimSpace(value) != "" {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
return fallback
|
|
}
|
|
func intValue(values map[string]any, key string, fallback int) int {
|
|
value := gconv.Int(values[key])
|
|
if value <= 0 {
|
|
return fallback
|
|
}
|
|
return value
|
|
}
|
|
func moderationFailureMode(value string) string {
|
|
if strings.TrimSpace(value) == "block" {
|
|
return "block"
|
|
}
|
|
return "allow"
|
|
}
|
|
|
|
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().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 {
|
|
return nil, gerror.New("IM租户不存在")
|
|
}
|
|
return tenant, nil
|
|
}
|
|
|
|
func tenantToModel(tenant *entity.ImTenant) *api.TenantModel {
|
|
if tenant == nil {
|
|
return nil
|
|
}
|
|
desc := tenant.TenantDesc
|
|
return &api.TenantModel{
|
|
ID: tenant.Id,
|
|
Code: tenant.Code,
|
|
Name: tenant.Name,
|
|
TenantDesc: &desc,
|
|
State: tenant.State,
|
|
CreatedAt: gtimeToRFC3339(tenant.CreatedAt),
|
|
CreatedBy: tenant.CreatedBy,
|
|
UpdatedAt: gtimeToRFC3339(tenant.UpdatedAt),
|
|
UpdatedBy: tenant.UpdatedBy,
|
|
}
|
|
}
|
|
|
|
func gtimeToRFC3339(t *gtime.Time) string {
|
|
if t == nil {
|
|
return ""
|
|
}
|
|
return t.Time.Format("2006-01-02T15:04:05Z07:00")
|
|
}
|
|
|
|
func splitKeys(raw string) []string {
|
|
if raw == "" {
|
|
return nil
|
|
}
|
|
parts := strings.Split(raw, ",")
|
|
keys := make([]string, 0, len(parts))
|
|
for _, part := range parts {
|
|
if part = strings.TrimSpace(part); part != "" {
|
|
keys = append(keys, part)
|
|
}
|
|
}
|
|
return keys
|
|
}
|