322 lines
10 KiB
Go
322 lines
10 KiB
Go
package services
|
|
|
|
import (
|
|
"bbs-go/internal/models/constants"
|
|
"errors"
|
|
"log/slog"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/mlogclub/simple/common/dates"
|
|
"github.com/mlogclub/simple/common/jsons"
|
|
"github.com/mlogclub/simple/common/numbers"
|
|
"github.com/mlogclub/simple/common/strs"
|
|
"github.com/mlogclub/simple/sqls"
|
|
"github.com/mlogclub/simple/web/params"
|
|
"github.com/spf13/cast"
|
|
"github.com/tidwall/gjson"
|
|
|
|
"gorm.io/gorm"
|
|
|
|
"bbs-go/internal/cache"
|
|
"bbs-go/internal/models"
|
|
"bbs-go/internal/repositories"
|
|
)
|
|
|
|
var SysConfigService = newSysConfigService()
|
|
|
|
func newSysConfigService() *sysConfigService {
|
|
return &sysConfigService{}
|
|
}
|
|
|
|
type sysConfigService struct {
|
|
}
|
|
|
|
func (s *sysConfigService) Get(id int64) *models.SysConfig {
|
|
return repositories.SysConfigRepository.Get(sqls.DB(), id)
|
|
}
|
|
|
|
func (s *sysConfigService) Take(where ...interface{}) *models.SysConfig {
|
|
return repositories.SysConfigRepository.Take(sqls.DB(), where...)
|
|
}
|
|
|
|
func (s *sysConfigService) Find(cnd *sqls.Cnd) []models.SysConfig {
|
|
return repositories.SysConfigRepository.Find(sqls.DB(), cnd)
|
|
}
|
|
|
|
func (s *sysConfigService) FindOne(cnd *sqls.Cnd) *models.SysConfig {
|
|
return repositories.SysConfigRepository.FindOne(sqls.DB(), cnd)
|
|
}
|
|
|
|
func (s *sysConfigService) FindPageByParams(params *params.QueryParams) (list []models.SysConfig, paging *sqls.Paging) {
|
|
return repositories.SysConfigRepository.FindPageByParams(sqls.DB(), params)
|
|
}
|
|
|
|
func (s *sysConfigService) FindPageByCnd(cnd *sqls.Cnd) (list []models.SysConfig, paging *sqls.Paging) {
|
|
return repositories.SysConfigRepository.FindPageByCnd(sqls.DB(), cnd)
|
|
}
|
|
|
|
func (s *sysConfigService) GetAll() []models.SysConfig {
|
|
return repositories.SysConfigRepository.Find(sqls.DB(), sqls.NewCnd().Asc("id"))
|
|
}
|
|
|
|
func (s *sysConfigService) SetAll(configStr string) error {
|
|
json := gjson.Parse(configStr)
|
|
configs, ok := json.Value().(map[string]interface{})
|
|
if !ok {
|
|
return errors.New("配置数据格式错误")
|
|
}
|
|
return sqls.DB().Transaction(func(tx *gorm.DB) error {
|
|
for k := range configs {
|
|
v := json.Get(k).String()
|
|
if err := s.setSingle(tx, k, v, "", ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// Set 设置配置，如果配置不存在，那么创建
|
|
func (s *sysConfigService) Set(key, value, name, description string) error {
|
|
return sqls.DB().Transaction(func(tx *gorm.DB) error {
|
|
if err := s.setSingle(tx, key, value, name, description); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (s *sysConfigService) setSingle(db *gorm.DB, key, value, name, description string) error {
|
|
if len(key) == 0 {
|
|
return errors.New("sys config key is null")
|
|
}
|
|
sysConfig := repositories.SysConfigRepository.GetByKey(db, key)
|
|
if sysConfig == nil {
|
|
sysConfig = &models.SysConfig{
|
|
CreateTime: dates.NowTimestamp(),
|
|
}
|
|
}
|
|
sysConfig.Key = key
|
|
sysConfig.Value = value
|
|
sysConfig.UpdateTime = dates.NowTimestamp()
|
|
|
|
if strs.IsNotBlank(name) {
|
|
sysConfig.Name = name
|
|
}
|
|
if strs.IsNotBlank(description) {
|
|
sysConfig.Description = description
|
|
}
|
|
|
|
var err error
|
|
if sysConfig.Id > 0 {
|
|
err = repositories.SysConfigRepository.Update(db, sysConfig)
|
|
} else {
|
|
err = repositories.SysConfigRepository.Create(db, sysConfig)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
} else {
|
|
cache.SysConfigCache.Invalidate(key)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (s *sysConfigService) GetTokenExpireDays() int {
|
|
tokenExpireDaysStr := cache.SysConfigCache.GetValue(constants.SysConfigTokenExpireDays)
|
|
tokenExpireDays, err := strconv.Atoi(tokenExpireDaysStr)
|
|
if err != nil {
|
|
tokenExpireDays = constants.DefaultTokenExpireDays
|
|
}
|
|
if tokenExpireDays <= 0 {
|
|
tokenExpireDays = constants.DefaultTokenExpireDays
|
|
}
|
|
return tokenExpireDays
|
|
}
|
|
|
|
func (s *sysConfigService) GetLoginMethod() models.LoginMethod {
|
|
loginMethodStr := cache.SysConfigCache.GetValue(constants.SysConfigLoginMethod)
|
|
|
|
useDefault := true
|
|
var loginMethod models.LoginMethod
|
|
if strs.IsNotBlank(loginMethodStr) {
|
|
if err := jsons.Parse(loginMethodStr, &loginMethod); err != nil {
|
|
slog.Warn("登录方式数据错误", err)
|
|
} else {
|
|
useDefault = false
|
|
}
|
|
}
|
|
if useDefault {
|
|
loginMethod = models.LoginMethod{
|
|
Password: true,
|
|
QQ: true,
|
|
Github: true,
|
|
}
|
|
}
|
|
return loginMethod
|
|
}
|
|
|
|
func (s *sysConfigService) IsCreateTopicEmailVerified() bool {
|
|
value := cache.SysConfigCache.GetValue(constants.SysConfigCreateTopicEmailVerified)
|
|
return strs.EqualsIgnoreCase(value, "true") || strs.EqualsIgnoreCase(value, "1")
|
|
}
|
|
|
|
func (s *sysConfigService) IsCreateArticleEmailVerified() bool {
|
|
value := cache.SysConfigCache.GetValue(constants.SysConfigCreateArticleEmailVerified)
|
|
return strs.EqualsIgnoreCase(value, "true") || strs.EqualsIgnoreCase(value, "1")
|
|
}
|
|
|
|
func (s *sysConfigService) IsCreateCommentEmailVerified() bool {
|
|
value := cache.SysConfigCache.GetValue(constants.SysConfigCreateCommentEmailVerified)
|
|
return strs.EqualsIgnoreCase(value, "true") || strs.EqualsIgnoreCase(value, "1")
|
|
}
|
|
|
|
func (s *sysConfigService) IsEnableHideContent() bool {
|
|
value := cache.SysConfigCache.GetValue(constants.SysConfigEnableHideContent)
|
|
return strs.EqualsIgnoreCase(value, "true") || strs.EqualsIgnoreCase(value, "1")
|
|
}
|
|
|
|
func (s *sysConfigService) IsArticlePending() bool {
|
|
value := cache.SysConfigCache.GetValue(constants.SysConfigArticlePending)
|
|
return strs.EqualsIgnoreCase(value, "true") || strs.EqualsIgnoreCase(value, "1")
|
|
}
|
|
|
|
func (s *sysConfigService) GetSiteNavs() []models.ActionLink {
|
|
siteNavs := cache.SysConfigCache.GetValue(constants.SysConfigSiteNavs)
|
|
var siteNavsArr []models.ActionLink
|
|
if strs.IsNotBlank(siteNavs) {
|
|
if err := jsons.Parse(siteNavs, &siteNavsArr); err != nil {
|
|
slog.Warn("站点导航数据错误", slog.Any("err", err))
|
|
}
|
|
}
|
|
return siteNavsArr
|
|
}
|
|
|
|
func (s *sysConfigService) GetModules() models.ModulesConfig {
|
|
str := cache.SysConfigCache.GetValue(constants.SysConfigModules)
|
|
|
|
useDefault := true
|
|
var modulesConfig models.ModulesConfig
|
|
if strs.IsNotBlank(str) {
|
|
if err := jsons.Parse(str, &modulesConfig); err != nil {
|
|
slog.Warn("启用模块配置错误", err)
|
|
} else {
|
|
useDefault = false
|
|
}
|
|
}
|
|
if useDefault {
|
|
modulesConfig = models.ModulesConfig{
|
|
Tweet: true,
|
|
Topic: true,
|
|
Article: true,
|
|
}
|
|
}
|
|
return modulesConfig
|
|
}
|
|
|
|
// GetEmailWhitelist 邮箱白名单
|
|
func (s *sysConfigService) GetEmailWhitelist() []string {
|
|
str := cache.SysConfigCache.GetValue(constants.SysConfigEmailWhitelist)
|
|
var emailWhitelist []string
|
|
if strs.IsNotBlank(str) {
|
|
_ = jsons.Parse(str, &emailWhitelist)
|
|
}
|
|
return emailWhitelist
|
|
}
|
|
|
|
func (s *sysConfigService) GetConfig() *models.SysConfigResponse {
|
|
var (
|
|
siteTitle = cache.SysConfigCache.GetValue(constants.SysConfigSiteTitle)
|
|
siteDescription = cache.SysConfigCache.GetValue(constants.SysConfigSiteDescription)
|
|
siteKeywords = cache.SysConfigCache.GetValue(constants.SysConfigSiteKeywords)
|
|
siteLogo = cache.SysConfigCache.GetValue(constants.SysConfigSiteLogo)
|
|
siteNotification = cache.SysConfigCache.GetValue(constants.SysConfigSiteNotification)
|
|
recommendTags = cache.SysConfigCache.GetValue(constants.SysConfigRecommendTags)
|
|
urlRedirect = cache.SysConfigCache.GetValue(constants.SysConfigUrlRedirect)
|
|
scoreConfigStr = cache.SysConfigCache.GetValue(constants.SysConfigScoreConfig)
|
|
defaultNodeIdStr = cache.SysConfigCache.GetValue(constants.SysConfigDefaultNodeId)
|
|
topicCaptcha = cache.SysConfigCache.GetValue(constants.SysConfigTopicCaptcha)
|
|
userObserveSecondsStr = cache.SysConfigCache.GetValue(constants.SysConfigUserObserveSeconds)
|
|
siteNavs = s.GetSiteNavs()
|
|
loginMethod = s.GetLoginMethod()
|
|
createTopicEmailVerified = s.IsCreateTopicEmailVerified()
|
|
createArticleEmailVerified = s.IsCreateArticleEmailVerified()
|
|
createCommentEmailVerified = s.IsCreateCommentEmailVerified()
|
|
enableHideContent = s.IsEnableHideContent()
|
|
articlePending = s.IsArticlePending()
|
|
)
|
|
|
|
var siteKeywordsArr []string
|
|
if strs.IsNotBlank(siteKeywords) {
|
|
if err := jsons.Parse(siteKeywords, &siteKeywordsArr); err != nil {
|
|
slog.Warn("站点关键词数据错误", slog.Any("err", err))
|
|
}
|
|
}
|
|
|
|
var recommendTagsArr []string
|
|
if strs.IsNotBlank(recommendTags) {
|
|
if err := jsons.Parse(recommendTags, &recommendTagsArr); err != nil {
|
|
slog.Warn("推荐标签数据错误", slog.Any("err", err))
|
|
}
|
|
}
|
|
|
|
var scoreConfig models.ScoreConfig
|
|
if strs.IsNotBlank(scoreConfigStr) {
|
|
if err := jsons.Parse(scoreConfigStr, &scoreConfig); err != nil {
|
|
slog.Warn("积分配置错误", slog.Any("err", err))
|
|
}
|
|
}
|
|
|
|
var (
|
|
defaultNodeId = numbers.ToInt64(defaultNodeIdStr)
|
|
userObserveSeconds = numbers.ToInt(userObserveSecondsStr)
|
|
)
|
|
|
|
return &models.SysConfigResponse{
|
|
SiteTitle: siteTitle,
|
|
SiteDescription: siteDescription,
|
|
SiteKeywords: siteKeywordsArr,
|
|
SiteLogo: siteLogo,
|
|
SiteNavs: siteNavs,
|
|
SiteNotification: siteNotification,
|
|
RecommendTags: recommendTagsArr,
|
|
UrlRedirect: strings.ToLower(urlRedirect) == "true",
|
|
ScoreConfig: scoreConfig,
|
|
DefaultNodeId: defaultNodeId,
|
|
ArticlePending: articlePending,
|
|
TopicCaptcha: strings.ToLower(topicCaptcha) == "true",
|
|
UserObserveSeconds: userObserveSeconds,
|
|
TokenExpireDays: s.GetTokenExpireDays(),
|
|
LoginMethod: loginMethod,
|
|
CreateTopicEmailVerified: createTopicEmailVerified,
|
|
CreateArticleEmailVerified: createArticleEmailVerified,
|
|
CreateCommentEmailVerified: createCommentEmailVerified,
|
|
EnableHideContent: enableHideContent,
|
|
Modules: s.GetModules(),
|
|
EmailWhitelist: s.GetEmailWhitelist(),
|
|
}
|
|
}
|
|
|
|
func (s *sysConfigService) GetStr(key, def string) (value string) {
|
|
value = cache.SysConfigCache.GetValue(key)
|
|
if strs.IsBlank(value) {
|
|
value = def
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *sysConfigService) GetInt(key string, def int) (value int) {
|
|
str := cache.SysConfigCache.GetValue(key)
|
|
if strs.IsBlank(str) {
|
|
value = def
|
|
return
|
|
}
|
|
var err error
|
|
if value, err = cast.ToIntE(str); err != nil {
|
|
value = def
|
|
slog.Warn("Get int config error, use default value", slog.Any("default", def), slog.Any("key", key), slog.Any("value", str))
|
|
return
|
|
}
|
|
return
|
|
}
|