sugarBecomer
325 lines
10 KiB
Go
325 lines
10 KiB
Go
package config
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
v1 "likedream-goframe/internal/api/v1"
|
|
cst2 "likedream-goframe/internal/common/cst"
|
|
"likedream-goframe/internal/common/db"
|
|
errors2 "likedream-goframe/internal/common/errors"
|
|
"likedream-goframe/internal/ent"
|
|
"likedream-goframe/internal/ent/sysconfig"
|
|
mailservice "likedream-goframe/internal/service/email"
|
|
"likedream-goframe/internal/utils"
|
|
)
|
|
|
|
type ConfigServiceV1 struct{}
|
|
|
|
func NewV1() *ConfigServiceV1 {
|
|
return &ConfigServiceV1{}
|
|
}
|
|
|
|
func (s *ConfigServiceV1) Get(ctx context.Context, req *v1.ConfigGetReq) *utils.Response[*ent.SysConfig] {
|
|
config, err := db.Global.SysConfig.Query().
|
|
Where(sysconfig.KeyEQ(req.Key)).
|
|
Only(ctx)
|
|
if err != nil {
|
|
if ent.IsNotFound(err) {
|
|
utils.OkOrPanic(errors2.NewBusinessError(404, "配置不存在"))
|
|
}
|
|
utils.OkOrPanic(err)
|
|
}
|
|
return utils.SuccessWithData[*ent.SysConfig](config)
|
|
}
|
|
|
|
func (s *ConfigServiceV1) PublicGet(ctx context.Context, req *v1.ConfigPublicGetReq) *utils.Response[*ent.SysConfig] {
|
|
allowedKeys := []string{"system.announcement", "system.allowRegister", "system.requireInviteCode"}
|
|
|
|
allowed := false
|
|
for _, key := range allowedKeys {
|
|
if req.Key == key {
|
|
allowed = true
|
|
break
|
|
}
|
|
}
|
|
if !allowed {
|
|
utils.OkOrPanic(errors2.NewBusinessError(403, "该配置不允许公开访问"))
|
|
}
|
|
|
|
config, err := db.Global.SysConfig.Query().
|
|
Where(sysconfig.KeyEQ(req.Key)).
|
|
Only(ctx)
|
|
if err != nil {
|
|
if ent.IsNotFound(err) {
|
|
return utils.SuccessWithData[*ent.SysConfig](nil)
|
|
}
|
|
utils.OkOrPanic(err)
|
|
}
|
|
|
|
return utils.SuccessWithData[*ent.SysConfig](config)
|
|
}
|
|
|
|
func (s *ConfigServiceV1) List(ctx context.Context, req *v1.ConfigListReq) *utils.Response[[]*ent.SysConfig] {
|
|
query := db.Global.SysConfig.Query().
|
|
Order(ent.Asc(sysconfig.FieldKey))
|
|
|
|
if req.Key != "" {
|
|
query.Where(sysconfig.KeyContains(req.Key))
|
|
}
|
|
|
|
total := query.CountX(ctx)
|
|
var data []*ent.SysConfig
|
|
if total > 0 {
|
|
query.Limit(req.Size).Offset((req.Page - 1) * req.Size)
|
|
data = query.AllX(ctx)
|
|
}
|
|
return utils.SuccessWithTotal[[]*ent.SysConfig](data, total)
|
|
}
|
|
|
|
func (s *ConfigServiceV1) Update(ctx context.Context, req *v1.ConfigUpdateReq) *utils.Response[any] {
|
|
config, err := db.Global.SysConfig.Query().
|
|
Where(sysconfig.KeyEQ(req.Key)).
|
|
Only(ctx)
|
|
if err != nil {
|
|
if ent.IsNotFound(err) {
|
|
db.Global.SysConfig.Create().
|
|
SetKey(req.Key).
|
|
SetValue(req.Value).
|
|
SetDescription(req.Description).
|
|
SetType("markdown").
|
|
SaveX(ctx)
|
|
return utils.SuccessWithMsg("配置创建成功")
|
|
}
|
|
utils.OkOrPanic(err)
|
|
}
|
|
|
|
db.Global.SysConfig.UpdateOne(config).
|
|
SetValue(req.Value).
|
|
SetDescription(req.Description).
|
|
ExecX(ctx)
|
|
return utils.SuccessWithMsg("配置更新成功")
|
|
}
|
|
|
|
const (
|
|
PriceKeyCpdailyTask = "price.cpdaily_task"
|
|
PriceKeyCpdailyLeave = "price.cpdaily_leave"
|
|
PriceKeyCpdailyPhone = "price.cpdaily_phone"
|
|
PriceKeyXxt = "price.xxt"
|
|
PriceKeySmarteduSc = "price.smartedu_sc"
|
|
)
|
|
|
|
func (s *ConfigServiceV1) GetPriceConfig(ctx context.Context, req *v1.PriceConfigGetReq) *utils.Response[*v1.PriceConfigResp] {
|
|
resp := &v1.PriceConfigResp{
|
|
CpdailyTask: s.getConfigValue(ctx, PriceKeyCpdailyTask, "0.5"),
|
|
CpdailyLeave: s.getConfigValue(ctx, PriceKeyCpdailyLeave, "4"),
|
|
CpdailyPhone: s.getConfigValue(ctx, PriceKeyCpdailyPhone, "0.25"),
|
|
Xxt: s.getConfigValue(ctx, PriceKeyXxt, "0"),
|
|
SmarteduSc: s.getConfigValue(ctx, PriceKeySmarteduSc, "0"),
|
|
}
|
|
return utils.SuccessWithData[*v1.PriceConfigResp](resp)
|
|
}
|
|
|
|
func (s *ConfigServiceV1) getConfigValue(ctx context.Context, key, defaultValue string) string {
|
|
config, err := db.Global.SysConfig.Query().
|
|
Where(sysconfig.KeyEQ(key)).
|
|
Only(ctx)
|
|
if err != nil {
|
|
return defaultValue
|
|
}
|
|
return config.Value
|
|
}
|
|
|
|
func (s *ConfigServiceV1) UpdatePriceConfig(ctx context.Context, req *v1.PriceConfigUpdateReq) *utils.Response[any] {
|
|
if req.CpdailyTask != "" {
|
|
s.upsertConfig(ctx, PriceKeyCpdailyTask, req.CpdailyTask, "今日校园签到单价")
|
|
}
|
|
if req.CpdailyLeave != "" {
|
|
s.upsertConfig(ctx, PriceKeyCpdailyLeave, req.CpdailyLeave, "今日校园请假单价")
|
|
}
|
|
if req.CpdailyPhone != "" {
|
|
s.upsertConfig(ctx, PriceKeyCpdailyPhone, req.CpdailyPhone, "今日校园手机号单价")
|
|
}
|
|
if req.Xxt != "" {
|
|
s.upsertConfig(ctx, PriceKeyXxt, req.Xxt, "学习通单价")
|
|
}
|
|
if req.SmarteduSc != "" {
|
|
s.upsertConfig(ctx, PriceKeySmarteduSc, req.SmarteduSc, "四川智慧教育单价")
|
|
}
|
|
return utils.SuccessWithMsg("费率配置更新成功")
|
|
}
|
|
|
|
func (s *ConfigServiceV1) upsertConfig(ctx context.Context, key, value, description string) {
|
|
config, err := db.Global.SysConfig.Query().
|
|
Where(sysconfig.KeyEQ(key)).
|
|
Only(ctx)
|
|
if err != nil {
|
|
if ent.IsNotFound(err) {
|
|
db.Global.SysConfig.Create().
|
|
SetKey(key).
|
|
SetValue(value).
|
|
SetDescription(description).
|
|
SetType("number").
|
|
SaveX(ctx)
|
|
return
|
|
}
|
|
utils.OkOrPanic(err)
|
|
}
|
|
|
|
db.Global.SysConfig.UpdateOne(config).
|
|
SetValue(value).
|
|
ExecX(ctx)
|
|
}
|
|
|
|
func (s *ConfigServiceV1) GetSmtpConfig(ctx context.Context, req *v1.SmtpConfigGetReq) *utils.Response[any] {
|
|
keys := []string{
|
|
cst2.ConfigEmailAuthMode,
|
|
cst2.ConfigEmailSMTPHost,
|
|
cst2.ConfigEmailSMTPPort,
|
|
cst2.ConfigEmailSMTPUsername,
|
|
cst2.ConfigEmailSMTPPassword,
|
|
cst2.ConfigEmailFromEmail,
|
|
cst2.ConfigEmailFromName,
|
|
cst2.ConfigEmailOAuthTenant,
|
|
cst2.ConfigEmailOAuthClientID,
|
|
cst2.ConfigEmailOAuthClientSecret,
|
|
cst2.ConfigEmailOAuthRedirectURL,
|
|
cst2.ConfigEmailOAuthRefreshToken,
|
|
cst2.ConfigEmailOAuthScope,
|
|
}
|
|
|
|
result := make(map[string]string, len(keys))
|
|
for _, key := range keys {
|
|
config, err := db.Global.SysConfig.Query().Where(sysconfig.KeyEQ(key)).Only(ctx)
|
|
if err == nil {
|
|
result[key] = config.Value
|
|
}
|
|
}
|
|
|
|
cfg := mailservice.NormalizeConfig(mailservice.EmailConfig{
|
|
AuthMode: result[cst2.ConfigEmailAuthMode],
|
|
SMTPHost: result[cst2.ConfigEmailSMTPHost],
|
|
SMTPPort: atoiOrZero(result[cst2.ConfigEmailSMTPPort]),
|
|
SMTPUsername: result[cst2.ConfigEmailSMTPUsername],
|
|
SMTPPassword: result[cst2.ConfigEmailSMTPPassword],
|
|
FromEmail: result[cst2.ConfigEmailFromEmail],
|
|
FromName: result[cst2.ConfigEmailFromName],
|
|
OAuthTenant: result[cst2.ConfigEmailOAuthTenant],
|
|
OAuthClientID: result[cst2.ConfigEmailOAuthClientID],
|
|
OAuthClientSecret: result[cst2.ConfigEmailOAuthClientSecret],
|
|
OAuthRedirectURL: result[cst2.ConfigEmailOAuthRedirectURL],
|
|
OAuthRefreshToken: result[cst2.ConfigEmailOAuthRefreshToken],
|
|
OAuthScope: result[cst2.ConfigEmailOAuthScope],
|
|
})
|
|
|
|
return utils.SuccessWithData[any](map[string]any{
|
|
"authMode": cfg.AuthMode,
|
|
"smtpHost": cfg.SMTPHost,
|
|
"smtpPort": cfg.SMTPPort,
|
|
"smtpUsername": cfg.SMTPUsername,
|
|
"smtpPassword": cfg.SMTPPassword,
|
|
"fromEmail": cfg.FromEmail,
|
|
"fromName": cfg.FromName,
|
|
"oauthTenant": cfg.OAuthTenant,
|
|
"oauthClientId": cfg.OAuthClientID,
|
|
"oauthClientSecret": cfg.OAuthClientSecret,
|
|
"oauthRedirectUrl": cfg.OAuthRedirectURL,
|
|
"oauthRefreshToken": cfg.OAuthRefreshToken,
|
|
"oauthScope": cfg.OAuthScope,
|
|
})
|
|
}
|
|
|
|
func (s *ConfigServiceV1) UpdateSmtpConfig(ctx context.Context, req *v1.SmtpConfigUpdateReq) *utils.Response[any] {
|
|
cfg := mailservice.NormalizeConfig(mailservice.EmailConfig{
|
|
AuthMode: req.AuthMode,
|
|
SMTPHost: req.SmtpHost,
|
|
SMTPPort: req.SmtpPort,
|
|
SMTPUsername: req.SmtpUsername,
|
|
SMTPPassword: req.SmtpPassword,
|
|
FromEmail: req.FromEmail,
|
|
FromName: req.FromName,
|
|
OAuthTenant: req.OAuthTenant,
|
|
OAuthClientID: req.OAuthClientID,
|
|
OAuthClientSecret: req.OAuthClientSecret,
|
|
OAuthRedirectURL: req.OAuthRedirectURL,
|
|
OAuthRefreshToken: req.OAuthRefreshToken,
|
|
OAuthScope: req.OAuthScope,
|
|
})
|
|
if err := mailservice.NewV1().ValidateConfig(cfg); err != nil {
|
|
utils.OkOrPanic(errors2.NewBusinessError(400, err.Error()))
|
|
}
|
|
|
|
configs := map[string]string{
|
|
cst2.ConfigEmailAuthMode: cfg.AuthMode,
|
|
cst2.ConfigEmailSMTPHost: cfg.SMTPHost,
|
|
cst2.ConfigEmailSMTPPort: fmt.Sprintf("%d", cfg.SMTPPort),
|
|
cst2.ConfigEmailSMTPUsername: cfg.SMTPUsername,
|
|
cst2.ConfigEmailSMTPPassword: cfg.SMTPPassword,
|
|
cst2.ConfigEmailFromEmail: cfg.FromEmail,
|
|
cst2.ConfigEmailFromName: cfg.FromName,
|
|
cst2.ConfigEmailOAuthTenant: cfg.OAuthTenant,
|
|
cst2.ConfigEmailOAuthClientID: cfg.OAuthClientID,
|
|
cst2.ConfigEmailOAuthClientSecret: cfg.OAuthClientSecret,
|
|
cst2.ConfigEmailOAuthRedirectURL: cfg.OAuthRedirectURL,
|
|
cst2.ConfigEmailOAuthRefreshToken: cfg.OAuthRefreshToken,
|
|
cst2.ConfigEmailOAuthScope: cfg.OAuthScope,
|
|
}
|
|
|
|
for key, value := range configs {
|
|
exists, _ := db.Global.SysConfig.Query().Where(sysconfig.KeyEQ(key)).Exist(ctx)
|
|
if exists {
|
|
db.Global.SysConfig.Update().Where(sysconfig.KeyEQ(key)).SetValue(value).ExecX(ctx)
|
|
} else {
|
|
db.Global.SysConfig.Create().
|
|
SetKey(key).
|
|
SetValue(value).
|
|
SetDescription("邮件配置").
|
|
ExecX(ctx)
|
|
}
|
|
}
|
|
|
|
return utils.SuccessWithMsg("邮件配置保存成功")
|
|
}
|
|
|
|
func (s *ConfigServiceV1) TestSmtp(ctx context.Context, req *v1.SmtpTestReq) *utils.Response[any] {
|
|
emailService := mailservice.NewV1()
|
|
cfg := emailService.GetConfig()
|
|
if err := emailService.ValidateConfig(cfg); err != nil {
|
|
utils.OkOrPanic(errors2.NewBusinessError(400, err.Error()))
|
|
}
|
|
|
|
subject := "邮件配置测试"
|
|
body := "<h2>邮件配置测试成功</h2><p>如果您收到此邮件，说明当前邮件配置可以正常发信。</p>"
|
|
if err := emailService.SendMessageNow(ctx, cfg, req.ToEmail, subject, body); err != nil {
|
|
utils.OkOrPanic(err)
|
|
}
|
|
return utils.SuccessWithMsg("测试邮件发送成功")
|
|
}
|
|
|
|
func (s *ConfigServiceV1) GetOutlookOAuthAuthorizeURL(ctx context.Context, req *v1.OutlookOAuthAuthorizeURLReq) *utils.Response[*v1.OutlookOAuthAuthorizeURLResp] {
|
|
cfg := mailservice.NormalizeConfig(mailservice.EmailConfig{
|
|
AuthMode: mailservice.AuthModeOutlookOAuth2,
|
|
FromEmail: req.FromEmail,
|
|
FromName: "Microsoft Graph OAuth2",
|
|
OAuthTenant: req.OAuthTenant,
|
|
OAuthClientID: req.OAuthClientID,
|
|
OAuthClientSecret: req.OAuthClientSecret,
|
|
OAuthScope: req.OAuthScope,
|
|
})
|
|
|
|
resp, err := mailservice.NewV1().BuildOutlookAuthorizeURL(cfg, req.CallbackBaseURL, req.FrontendOrigin)
|
|
if err != nil {
|
|
utils.OkOrPanic(errors2.NewBusinessError(400, err.Error()))
|
|
}
|
|
return utils.SuccessWithData(resp)
|
|
}
|
|
|
|
func atoiOrZero(value string) int {
|
|
if value == "" {
|
|
return 0
|
|
}
|
|
var result int
|
|
_, _ = fmt.Sscanf(value, "%d", &result)
|
|
return result
|
|
}
|