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