1068 lines
35 KiB
Go
1068 lines
35 KiB
Go
package appconfig
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
"unicode"
|
||
"unicode/utf8"
|
||
|
||
"hyapp-admin-server/internal/appctx"
|
||
"hyapp-admin-server/internal/model"
|
||
"hyapp-admin-server/internal/repository"
|
||
)
|
||
|
||
const h5LinkGroup = "h5-links"
|
||
|
||
const (
|
||
bannerDisplayScopeHome = "home"
|
||
bannerDisplayScopeRoom = "room"
|
||
bannerDisplayScopeRecharge = "recharge"
|
||
|
||
bannerStatusActive = "active"
|
||
bannerStatusDisabled = "disabled"
|
||
bannerStatusExpired = "expired"
|
||
|
||
splashDefaultDisplayDurationMS = 3000
|
||
)
|
||
|
||
var bannerDisplayScopeOrder = []string{bannerDisplayScopeHome, bannerDisplayScopeRoom, bannerDisplayScopeRecharge}
|
||
|
||
type AppConfigService struct {
|
||
store *repository.Store
|
||
}
|
||
|
||
type H5Link struct {
|
||
Key string `json:"key"`
|
||
Label string `json:"label"`
|
||
URL string `json:"url"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
type AppBanner struct {
|
||
ID uint `json:"id"`
|
||
AppCode string `json:"appCode"`
|
||
CoverURL string `json:"coverUrl"`
|
||
RoomSmallImageURL string `json:"roomSmallImageUrl"`
|
||
BannerType string `json:"bannerType"`
|
||
DisplayScope string `json:"displayScope"`
|
||
DisplayScopes []string `json:"displayScopes"`
|
||
Param string `json:"param"`
|
||
Status string `json:"status"`
|
||
Platform string `json:"platform"`
|
||
SortOrder int `json:"sortOrder"`
|
||
RegionID int64 `json:"regionId"`
|
||
CountryCode string `json:"countryCode"`
|
||
Description string `json:"description"`
|
||
StartsAtMs int64 `json:"startsAtMs"`
|
||
EndsAtMs int64 `json:"endsAtMs"`
|
||
CreatedAtMs int64 `json:"createdAtMs"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
type AppSplashScreen struct {
|
||
ID uint `json:"id"`
|
||
AppCode string `json:"appCode"`
|
||
CoverURL string `json:"coverUrl"`
|
||
SplashType string `json:"splashType"`
|
||
Param string `json:"param"`
|
||
Status string `json:"status"`
|
||
Platform string `json:"platform"`
|
||
SortOrder int `json:"sortOrder"`
|
||
RegionID int64 `json:"regionId"`
|
||
CountryCode string `json:"countryCode"`
|
||
Description string `json:"description"`
|
||
DisplayDurationMs int `json:"displayDurationMs"`
|
||
StartsAtMs int64 `json:"startsAtMs"`
|
||
EndsAtMs int64 `json:"endsAtMs"`
|
||
CreatedAtMs int64 `json:"createdAtMs"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
type AppPopup struct {
|
||
ID uint `json:"id"`
|
||
AppCode string `json:"appCode"`
|
||
Code string `json:"code"`
|
||
Name string `json:"name"`
|
||
ImageURL string `json:"imageUrl"`
|
||
JumpType string `json:"jumpType"`
|
||
JumpURL string `json:"jumpUrl"`
|
||
DisplayPeriodDays int `json:"displayPeriodDays"`
|
||
Status string `json:"status"`
|
||
SortOrder int `json:"sortOrder"`
|
||
StartsAtMs int64 `json:"startsAtMs"`
|
||
EndsAtMs int64 `json:"endsAtMs"`
|
||
CreatedAtMs int64 `json:"createdAtMs"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
type AppVersion struct {
|
||
ID uint `json:"id"`
|
||
AppCode string `json:"appCode"`
|
||
Platform string `json:"platform"`
|
||
Version string `json:"version"`
|
||
BuildNumber int64 `json:"buildNumber"`
|
||
ForceUpdate bool `json:"forceUpdate"`
|
||
DownloadURL string `json:"downloadUrl"`
|
||
Description string `json:"description"`
|
||
CreatedAtMs int64 `json:"createdAtMs"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
type ExploreTab struct {
|
||
ID uint `json:"id"`
|
||
AppCode string `json:"appCode"`
|
||
Tab string `json:"tab"`
|
||
H5URL string `json:"h5Url"`
|
||
Enabled bool `json:"enabled"`
|
||
SortOrder int `json:"sortOrder"`
|
||
CreatedAtMs int64 `json:"createdAtMs"`
|
||
UpdatedAtMs int64 `json:"updatedAtMs"`
|
||
}
|
||
|
||
func NewService(store *repository.Store) *AppConfigService {
|
||
return &AppConfigService{store: store}
|
||
}
|
||
|
||
func (s *AppConfigService) ListH5Links() ([]H5Link, error) {
|
||
configs, err := s.store.ListAppConfigs(h5LinkGroup)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
items := make([]H5Link, 0, len(configs))
|
||
for _, config := range configs {
|
||
items = append(items, h5LinkFromModel(config))
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateH5Links(request updateH5LinksRequest) ([]H5Link, error) {
|
||
if len(request.Items) == 0 {
|
||
return nil, errors.New("items are required")
|
||
}
|
||
|
||
items := make([]model.AppConfig, 0, len(request.Items))
|
||
seen := make(map[string]struct{}, len(request.Items))
|
||
for _, item := range request.Items {
|
||
config, err := h5LinkModelFromPayload(item)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
key := config.Key
|
||
if _, ok := seen[key]; ok {
|
||
return nil, fmt.Errorf("duplicate h5 link key: %s", key)
|
||
}
|
||
seen[key] = struct{}{}
|
||
items = append(items, config)
|
||
}
|
||
|
||
if err := s.store.UpsertAppConfigs(items); err != nil {
|
||
return nil, err
|
||
}
|
||
return s.ListH5Links()
|
||
}
|
||
|
||
func (s *AppConfigService) CreateH5Link(req h5LinkPayload) (H5Link, error) {
|
||
item, err := h5LinkModelFromPayload(req)
|
||
if err != nil {
|
||
return H5Link{}, err
|
||
}
|
||
if err := s.store.CreateAppConfig(&item); err != nil {
|
||
return H5Link{}, err
|
||
}
|
||
return h5LinkFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateH5Link(key string, req h5LinkPayload) (H5Link, error) {
|
||
item, err := s.store.GetAppConfig(h5LinkGroup, key)
|
||
if err != nil {
|
||
return H5Link{}, err
|
||
}
|
||
req.Key = item.Key
|
||
updated, err := h5LinkModelFromPayload(req)
|
||
if err != nil {
|
||
return H5Link{}, err
|
||
}
|
||
item.Value = updated.Value
|
||
item.Description = updated.Description
|
||
if err := s.store.UpdateAppConfig(&item); err != nil {
|
||
return H5Link{}, err
|
||
}
|
||
return h5LinkFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeleteH5Link(key string) error {
|
||
return s.store.DeleteAppConfig(h5LinkGroup, key)
|
||
}
|
||
|
||
func (s *AppConfigService) ListBanners(appCode string, options repository.AppBannerListOptions) ([]AppBanner, error) {
|
||
options.AppCode = appctx.Normalize(appCode)
|
||
options.Status = normalizeBannerStatus(options.Status)
|
||
if strings.TrimSpace(options.DisplayScope) != "" {
|
||
options.DisplayScope = normalizeBannerDisplayScope(options.DisplayScope)
|
||
}
|
||
options.Platform = normalizeBannerPlatform(options.Platform)
|
||
options.Country = normalizeCountryCode(options.Country)
|
||
options.Keyword = strings.TrimSpace(options.Keyword)
|
||
if err := s.store.ExpireAppBanners(options.AppCode, time.Now().UTC().UnixMilli()); err != nil {
|
||
return nil, err
|
||
}
|
||
items, err := s.store.ListAppBanners(options)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]AppBanner, 0, len(items))
|
||
for _, item := range items {
|
||
out = append(out, appBannerFromModel(item))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AppConfigService) CreateBanner(appCode string, req bannerRequest) (AppBanner, error) {
|
||
item, err := bannerModelFromRequest(appctx.Normalize(appCode), req)
|
||
if err != nil {
|
||
return AppBanner{}, err
|
||
}
|
||
if err := s.store.CreateAppBanner(&item); err != nil {
|
||
return AppBanner{}, err
|
||
}
|
||
return appBannerFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateBanner(appCode string, id uint, req bannerRequest) (AppBanner, error) {
|
||
item, err := s.store.GetAppBanner(appctx.Normalize(appCode), id)
|
||
if err != nil {
|
||
return AppBanner{}, err
|
||
}
|
||
updated, err := bannerModelFromRequest(item.AppCode, req)
|
||
if err != nil {
|
||
return AppBanner{}, err
|
||
}
|
||
item.CoverURL = updated.CoverURL
|
||
item.RoomSmallImageURL = updated.RoomSmallImageURL
|
||
item.BannerType = updated.BannerType
|
||
item.DisplayScope = updated.DisplayScope
|
||
item.Param = updated.Param
|
||
item.Status = updated.Status
|
||
item.Platform = updated.Platform
|
||
item.SortOrder = updated.SortOrder
|
||
item.RegionID = updated.RegionID
|
||
item.CountryCode = updated.CountryCode
|
||
item.Description = updated.Description
|
||
item.StartsAtMS = updated.StartsAtMS
|
||
item.EndsAtMS = updated.EndsAtMS
|
||
if err := s.store.UpdateAppBanner(&item); err != nil {
|
||
return AppBanner{}, err
|
||
}
|
||
return appBannerFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeleteBanner(appCode string, id uint) error {
|
||
return s.store.DeleteAppBanner(appctx.Normalize(appCode), id)
|
||
}
|
||
|
||
func (s *AppConfigService) ListSplashScreens(appCode string, options repository.AppSplashScreenListOptions) ([]AppSplashScreen, error) {
|
||
// 列表入口先把管理后台传入的筛选条件统一成数据库稳定值，再执行过期回收，避免已过期 active 数据继续展示。
|
||
options.AppCode = appctx.Normalize(appCode)
|
||
options.Status = normalizeBannerStatus(options.Status)
|
||
options.Platform = normalizeBannerPlatform(options.Platform)
|
||
options.Country = normalizeCountryCode(options.Country)
|
||
options.Keyword = strings.TrimSpace(options.Keyword)
|
||
if err := s.store.ExpireAppSplashScreens(options.AppCode, time.Now().UTC().UnixMilli()); err != nil {
|
||
return nil, err
|
||
}
|
||
items, err := s.store.ListAppSplashScreens(options)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]AppSplashScreen, 0, len(items))
|
||
for _, item := range items {
|
||
out = append(out, appSplashScreenFromModel(item))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AppConfigService) CreateSplashScreen(appCode string, req splashScreenRequest) (AppSplashScreen, error) {
|
||
// 创建时只接受 service 归一化后的模型，保证 status、平台、国家码和时间窗口在入库前已经被校验。
|
||
item, err := splashScreenModelFromRequest(appctx.Normalize(appCode), req)
|
||
if err != nil {
|
||
return AppSplashScreen{}, err
|
||
}
|
||
if err := s.store.CreateAppSplashScreen(&item); err != nil {
|
||
return AppSplashScreen{}, err
|
||
}
|
||
return appSplashScreenFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateSplashScreen(appCode string, id uint, req splashScreenRequest) (AppSplashScreen, error) {
|
||
// 更新先按 app_code 和 id 锁定原记录，再只覆盖业务字段，避免请求体伪造 app_code 或创建时间。
|
||
item, err := s.store.GetAppSplashScreen(appctx.Normalize(appCode), id)
|
||
if err != nil {
|
||
return AppSplashScreen{}, err
|
||
}
|
||
updated, err := splashScreenModelFromRequest(item.AppCode, req)
|
||
if err != nil {
|
||
return AppSplashScreen{}, err
|
||
}
|
||
item.CoverURL = updated.CoverURL
|
||
item.SplashType = updated.SplashType
|
||
item.Param = updated.Param
|
||
item.Status = updated.Status
|
||
item.Platform = updated.Platform
|
||
item.SortOrder = updated.SortOrder
|
||
item.RegionID = updated.RegionID
|
||
item.CountryCode = updated.CountryCode
|
||
item.Description = updated.Description
|
||
item.DisplayDurationMS = updated.DisplayDurationMS
|
||
item.StartsAtMS = updated.StartsAtMS
|
||
item.EndsAtMS = updated.EndsAtMS
|
||
if err := s.store.UpdateAppSplashScreen(&item); err != nil {
|
||
return AppSplashScreen{}, err
|
||
}
|
||
return appSplashScreenFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeleteSplashScreen(appCode string, id uint) error {
|
||
return s.store.DeleteAppSplashScreen(appctx.Normalize(appCode), id)
|
||
}
|
||
|
||
func (s *AppConfigService) ListPopups(appCode string, options repository.AppPopupListOptions) ([]AppPopup, error) {
|
||
// 列表先清理已过期 active 记录，再返回后台可见数据，保证运营看到的状态和 App 实际可展示状态一致。
|
||
options.AppCode = appctx.Normalize(appCode)
|
||
options.Status = normalizeBannerStatus(options.Status)
|
||
options.Keyword = strings.TrimSpace(options.Keyword)
|
||
if err := s.store.ExpireAppPopups(options.AppCode, time.Now().UTC().UnixMilli()); err != nil {
|
||
return nil, err
|
||
}
|
||
items, err := s.store.ListAppPopups(options)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]AppPopup, 0, len(items))
|
||
for _, item := range items {
|
||
out = append(out, appPopupFromModel(item))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AppConfigService) CreatePopup(appCode string, req popupRequest) (AppPopup, error) {
|
||
item, err := popupModelFromRequest(appctx.Normalize(appCode), req)
|
||
if err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
exists, err := s.store.HasAppPopupCode(item.AppCode, item.Code, 0)
|
||
if err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
if exists {
|
||
return AppPopup{}, errors.New("popup code already exists")
|
||
}
|
||
if err := s.store.CreateAppPopup(&item); err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
return appPopupFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdatePopup(appCode string, id uint, req popupRequest) (AppPopup, error) {
|
||
// 更新时先按 app_code 锁定原记录，再覆盖可编辑字段，避免请求体伪造租户和创建时间。
|
||
item, err := s.store.GetAppPopup(appctx.Normalize(appCode), id)
|
||
if err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
updated, err := popupModelFromRequest(item.AppCode, req)
|
||
if err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
exists, err := s.store.HasAppPopupCode(item.AppCode, updated.Code, item.ID)
|
||
if err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
if exists {
|
||
return AppPopup{}, errors.New("popup code already exists")
|
||
}
|
||
item.Code = updated.Code
|
||
item.Name = updated.Name
|
||
item.ImageURL = updated.ImageURL
|
||
item.JumpType = updated.JumpType
|
||
item.JumpURL = updated.JumpURL
|
||
item.DisplayPeriodDays = updated.DisplayPeriodDays
|
||
item.Status = updated.Status
|
||
item.SortOrder = updated.SortOrder
|
||
item.StartsAtMS = updated.StartsAtMS
|
||
item.EndsAtMS = updated.EndsAtMS
|
||
if err := s.store.UpdateAppPopup(&item); err != nil {
|
||
return AppPopup{}, err
|
||
}
|
||
return appPopupFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeletePopup(appCode string, id uint) error {
|
||
return s.store.DeleteAppPopup(appctx.Normalize(appCode), id)
|
||
}
|
||
|
||
func (s *AppConfigService) ListAppVersions(appCode string, options repository.AppVersionListOptions) ([]AppVersion, error) {
|
||
options.AppCode = appctx.Normalize(appCode)
|
||
options.Platform = normalizeAppPlatform(options.Platform)
|
||
options.Keyword = strings.TrimSpace(options.Keyword)
|
||
items, err := s.store.ListAppVersions(options)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]AppVersion, 0, len(items))
|
||
for _, item := range items {
|
||
out = append(out, appVersionFromModel(item))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AppConfigService) CreateAppVersion(appCode string, req appVersionRequest) (AppVersion, error) {
|
||
item, err := appVersionModelFromRequest(appctx.Normalize(appCode), req)
|
||
if err != nil {
|
||
return AppVersion{}, err
|
||
}
|
||
if err := s.store.CreateAppVersion(&item); err != nil {
|
||
return AppVersion{}, err
|
||
}
|
||
return appVersionFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateAppVersion(appCode string, id uint, req appVersionRequest) (AppVersion, error) {
|
||
item, err := s.store.GetAppVersion(appctx.Normalize(appCode), id)
|
||
if err != nil {
|
||
return AppVersion{}, err
|
||
}
|
||
updated, err := appVersionModelFromRequest(item.AppCode, req)
|
||
if err != nil {
|
||
return AppVersion{}, err
|
||
}
|
||
item.Platform = updated.Platform
|
||
item.Version = updated.Version
|
||
item.BuildNumber = updated.BuildNumber
|
||
item.ForceUpdate = updated.ForceUpdate
|
||
item.DownloadURL = updated.DownloadURL
|
||
item.Description = updated.Description
|
||
if err := s.store.UpdateAppVersion(&item); err != nil {
|
||
return AppVersion{}, err
|
||
}
|
||
return appVersionFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeleteAppVersion(appCode string, id uint) error {
|
||
return s.store.DeleteAppVersion(appctx.Normalize(appCode), id)
|
||
}
|
||
|
||
func (s *AppConfigService) ListExploreTabs(appCode string, options repository.AppExploreTabListOptions) ([]ExploreTab, error) {
|
||
options.AppCode = appctx.Normalize(appCode)
|
||
options.Keyword = strings.TrimSpace(options.Keyword)
|
||
items, err := s.store.ListAppExploreTabs(options)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]ExploreTab, 0, len(items))
|
||
for _, item := range items {
|
||
out = append(out, exploreTabFromModel(item))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AppConfigService) CreateExploreTab(appCode string, req exploreTabRequest) (ExploreTab, error) {
|
||
item, err := exploreTabModelFromRequest(appctx.Normalize(appCode), req)
|
||
if err != nil {
|
||
return ExploreTab{}, err
|
||
}
|
||
if err := s.store.CreateAppExploreTab(&item); err != nil {
|
||
return ExploreTab{}, err
|
||
}
|
||
return exploreTabFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) UpdateExploreTab(appCode string, id uint, req exploreTabRequest) (ExploreTab, error) {
|
||
item, err := s.store.GetAppExploreTab(appctx.Normalize(appCode), id)
|
||
if err != nil {
|
||
return ExploreTab{}, err
|
||
}
|
||
updated, err := exploreTabModelFromRequest(item.AppCode, req)
|
||
if err != nil {
|
||
return ExploreTab{}, err
|
||
}
|
||
item.Tab = updated.Tab
|
||
item.H5URL = updated.H5URL
|
||
item.Enabled = updated.Enabled
|
||
item.SortOrder = updated.SortOrder
|
||
if err := s.store.UpdateAppExploreTab(&item); err != nil {
|
||
return ExploreTab{}, err
|
||
}
|
||
return exploreTabFromModel(item), nil
|
||
}
|
||
|
||
func (s *AppConfigService) DeleteExploreTab(appCode string, id uint) error {
|
||
return s.store.DeleteAppExploreTab(appctx.Normalize(appCode), id)
|
||
}
|
||
|
||
func validateH5URL(value string) error {
|
||
if value == "" {
|
||
return nil
|
||
}
|
||
if len(value) > 2048 {
|
||
return errors.New("h5 link is too long")
|
||
}
|
||
for _, char := range value {
|
||
if unicode.IsSpace(char) {
|
||
return errors.New("h5 link cannot contain whitespace")
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func h5LinkModelFromPayload(req h5LinkPayload) (model.AppConfig, error) {
|
||
key := strings.TrimSpace(req.Key)
|
||
label := strings.TrimSpace(req.Label)
|
||
url := strings.TrimSpace(req.URL)
|
||
if err := validateH5Key(key); err != nil {
|
||
return model.AppConfig{}, err
|
||
}
|
||
if label == "" || utf8.RuneCountInString(label) > 80 {
|
||
return model.AppConfig{}, errors.New("h5 config label is invalid")
|
||
}
|
||
if url == "" {
|
||
return model.AppConfig{}, errors.New("h5 link is required")
|
||
}
|
||
if err := validateH5URL(url); err != nil {
|
||
return model.AppConfig{}, err
|
||
}
|
||
return model.AppConfig{
|
||
Group: h5LinkGroup,
|
||
Key: key,
|
||
Value: url,
|
||
Description: label,
|
||
}, nil
|
||
}
|
||
|
||
func validateH5Key(value string) error {
|
||
if value == "" || len(value) > 80 {
|
||
return errors.New("h5 config key is invalid")
|
||
}
|
||
for _, char := range value {
|
||
switch {
|
||
case char >= 'a' && char <= 'z':
|
||
case char >= 'A' && char <= 'Z':
|
||
case char >= '0' && char <= '9':
|
||
case char == '-' || char == '_' || char == '.' || char == ':':
|
||
default:
|
||
return errors.New("h5 config key is invalid")
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func h5LinkFromModel(config model.AppConfig) H5Link {
|
||
label := strings.TrimSpace(config.Description)
|
||
if label == "" {
|
||
label = config.Key
|
||
}
|
||
return H5Link{
|
||
Key: config.Key,
|
||
Label: label,
|
||
URL: config.Value,
|
||
UpdatedAtMs: config.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func bannerModelFromRequest(appCode string, req bannerRequest) (model.AppBanner, error) {
|
||
displayScopes := normalizeBannerDisplayScopes(req.DisplayScopes, req.DisplayScope)
|
||
item := model.AppBanner{
|
||
AppCode: appctx.Normalize(appCode),
|
||
CoverURL: strings.TrimSpace(req.CoverURL),
|
||
RoomSmallImageURL: strings.TrimSpace(req.RoomSmallImageURL),
|
||
BannerType: normalizeBannerType(req.BannerType),
|
||
DisplayScope: bannerDisplayScopeValue(displayScopes),
|
||
Param: strings.TrimSpace(req.Param),
|
||
Status: normalizeBannerStatus(req.Status),
|
||
Platform: normalizeBannerPlatform(req.Platform),
|
||
SortOrder: req.SortOrder,
|
||
RegionID: req.RegionID,
|
||
CountryCode: normalizeCountryCode(req.CountryCode),
|
||
Description: strings.TrimSpace(req.Description),
|
||
StartsAtMS: req.StartsAtMs,
|
||
EndsAtMS: req.EndsAtMs,
|
||
}
|
||
if item.CoverURL == "" || len(item.CoverURL) > 1024 {
|
||
return model.AppBanner{}, errors.New("banner cover is invalid")
|
||
}
|
||
if containsWhitespace(item.CoverURL) {
|
||
return model.AppBanner{}, errors.New("banner cover cannot contain whitespace")
|
||
}
|
||
if !validBannerDisplayScopes(displayScopes) {
|
||
return model.AppBanner{}, errors.New("banner display scope is invalid")
|
||
}
|
||
if bannerDisplayScopesContain(displayScopes, bannerDisplayScopeRoom) {
|
||
if item.RoomSmallImageURL == "" || len(item.RoomSmallImageURL) > 1024 {
|
||
return model.AppBanner{}, errors.New("room small image is required")
|
||
}
|
||
if containsWhitespace(item.RoomSmallImageURL) {
|
||
return model.AppBanner{}, errors.New("room small image cannot contain whitespace")
|
||
}
|
||
} else {
|
||
// 未投放到房间内时不保留小屏图，避免客户端误用房间专属素材。
|
||
item.RoomSmallImageURL = ""
|
||
}
|
||
if item.BannerType != "h5" && item.BannerType != "app" {
|
||
return model.AppBanner{}, errors.New("banner type is invalid")
|
||
}
|
||
if item.BannerType == "h5" {
|
||
if item.Param == "" {
|
||
return model.AppBanner{}, errors.New("h5 link is required")
|
||
}
|
||
if err := validateH5URL(item.Param); err != nil {
|
||
return model.AppBanner{}, err
|
||
}
|
||
}
|
||
if len(item.Param) > 2048 {
|
||
return model.AppBanner{}, errors.New("banner param is too long")
|
||
}
|
||
if item.Status != bannerStatusActive && item.Status != bannerStatusDisabled && item.Status != bannerStatusExpired {
|
||
return model.AppBanner{}, errors.New("banner status is invalid")
|
||
}
|
||
if item.StartsAtMS < 0 || item.EndsAtMS < 0 {
|
||
return model.AppBanner{}, errors.New("banner delivery time is invalid")
|
||
}
|
||
if item.StartsAtMS > 0 && item.EndsAtMS > 0 && item.StartsAtMS >= item.EndsAtMS {
|
||
return model.AppBanner{}, errors.New("banner delivery time range is invalid")
|
||
}
|
||
if item.Status == bannerStatusActive && item.EndsAtMS > 0 && item.EndsAtMS <= time.Now().UTC().UnixMilli() {
|
||
item.Status = bannerStatusExpired
|
||
}
|
||
if item.Platform != "android" && item.Platform != "ios" {
|
||
return model.AppBanner{}, errors.New("banner platform is invalid")
|
||
}
|
||
if item.RegionID < 0 {
|
||
return model.AppBanner{}, errors.New("banner region is invalid")
|
||
}
|
||
if item.CountryCode != "" && !validCountryCode(item.CountryCode) {
|
||
return model.AppBanner{}, errors.New("banner country is invalid")
|
||
}
|
||
if utf8.RuneCountInString(item.Description) > 255 {
|
||
return model.AppBanner{}, errors.New("banner description is too long")
|
||
}
|
||
return item, nil
|
||
}
|
||
|
||
func appBannerFromModel(item model.AppBanner) AppBanner {
|
||
return AppBanner{
|
||
ID: item.ID,
|
||
AppCode: item.AppCode,
|
||
CoverURL: item.CoverURL,
|
||
RoomSmallImageURL: item.RoomSmallImageURL,
|
||
BannerType: item.BannerType,
|
||
DisplayScope: item.DisplayScope,
|
||
DisplayScopes: bannerDisplayScopeList(item.DisplayScope),
|
||
Param: item.Param,
|
||
Status: item.Status,
|
||
Platform: item.Platform,
|
||
SortOrder: item.SortOrder,
|
||
RegionID: item.RegionID,
|
||
CountryCode: item.CountryCode,
|
||
Description: item.Description,
|
||
StartsAtMs: item.StartsAtMS,
|
||
EndsAtMs: item.EndsAtMS,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
UpdatedAtMs: item.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func splashScreenModelFromRequest(appCode string, req splashScreenRequest) (model.AppSplashScreen, error) {
|
||
item := model.AppSplashScreen{
|
||
AppCode: appctx.Normalize(appCode),
|
||
CoverURL: strings.TrimSpace(req.CoverURL),
|
||
SplashType: normalizeSplashType(req.SplashType),
|
||
Param: strings.TrimSpace(req.Param),
|
||
Status: normalizeBannerStatus(req.Status),
|
||
Platform: normalizeBannerPlatform(req.Platform),
|
||
SortOrder: req.SortOrder,
|
||
RegionID: req.RegionID,
|
||
CountryCode: normalizeCountryCode(req.CountryCode),
|
||
Description: strings.TrimSpace(req.Description),
|
||
DisplayDurationMS: normalizeSplashDisplayDurationMS(req.DisplayDurationMs),
|
||
StartsAtMS: req.StartsAtMs,
|
||
EndsAtMS: req.EndsAtMs,
|
||
}
|
||
if item.CoverURL == "" || len(item.CoverURL) > 1024 {
|
||
return model.AppSplashScreen{}, errors.New("splash cover is invalid")
|
||
}
|
||
if containsWhitespace(item.CoverURL) {
|
||
return model.AppSplashScreen{}, errors.New("splash cover cannot contain whitespace")
|
||
}
|
||
if item.SplashType != "h5" && item.SplashType != "app" {
|
||
return model.AppSplashScreen{}, errors.New("splash type is invalid")
|
||
}
|
||
if item.SplashType == "h5" {
|
||
// H5 开屏必须带可直接打开的链接；APP 类型参数由客户端解释，所以只做长度限制。
|
||
if item.Param == "" {
|
||
return model.AppSplashScreen{}, errors.New("h5 link is required")
|
||
}
|
||
if err := validateH5URL(item.Param); err != nil {
|
||
return model.AppSplashScreen{}, err
|
||
}
|
||
}
|
||
if len(item.Param) > 2048 {
|
||
return model.AppSplashScreen{}, errors.New("splash param is too long")
|
||
}
|
||
if item.Status != bannerStatusActive && item.Status != bannerStatusDisabled && item.Status != bannerStatusExpired {
|
||
return model.AppSplashScreen{}, errors.New("splash status is invalid")
|
||
}
|
||
if item.StartsAtMS < 0 || item.EndsAtMS < 0 {
|
||
return model.AppSplashScreen{}, errors.New("splash delivery time is invalid")
|
||
}
|
||
if item.StartsAtMS > 0 && item.EndsAtMS > 0 && item.StartsAtMS >= item.EndsAtMS {
|
||
return model.AppSplashScreen{}, errors.New("splash delivery time range is invalid")
|
||
}
|
||
if item.Status == bannerStatusActive && item.EndsAtMS > 0 && item.EndsAtMS <= time.Now().UTC().UnixMilli() {
|
||
// 管理员保存已经结束的 active 配置时直接落为 expired，列表和 App 侧都不会误判为可投放。
|
||
item.Status = bannerStatusExpired
|
||
}
|
||
if item.Platform != "android" && item.Platform != "ios" {
|
||
return model.AppSplashScreen{}, errors.New("splash platform is invalid")
|
||
}
|
||
if item.RegionID < 0 {
|
||
return model.AppSplashScreen{}, errors.New("splash region is invalid")
|
||
}
|
||
if item.CountryCode != "" && !validCountryCode(item.CountryCode) {
|
||
return model.AppSplashScreen{}, errors.New("splash country is invalid")
|
||
}
|
||
if utf8.RuneCountInString(item.Description) > 255 {
|
||
return model.AppSplashScreen{}, errors.New("splash description is too long")
|
||
}
|
||
if req.DisplayDurationMs < 0 {
|
||
return model.AppSplashScreen{}, errors.New("splash display duration is invalid")
|
||
}
|
||
return item, nil
|
||
}
|
||
|
||
func appSplashScreenFromModel(item model.AppSplashScreen) AppSplashScreen {
|
||
// DTO 只返回后台页面需要的字段，不暴露数据库列名；gateway 另有 snake_case 的 App 输出结构。
|
||
return AppSplashScreen{
|
||
ID: item.ID,
|
||
AppCode: item.AppCode,
|
||
CoverURL: item.CoverURL,
|
||
SplashType: item.SplashType,
|
||
Param: item.Param,
|
||
Status: item.Status,
|
||
Platform: item.Platform,
|
||
SortOrder: item.SortOrder,
|
||
RegionID: item.RegionID,
|
||
CountryCode: item.CountryCode,
|
||
Description: item.Description,
|
||
DisplayDurationMs: item.DisplayDurationMS,
|
||
StartsAtMs: item.StartsAtMS,
|
||
EndsAtMs: item.EndsAtMS,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
UpdatedAtMs: item.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func popupModelFromRequest(appCode string, req popupRequest) (model.AppPopup, error) {
|
||
item := model.AppPopup{
|
||
AppCode: appctx.Normalize(appCode),
|
||
Code: strings.TrimSpace(req.Code),
|
||
Name: strings.TrimSpace(req.Name),
|
||
ImageURL: strings.TrimSpace(req.ImageURL),
|
||
JumpType: normalizeJumpType(req.JumpType),
|
||
JumpURL: strings.TrimSpace(req.JumpURL),
|
||
DisplayPeriodDays: req.DisplayPeriodDays,
|
||
Status: normalizeBannerStatus(req.Status),
|
||
SortOrder: req.SortOrder,
|
||
StartsAtMS: req.StartsAtMs,
|
||
EndsAtMS: req.EndsAtMs,
|
||
}
|
||
if err := validateH5Key(item.Code); err != nil {
|
||
return model.AppPopup{}, errors.New("popup code is invalid")
|
||
}
|
||
if item.Name == "" || utf8.RuneCountInString(item.Name) > 80 {
|
||
return model.AppPopup{}, errors.New("popup name is invalid")
|
||
}
|
||
if len(item.ImageURL) > 1024 {
|
||
return model.AppPopup{}, errors.New("popup image is too long")
|
||
}
|
||
if item.ImageURL != "" && containsWhitespace(item.ImageURL) {
|
||
return model.AppPopup{}, errors.New("popup image cannot contain whitespace")
|
||
}
|
||
if item.JumpType != "h5" && item.JumpType != "app" {
|
||
return model.AppPopup{}, errors.New("popup jump type is invalid")
|
||
}
|
||
if item.JumpURL == "" {
|
||
return model.AppPopup{}, errors.New("popup jump url is required")
|
||
}
|
||
if len(item.JumpURL) > 2048 {
|
||
return model.AppPopup{}, errors.New("popup jump url is too long")
|
||
}
|
||
if item.JumpType == "h5" {
|
||
// H5 弹窗必须是无空白的可打开地址；APP 类型由客户端解释路径，但同样不允许空白字符破坏路由解析。
|
||
if err := validateH5URL(item.JumpURL); err != nil {
|
||
return model.AppPopup{}, err
|
||
}
|
||
} else if containsWhitespace(item.JumpURL) {
|
||
return model.AppPopup{}, errors.New("popup jump url cannot contain whitespace")
|
||
}
|
||
if item.DisplayPeriodDays < 0 {
|
||
return model.AppPopup{}, errors.New("popup display period is invalid")
|
||
}
|
||
if item.Status != bannerStatusActive && item.Status != bannerStatusDisabled && item.Status != bannerStatusExpired {
|
||
return model.AppPopup{}, errors.New("popup status is invalid")
|
||
}
|
||
if item.StartsAtMS < 0 || item.EndsAtMS < 0 {
|
||
return model.AppPopup{}, errors.New("popup effective time is invalid")
|
||
}
|
||
if item.StartsAtMS > 0 && item.EndsAtMS > 0 && item.StartsAtMS >= item.EndsAtMS {
|
||
return model.AppPopup{}, errors.New("popup effective time range is invalid")
|
||
}
|
||
if item.Status == bannerStatusActive && item.EndsAtMS > 0 && item.EndsAtMS <= time.Now().UTC().UnixMilli() {
|
||
// 已经结束的 active 弹窗保存为 expired，App 接口不会再下发，后台也能直接看到过期状态。
|
||
item.Status = bannerStatusExpired
|
||
}
|
||
return item, nil
|
||
}
|
||
|
||
func appPopupFromModel(item model.AppPopup) AppPopup {
|
||
return AppPopup{
|
||
ID: item.ID,
|
||
AppCode: item.AppCode,
|
||
Code: item.Code,
|
||
Name: item.Name,
|
||
ImageURL: item.ImageURL,
|
||
JumpType: item.JumpType,
|
||
JumpURL: item.JumpURL,
|
||
DisplayPeriodDays: item.DisplayPeriodDays,
|
||
Status: item.Status,
|
||
SortOrder: item.SortOrder,
|
||
StartsAtMs: item.StartsAtMS,
|
||
EndsAtMs: item.EndsAtMS,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
UpdatedAtMs: item.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func appVersionModelFromRequest(appCode string, req appVersionRequest) (model.AppVersion, error) {
|
||
item := model.AppVersion{
|
||
AppCode: appctx.Normalize(appCode),
|
||
Platform: normalizeAppPlatform(req.Platform),
|
||
Version: strings.TrimSpace(req.Version),
|
||
BuildNumber: req.BuildNumber,
|
||
ForceUpdate: req.ForceUpdate,
|
||
DownloadURL: strings.TrimSpace(req.DownloadURL),
|
||
Description: strings.TrimSpace(req.Description),
|
||
}
|
||
if item.Platform != "android" && item.Platform != "ios" {
|
||
return model.AppVersion{}, errors.New("app version platform is invalid")
|
||
}
|
||
if item.Version == "" || utf8.RuneCountInString(item.Version) > 40 {
|
||
return model.AppVersion{}, errors.New("app version is invalid")
|
||
}
|
||
if item.BuildNumber <= 0 {
|
||
return model.AppVersion{}, errors.New("app build number is invalid")
|
||
}
|
||
if item.DownloadURL == "" || len(item.DownloadURL) > 2048 {
|
||
return model.AppVersion{}, errors.New("app download url is invalid")
|
||
}
|
||
for _, char := range item.DownloadURL {
|
||
if unicode.IsSpace(char) {
|
||
return model.AppVersion{}, errors.New("app download url cannot contain whitespace")
|
||
}
|
||
}
|
||
if utf8.RuneCountInString(item.Description) > 1000 {
|
||
return model.AppVersion{}, errors.New("app version description is too long")
|
||
}
|
||
return item, nil
|
||
}
|
||
|
||
func appVersionFromModel(item model.AppVersion) AppVersion {
|
||
return AppVersion{
|
||
ID: item.ID,
|
||
AppCode: item.AppCode,
|
||
Platform: item.Platform,
|
||
Version: item.Version,
|
||
BuildNumber: item.BuildNumber,
|
||
ForceUpdate: item.ForceUpdate,
|
||
DownloadURL: item.DownloadURL,
|
||
Description: item.Description,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
UpdatedAtMs: item.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func exploreTabModelFromRequest(appCode string, req exploreTabRequest) (model.AppExploreTab, error) {
|
||
item := model.AppExploreTab{
|
||
AppCode: appctx.Normalize(appCode),
|
||
Tab: strings.TrimSpace(req.Tab),
|
||
H5URL: strings.TrimSpace(req.H5URL),
|
||
Enabled: req.Enabled,
|
||
SortOrder: req.SortOrder,
|
||
}
|
||
if item.Tab == "" || utf8.RuneCountInString(item.Tab) > 40 {
|
||
return model.AppExploreTab{}, errors.New("explore tab is invalid")
|
||
}
|
||
if item.H5URL == "" || len(item.H5URL) > 2048 {
|
||
return model.AppExploreTab{}, errors.New("explore h5 url is invalid")
|
||
}
|
||
if err := validateH5URL(item.H5URL); err != nil {
|
||
return model.AppExploreTab{}, err
|
||
}
|
||
return item, nil
|
||
}
|
||
|
||
func exploreTabFromModel(item model.AppExploreTab) ExploreTab {
|
||
return ExploreTab{
|
||
ID: item.ID,
|
||
AppCode: item.AppCode,
|
||
Tab: item.Tab,
|
||
H5URL: item.H5URL,
|
||
Enabled: item.Enabled,
|
||
SortOrder: item.SortOrder,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
UpdatedAtMs: item.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func normalizeBannerType(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeSplashType(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeJumpType(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeSplashDisplayDurationMS(value int) int {
|
||
// 管理端允许 0 表示“客户端默认 3 秒”，空请求和历史数据都统一补成 3000ms，避免 App 侧拿到缺省字段后出现 0 秒闪退式开屏。
|
||
if value == 0 {
|
||
return splashDefaultDisplayDurationMS
|
||
}
|
||
return value
|
||
}
|
||
|
||
func normalizeBannerStatus(value string) string {
|
||
value = strings.ToLower(strings.TrimSpace(value))
|
||
if value == "" {
|
||
return bannerStatusActive
|
||
}
|
||
return value
|
||
}
|
||
|
||
func normalizeBannerDisplayScope(value string) string {
|
||
value = strings.ToLower(strings.TrimSpace(value))
|
||
switch value {
|
||
case "":
|
||
return bannerDisplayScopeHome
|
||
case bannerDisplayScopeHome, "首页":
|
||
return bannerDisplayScopeHome
|
||
case bannerDisplayScopeRoom, "房间内":
|
||
return bannerDisplayScopeRoom
|
||
case bannerDisplayScopeRecharge, "充值页":
|
||
return bannerDisplayScopeRecharge
|
||
default:
|
||
return value
|
||
}
|
||
}
|
||
|
||
func normalizeBannerDisplayScopes(values []string, fallback string) []string {
|
||
seen := make(map[string]struct{}, len(bannerDisplayScopeOrder))
|
||
for _, value := range values {
|
||
for _, part := range strings.Split(value, ",") {
|
||
scope := normalizeBannerDisplayScope(part)
|
||
if scope == "" {
|
||
continue
|
||
}
|
||
seen[scope] = struct{}{}
|
||
}
|
||
}
|
||
if len(seen) == 0 {
|
||
for _, part := range strings.Split(fallback, ",") {
|
||
scope := normalizeBannerDisplayScope(part)
|
||
if scope == "" {
|
||
continue
|
||
}
|
||
seen[scope] = struct{}{}
|
||
}
|
||
}
|
||
if len(seen) == 0 {
|
||
seen[bannerDisplayScopeHome] = struct{}{}
|
||
}
|
||
out := make([]string, 0, len(seen))
|
||
for _, scope := range bannerDisplayScopeOrder {
|
||
if _, ok := seen[scope]; ok {
|
||
out = append(out, scope)
|
||
delete(seen, scope)
|
||
}
|
||
}
|
||
for scope := range seen {
|
||
out = append(out, scope)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func bannerDisplayScopeList(value string) []string {
|
||
return normalizeBannerDisplayScopes(nil, value)
|
||
}
|
||
|
||
func bannerDisplayScopeValue(scopes []string) string {
|
||
return strings.Join(scopes, ",")
|
||
}
|
||
|
||
func validBannerDisplayScopes(scopes []string) bool {
|
||
if len(scopes) == 0 {
|
||
return false
|
||
}
|
||
for _, scope := range scopes {
|
||
if scope != bannerDisplayScopeHome && scope != bannerDisplayScopeRoom && scope != bannerDisplayScopeRecharge {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func bannerDisplayScopesContain(scopes []string, target string) bool {
|
||
for _, scope := range scopes {
|
||
if scope == target {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func normalizeBannerPlatform(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeAppPlatform(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeCountryCode(value string) string {
|
||
return strings.ToUpper(strings.TrimSpace(value))
|
||
}
|
||
|
||
func containsWhitespace(value string) bool {
|
||
for _, char := range value {
|
||
if unicode.IsSpace(char) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func validCountryCode(value string) bool {
|
||
if len(value) < 2 || len(value) > 3 {
|
||
return false
|
||
}
|
||
for _, char := range value {
|
||
if char < 'A' || char > 'Z' {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|