break
d5bcda94fe
新增 000228 迁移：规则表 tb_package_traffic_alert_rule（每套餐商品至多一条，无软删除，package_id 非部分唯一约束）、达量预警快照表 tb_package_traffic_alert（以主套餐使用记录 + 阈值快照为唯一键， 触发时冻结用量、额度、比例、阈值、到期时间、归属与资产快照），并为 tb_package_usage 新增扫描 范围部分索引 idx_package_usage_alert_scope；down 在预警表存在数据时阻断回滚。 新增规则维护接口 GET/POST/PUT /api/admin/package-traffic-alert-rules（仅超级管理员与平台账号）： 创建校验套餐存在且真流量额度大于零，阈值为 1%～100% 的两位小数；修改只影响后续扫描，不回填也 不改写既有预警快照；全部写操作记录操作者、前后值与时间。 新增每日 06:00（Asia/Shanghai）扫描任务 package:traffic:alert:scan，与套餐临期扫描共用 data_cleanup 队列：按资产汇总当前有效套餐的真流量，分子取使用记录真已用量、分母取使用记录真总量快照，命中 主套餐规则阈值时在同一事务创建预警与可靠通知事件；重复执行以唯一冲突视为已处理，不重复投递， 不建停机锁、不调用运营商。 新增预警列表、详情与异步导出 GET /api/admin/package-traffic-alerts、GET /api/admin/package-traffic-alerts/:id、 POST /api/admin/package-traffic-alerts/export，列表与详情一律读冻结快照；新增通知类型 package.traffic.alert 与受控目标 package_traffic_alert_detail，目标解析仅对超级管理员与平台账号 返回可跳转，越权与不存在统一按资源不可见处理。 同步 OpenAPI（cmd/gendocs、cmd/api/docs.go、pkg/openapi/handlers.go）、审计动作与资源注册、上下文 健康检查证据；归档变更并同步 package-traffic-alert 主 Spec。
170 lines
7.8 KiB
Go
170 lines
7.8 KiB
Go
package notification
|
|
|
|
import (
|
|
"context"
|
|
"math"
|
|
"strconv"
|
|
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"github.com/break/junhong_cmp_fiber/pkg/middleware"
|
|
)
|
|
|
|
// Target 先校验通知属于当前账号，再解析白名单结构化目标并复核当前权限。
|
|
func (q *Query) Target(ctx context.Context, recipientID, notificationID uint) (*dto.NotificationTargetResponse, error) {
|
|
result := &dto.NotificationTargetResponse{}
|
|
if recipientID == 0 || notificationID == 0 {
|
|
return nil, errors.New(errors.CodeInvalidParam)
|
|
}
|
|
var record model.Notification
|
|
err := q.db.WithContext(ctx).Select("ref_type", "ref_id", "ref_key").
|
|
Where("id = ? AND recipient_kind = ? AND recipient_id = ? AND (expires_at IS NULL OR expires_at > ?)",
|
|
notificationID, constants.NotificationRecipientKindAccount, recipientID, q.now().UTC()).Take(&record).Error
|
|
if err == gorm.ErrRecordNotFound {
|
|
return result, nil
|
|
}
|
|
if err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询通知目标失败")
|
|
}
|
|
return q.resolveTarget(ctx, record)
|
|
}
|
|
|
|
func (q *Query) resolveTarget(ctx context.Context, record model.Notification) (*dto.NotificationTargetResponse, error) {
|
|
definition, exists := notificationTargetDefinitions()[record.RefType]
|
|
if !exists {
|
|
return &dto.NotificationTargetResponse{}, nil
|
|
}
|
|
result := &dto.NotificationTargetResponse{TargetType: definition.targetType}
|
|
if definition.keyTarget {
|
|
result.TargetKey = record.RefKey
|
|
}
|
|
if definition.idTarget {
|
|
id, valid := parseNotificationTargetID(record.RefID)
|
|
if !valid {
|
|
return result, nil
|
|
}
|
|
result.TargetID = &id
|
|
}
|
|
available, err := definition.available(q, ctx, record, result.TargetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result.Available = available
|
|
return result, nil
|
|
}
|
|
|
|
type targetDefinition struct {
|
|
targetType string
|
|
idTarget bool
|
|
keyTarget bool
|
|
available func(*Query, context.Context, model.Notification, *uint) (bool, error)
|
|
}
|
|
|
|
func notificationTargetDefinitions() map[string]targetDefinition {
|
|
return map[string]targetDefinition{
|
|
constants.NotificationRefTypeRefund: {targetType: constants.NotificationTargetTypeRefundDetail, idTarget: true, available: refundTargetAvailable},
|
|
constants.NotificationRefTypeAgentRecharge: {targetType: constants.NotificationTargetTypeAgentRechargeDetail, idTarget: true, available: unavailableFutureTarget},
|
|
constants.NotificationRefTypeWeComApproval: {targetType: constants.NotificationTargetTypeWeComApprovalDetail, idTarget: true, available: unavailableFutureTarget},
|
|
constants.NotificationRefTypeIotCard: {targetType: constants.NotificationTargetTypeIotCardDetail, idTarget: true, available: iotCardTargetAvailable},
|
|
constants.NotificationRefTypeDevice: {targetType: constants.NotificationTargetTypeDeviceDetail, idTarget: true, available: deviceTargetAvailable},
|
|
constants.NotificationRefTypeExpiringAsset: {targetType: constants.NotificationTargetTypeExpiringAssetList, idTarget: true, available: shopTargetAvailable},
|
|
constants.NotificationRefTypeShopFund: {targetType: constants.NotificationTargetTypeShopFundSummary, idTarget: true, available: shopTargetAvailable},
|
|
constants.NotificationRefTypeIntegrationLog: {targetType: constants.NotificationTargetTypeIntegrationLog, keyTarget: true, available: integrationTargetAvailable},
|
|
constants.NotificationRefTypeCardSync: {targetType: constants.NotificationTargetTypeIntegrationLog, keyTarget: true, available: integrationTargetAvailable},
|
|
constants.NotificationRefTypeSystemConfig: {targetType: constants.NotificationTargetTypeSystemConfig, keyTarget: true, available: systemConfigTargetAvailable},
|
|
// 套餐真流量达量预警：仅超级管理员与平台账号可见，目标为预警详情，不返回 URL。
|
|
constants.NotificationRefTypePackageTrafficAlert: {targetType: constants.NotificationTargetTypePackageTrafficAlertDetail, idTarget: true, available: packageTrafficAlertTargetAvailable},
|
|
}
|
|
}
|
|
|
|
// packageTrafficAlertTargetAvailable 复核当前账号是否仍可查看该预警详情。
|
|
// 预警只对超级管理员与平台账号开放；其他身份的账号即使持有通知也不可跳转。
|
|
func packageTrafficAlertTargetAvailable(q *Query, ctx context.Context, _ model.Notification, id *uint) (bool, error) {
|
|
userType := middleware.GetUserTypeFromContext(ctx)
|
|
if userType != constants.UserTypeSuperAdmin && userType != constants.UserTypePlatform {
|
|
return false, nil
|
|
}
|
|
query := q.db.WithContext(ctx).Model(&model.PackageTrafficAlert{}).Where("id = ?", *id)
|
|
return targetExists(query, "查询套餐真流量达量预警通知目标失败")
|
|
}
|
|
|
|
func parseNotificationTargetID(value string) (uint, bool) {
|
|
parsed, err := strconv.ParseUint(value, 10, 64)
|
|
if err != nil || parsed == 0 || parsed > math.MaxInt64 {
|
|
return 0, false
|
|
}
|
|
return uint(parsed), true
|
|
}
|
|
|
|
func refundTargetAvailable(q *Query, ctx context.Context, _ model.Notification, id *uint) (bool, error) {
|
|
query := q.db.WithContext(ctx).Model(&model.RefundRequest{}).Where("id = ?", *id)
|
|
switch middleware.GetUserTypeFromContext(ctx) {
|
|
case constants.UserTypeSuperAdmin, constants.UserTypePlatform:
|
|
case constants.UserTypeAgent:
|
|
query = query.Where("creator = ?", middleware.GetUserIDFromContext(ctx))
|
|
default:
|
|
return false, nil
|
|
}
|
|
return targetExists(query, "查询退款通知目标失败")
|
|
}
|
|
|
|
func iotCardTargetAvailable(q *Query, ctx context.Context, _ model.Notification, id *uint) (bool, error) {
|
|
if middleware.GetUserTypeFromContext(ctx) == constants.UserTypeEnterprise {
|
|
return false, nil
|
|
}
|
|
query := middleware.ApplyShopFilter(ctx, q.db.WithContext(ctx).Model(&model.IotCard{})).Where("id = ?", *id)
|
|
return targetExists(query, "查询物联网卡通知目标失败")
|
|
}
|
|
|
|
func deviceTargetAvailable(q *Query, ctx context.Context, _ model.Notification, id *uint) (bool, error) {
|
|
if middleware.GetUserTypeFromContext(ctx) == constants.UserTypeEnterprise {
|
|
return false, nil
|
|
}
|
|
query := middleware.ApplyShopFilter(ctx, q.db.WithContext(ctx).Model(&model.Device{})).Where("id = ?", *id)
|
|
return targetExists(query, "查询设备通知目标失败")
|
|
}
|
|
|
|
func shopTargetAvailable(q *Query, ctx context.Context, _ model.Notification, id *uint) (bool, error) {
|
|
if err := middleware.CanManageShop(ctx, *id); err != nil {
|
|
return false, nil
|
|
}
|
|
query := middleware.ApplyShopIDFilter(ctx, q.db.WithContext(ctx).Model(&model.Shop{})).Where("id = ?", *id)
|
|
return targetExists(query, "查询店铺通知目标失败")
|
|
}
|
|
|
|
func integrationTargetAvailable(q *Query, ctx context.Context, record model.Notification, _ *uint) (bool, error) {
|
|
userType := middleware.GetUserTypeFromContext(ctx)
|
|
if userType != constants.UserTypeSuperAdmin && userType != constants.UserTypePlatform {
|
|
return false, nil
|
|
}
|
|
if record.RefKey == "" {
|
|
return false, nil
|
|
}
|
|
query := q.db.WithContext(ctx).Model(&model.IntegrationLog{}).Where("integration_id = ?", record.RefKey)
|
|
return targetExists(query, "查询外部集成通知目标失败")
|
|
}
|
|
|
|
func systemConfigTargetAvailable(q *Query, ctx context.Context, record model.Notification, _ *uint) (bool, error) {
|
|
if middleware.GetUserTypeFromContext(ctx) != constants.UserTypeSuperAdmin || record.RefKey == "" {
|
|
return false, nil
|
|
}
|
|
query := q.db.WithContext(ctx).Model(&model.SystemConfig{}).Where("config_key = ?", record.RefKey)
|
|
return targetExists(query, "查询系统配置通知目标失败")
|
|
}
|
|
|
|
func unavailableFutureTarget(_ *Query, _ context.Context, _ model.Notification, _ *uint) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func targetExists(query *gorm.DB, summary string) (bool, error) {
|
|
var count int64
|
|
if err := query.Count(&count).Error; err != nil {
|
|
return false, errors.Wrap(errors.CodeDatabaseError, err, summary)
|
|
}
|
|
return count > 0, nil
|
|
}
|