fiee/micro-bundle
8
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加每月余量更新

Browse Source
This commit is contained in:
lzh 2025-10-13 14:15:37 +08:00
parent ea00e1e361
commit cae2e19a96
8 changed files with 1000 additions and 892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/app.go
View File

@ -5,6 +5,7 @@ import (
"micro-bundle/internal/controller" "micro-bundle/internal/controller"
_ "micro-bundle/internal/handler" _ "micro-bundle/internal/handler"
"micro-bundle/pkg/app" "micro-bundle/pkg/app"
"micro-bundle/pkg/cron"
"micro-bundle/pkg/db" "micro-bundle/pkg/db"
"micro-bundle/pkg/tracing" "micro-bundle/pkg/tracing"
@ -47,6 +48,7 @@ func main() {
if err = config.Load(); err != nil { if err = config.Load(); err != nil {
panic(err) panic(err)
} }
cron.InitCronJob() // 定时任务
select {} select {}
// dao.AddBundleExtendRecord(model.BundleExtensionRecords{ // dao.AddBundleExtendRecord(model.BundleExtensionRecords{
// UserId: 57, // UserId: 57,

145
internal/dao/bundleExtend.go
View File

@ -183,158 +183,171 @@ func GetBundleBalanceByUserId(req *bundle.GetBundleBalanceByUserIdReq) (data mod
return return
} }
func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) error { func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err error) {
return app.ModuleClients.BundleDB.Transaction(func(tx *gorm.DB) error { err = app.ModuleClients.BundleDB.Transaction(func(tx *gorm.DB) (err error) {
oldData := model.BundleBalance{} oldData := model.BundleBalance{}
if err := tx.Model(&model.BundleBalance{}).Where("user_id = ?", data.UserId).Order("created_at desc").First(&oldData).Error; err != nil { if err := tx.Model(&model.BundleBalance{}).Where("user_id = ?", data.UserId).Where("month = ?", time.Now().Format("2006-01")).Order("created_at desc").First(&oldData).Error; err != nil {
return errors.New("用户还没有套餐信息") return errors.New("用户还没有套餐信息")
} }
if data.AccountNumber > 0 { // 增加账号消耗数 if data.AccountNumber > 0 { // 增加账号消耗数
for range data.AccountNumber {
if oldData.BundleAccountConsumptionNumber < oldData.BundleAccountNumber { // 消耗账号数优先套餐内 if oldData.BundleAccountConsumptionNumber < oldData.BundleAccountNumber { // 消耗账号数优先套餐内
oldData.BundleAccountConsumptionNumber++ oldData.BundleAccountConsumptionNumber++
continue usedType = 1
goto Over
} }
if oldData.IncreaseAccountConsumptionNumber < oldData.IncreaseAccountNumber { // 其次消耗增值的 if oldData.IncreaseAccountConsumptionNumber < oldData.IncreaseAccountNumber { // 其次消耗增值的
oldData.IncreaseAccountConsumptionNumber++ oldData.IncreaseAccountConsumptionNumber++
continue usedType = 2
goto Over
} }
return errors.New("账号数不足") return errors.New("账号数不足")
} } else if data.AccountNumber < 0 { // 减少账号消耗数，用于解绑账号
} else { // 减少账号消耗数，用于解绑账号
for range -data.AccountNumber {
if oldData.IncreaseAccountConsumptionNumber > 0 { if oldData.IncreaseAccountConsumptionNumber > 0 {
oldData.IncreaseAccountConsumptionNumber-- oldData.IncreaseAccountConsumptionNumber--
continue usedType = 2
goto Over
} }
if oldData.BundleAccountConsumptionNumber > 0 { if oldData.BundleAccountConsumptionNumber > 0 {
oldData.BundleAccountConsumptionNumber-- oldData.BundleAccountConsumptionNumber--
continue usedType = 1
goto Over
} }
return errors.New("当前未绑定账号") return errors.New("当前未绑定账号")
} }
} if data.VideoNumber > 0 {
for range data.VideoNumber {
if oldData.MonthlyLimitVideoExpireNumber > oldData.MonthlyLimitVideoExpireConsumptionNumber { // 当月可使用的会过期的限制类型充足 if oldData.MonthlyLimitVideoExpireNumber > oldData.MonthlyLimitVideoExpireConsumptionNumber { // 当月可使用的会过期的限制类型充足
if oldData.BundleLimitVideoExpiredConsumptionNumber < oldData.BundleLimitVideoExpiredNumber { // 套餐内会过期的限制类型视频充足 if oldData.BundleLimitVideoExpiredConsumptionNumber < oldData.BundleLimitVideoExpiredNumber { // 套餐内会过期的限制类型视频充足
oldData.MonthlyLimitVideoExpireConsumptionNumber++ oldData.MonthlyLimitVideoExpireConsumptionNumber++
oldData.BundleLimitVideoExpiredConsumptionNumber++ oldData.BundleLimitVideoExpiredConsumptionNumber++
continue usedType = 1
goto Over
} }
if oldData.IncreaseLimitVideoExpiredConsumptionNumber < oldData.IncreaseLimitVideoExpiredNumber { // 增值服务会过期的限制类型视频充足 if oldData.IncreaseLimitVideoExpiredConsumptionNumber < oldData.IncreaseLimitVideoExpiredNumber { // 增值服务会过期的限制类型视频充足
oldData.MonthlyLimitVideoExpireConsumptionNumber++ oldData.MonthlyLimitVideoExpireConsumptionNumber++
oldData.IncreaseLimitVideoExpiredConsumptionNumber++ oldData.IncreaseLimitVideoExpiredConsumptionNumber++
continue usedType = 2
goto Over
} }
} }
if oldData.MonthlyLimitVideoNumber > oldData.MonthlyLimitVideoConsumptionNumber { // 当月可使用的不过期的限制类型充足 if oldData.MonthlyLimitVideoNumber > oldData.MonthlyLimitVideoConsumptionNumber { // 当月可使用的不过期的限制类型充足
if oldData.BundleLimitVideoConsumptionNumber < oldData.BundleLimitVideoNumber { // 套餐内不过期的限制类型视频充足 if oldData.BundleLimitVideoConsumptionNumber < oldData.BundleLimitVideoNumber { // 套餐内不过期的限制类型视频充足
oldData.MonthlyLimitVideoConsumptionNumber++ oldData.MonthlyLimitVideoConsumptionNumber++
oldData.BundleLimitVideoConsumptionNumber++ oldData.BundleLimitVideoConsumptionNumber++
continue usedType = 1
goto Over
} }
if oldData.IncreaseLimitVideoConsumptionNumber < oldData.IncreaseLimitVideoNumber { // 增值服务不过期的限制类型视频充足 if oldData.IncreaseLimitVideoConsumptionNumber < oldData.IncreaseLimitVideoNumber { // 增值服务不过期的限制类型视频充足
oldData.MonthlyLimitVideoConsumptionNumber++ oldData.MonthlyLimitVideoConsumptionNumber++
oldData.IncreaseLimitVideoConsumptionNumber++ oldData.IncreaseLimitVideoConsumptionNumber++
continue usedType = 2
goto Over
} }
} }
if oldData.BundleVideoConsumptionNumber < oldData.BundleVideoNumber { //套餐内非限制类型的视频充足 if oldData.BundleVideoConsumptionNumber < oldData.BundleVideoNumber { //套餐内非限制类型的视频充足
oldData.BundleVideoConsumptionNumber++ oldData.BundleVideoConsumptionNumber++
continue usedType = 1
goto Over
} }
if oldData.IncreaseVideoConsumptionNumber < oldData.IncreaseVideoNumber { //增值服务非限制类型的视频充足 if oldData.IncreaseVideoConsumptionNumber < oldData.IncreaseVideoNumber { //增值服务非限制类型的视频充足
oldData.IncreaseVideoConsumptionNumber++ oldData.IncreaseVideoConsumptionNumber++
continue usedType = 2
goto Over
} }
if oldData.ManualVideoConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足 if oldData.ManualVideoConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足
oldData.ManualVideoConsumptionNumber++ oldData.ManualVideoConsumptionNumber++
oldData.MonthlyManualVideoConsumptionNumber++ // 记录本月使用的手动扩展 oldData.MonthlyManualVideoConsumptionNumber++ // 记录本月使用的手动扩展
continue usedType = 3
goto Over
} }
return errors.New("可用视频数不足") return errors.New("可用视频数不足")
} }
for range data.ImageNumber { if data.ImageNumber > 0 {
if oldData.MonthlyLimitImageConsumptionNumber < oldData.MonthlyLimitImageNumber { // 限制类型图文可用额度充足 if oldData.MonthlyLimitImageExpireNumber > oldData.MonthlyLimitImageExpireConsumptionNumber { // 当月可使用的会过期的限制类型充足
if oldData.BundleLimitImageExpiredConsumptionNumber < oldData.BundleLimitImageExpiredNumber { // 套餐内会过期的限制类型图文充足 if oldData.BundleLimitImageExpiredConsumptionNumber < oldData.BundleLimitImageExpiredNumber { // 套餐内会过期的限制类型图文充足
oldData.MonthlyLimitImageExpireConsumptionNumber++
oldData.BundleLimitImageExpiredConsumptionNumber++ oldData.BundleLimitImageExpiredConsumptionNumber++
oldData.MonthlyLimitImageConsumptionNumber++ goto Over
continue
} }
if oldData.IncreaseLimitImageExpiredConsumptionNumber < oldData.IncreaseLimitImageExpiredNumber { // 增值服务会过期的限制类型图文充足 if oldData.IncreaseLimitImageExpiredConsumptionNumber < oldData.IncreaseLimitImageExpiredNumber { // 增值服务会过期的限制类型图文充足
oldData.MonthlyLimitImageExpireConsumptionNumber++
oldData.IncreaseLimitImageExpiredConsumptionNumber++ oldData.IncreaseLimitImageExpiredConsumptionNumber++
oldData.MonthlyLimitImageConsumptionNumber++ goto Over
continue
} }
if oldData.BundleLimitImageConsumptionNumber < oldData.BundleLimitImageNumber { // 套餐内不会过期的限制类型图文充足 }
if oldData.MonthlyLimitImageNumber > oldData.MonthlyLimitImageConsumptionNumber { // 当月可使用的不过期的限制类型充足
if oldData.BundleLimitImageConsumptionNumber < oldData.BundleLimitImageNumber { // 套餐内不过期的限制类型图文充足
oldData.MonthlyLimitImageConsumptionNumber++
oldData.BundleLimitImageConsumptionNumber++ oldData.BundleLimitImageConsumptionNumber++
oldData.MonthlyLimitImageConsumptionNumber++ goto Over
continue
} }
if oldData.IncreaseLimitImageConsumptionNumber < oldData.IncreaseLimitImageNumber { // 增值服务不会过期的限制类型图文充足 if oldData.IncreaseLimitImageConsumptionNumber < oldData.IncreaseLimitImageNumber { // 增值服务不过期的限制类型图文充足
oldData.IncreaseLimitImageConsumptionNumber++
oldData.MonthlyLimitImageConsumptionNumber++ oldData.MonthlyLimitImageConsumptionNumber++
continue oldData.IncreaseLimitImageConsumptionNumber++
goto Over
} }
} }
if oldData.BundleImageConsumptionNumber < oldData.BundleImageNumber { //套餐内非限制类型的图文充足 if oldData.BundleImageConsumptionNumber < oldData.BundleImageNumber { //套餐内非限制类型的图文充足
oldData.BundleImageConsumptionNumber++ oldData.BundleImageConsumptionNumber++
continue goto Over
} }
if oldData.IncreaseImageConsumptionNumber < oldData.IncreaseImageNumber { //增值服务非限制类型的图文充足 if oldData.IncreaseImageConsumptionNumber < oldData.IncreaseImageNumber { //增值服务非限制类型的图文充足
oldData.IncreaseImageConsumptionNumber++ oldData.IncreaseImageConsumptionNumber++
continue goto Over
} }
if oldData.ManualImageConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足 if oldData.ManualImageConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足
oldData.ManualImageConsumptionNumber++ oldData.ManualImageConsumptionNumber++
oldData.MonthlyManualImageConsumptionNumber++ // 记录本月使用的手动扩展 oldData.MonthlyManualImageConsumptionNumber++ // 记录本月使用的手动扩展
continue goto Over
} }
return errors.New("可用图文数不足") return errors.New("可用图文数不足")
} }
for range data.DataAnalysisNumber { if data.DataAnalysisNumber > 0 {
if oldData.MonthlyLimitDataAnalysisConsumptionNumber < oldData.MonthlyLimitDataAnalysisNumber { // 限制类型数据分析可用额度充足 if oldData.MonthlyLimitDataAnalysisExpireNumber > oldData.MonthlyLimitDataAnalysisExpireConsumptionNumber { // 当月可使用的会过期的限制类型充足
if oldData.BundleLimitDataAnalysisExpiredConsumptionNumber < oldData.BundleLimitDataAnalysisExpiredNumber { // 套餐内会过期的限制类型数据分析充足 if oldData.BundleLimitDataAnalysisExpiredConsumptionNumber < oldData.BundleLimitDataAnalysisExpiredNumber { // 套餐内会过期的限制类型数据分析充足
oldData.MonthlyLimitDataAnalysisExpireConsumptionNumber++
oldData.BundleLimitDataAnalysisExpiredConsumptionNumber++ oldData.BundleLimitDataAnalysisExpiredConsumptionNumber++
oldData.MonthlyLimitDataAnalysisConsumptionNumber++ goto Over
continue
} }
if oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber < oldData.IncreaseLimitDataAnalysisExpiredNumber { // 增值服务会过期的限制类型数据分析充足 if oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber < oldData.IncreaseLimitDataAnalysisExpiredNumber { // 增值服务会过期的限制类型数据分析充足
oldData.MonthlyLimitDataAnalysisExpireConsumptionNumber++
oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber++ oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber++
oldData.MonthlyLimitDataAnalysisConsumptionNumber++ goto Over
continue
} }
if oldData.BundleLimitDataAnalysisConsumptionNumber < oldData.BundleLimitDataAnalysisNumber { // 套餐内不会过期的限制类型数据分析充足 }
if oldData.MonthlyLimitDataAnalysisNumber > oldData.MonthlyLimitDataAnalysisConsumptionNumber { // 当月可使用的不过期的限制类型充足
if oldData.BundleLimitDataAnalysisConsumptionNumber < oldData.BundleLimitDataAnalysisNumber { // 套餐内不过期的限制类型数据分析充足
oldData.MonthlyLimitDataAnalysisConsumptionNumber++
oldData.BundleLimitDataAnalysisConsumptionNumber++ oldData.BundleLimitDataAnalysisConsumptionNumber++
oldData.MonthlyLimitDataAnalysisConsumptionNumber++ goto Over
continue
} }
if oldData.IncreaseLimitDataAnalysisConsumptionNumber < oldData.IncreaseLimitDataAnalysisNumber { // 增值服务不会过期的限制类型数据分析充足 if oldData.IncreaseLimitDataAnalysisConsumptionNumber < oldData.IncreaseLimitDataAnalysisNumber { // 增值服务不过期的限制类型数据分析充足
oldData.IncreaseLimitDataAnalysisConsumptionNumber++
oldData.MonthlyLimitDataAnalysisConsumptionNumber++ oldData.MonthlyLimitDataAnalysisConsumptionNumber++
continue oldData.IncreaseLimitDataAnalysisConsumptionNumber++
goto Over
} }
} }
if oldData.BundleLimitDataAnalysisNumber < oldData.BundleDataAnalysisNumber { //套餐内非限制类型的数据分析充足 if oldData.BundleLimitDataAnalysisNumber < oldData.BundleDataAnalysisNumber { //套餐内非限制类型的数据分析充足
oldData.BundleLimitDataAnalysisNumber++ oldData.BundleLimitDataAnalysisNumber++
continue goto Over
} }
if oldData.IncreaseDataAnalysisConsumptionNumber < oldData.IncreaseDataAnalysisNumber { //增值服务非限制类型的数据分析充足 if oldData.IncreaseDataAnalysisConsumptionNumber < oldData.IncreaseDataAnalysisNumber { //增值服务非限制类型的数据分析充足
oldData.IncreaseDataAnalysisConsumptionNumber++ oldData.IncreaseDataAnalysisConsumptionNumber++
continue goto Over
} }
if oldData.ManualDataAnalysisConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足 if oldData.ManualDataAnalysisConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足
oldData.ManualDataAnalysisConsumptionNumber++ oldData.ManualDataAnalysisConsumptionNumber++
oldData.MonthlyManualDataAnalysisConsumptionNumber++ // 记录本月使用的手动扩展 oldData.MonthlyManualDataAnalysisConsumptionNumber++ // 记录本月使用的手动扩展
continue goto Over
} }
return errors.New("可用数据分析数不足") return errors.New("可用数据分析数不足")
} }
Over:
return tx.Model(&model.BundleBalance{}).Where("id = ?", oldData.ID).Save(&oldData).Error return tx.Model(&model.BundleBalance{}).Where("id = ?", oldData.ID).Save(&oldData).Error
}) })
return
} }
func CreateUsedRecord(tx *gorm.DB, data model.BundleUsedRecord) error { func CreateUsedRecord(tx *gorm.DB, data model.BundleUsedRecord) error {
@ -499,12 +512,16 @@ inner join (
bb.user_id bb.user_id
) newest on ) newest on
newest.month = bb.month newest.month = bb.month
and bb.user_id = newest.user_id`).Find(&bl).Error; err != nil { and bb.user_id = newest.user_id
and bb.expired_at > now()`).Find(&bl).Error; err != nil {
return err return err
} }
now := time.Now() now := time.Now()
month := time.Now().Format("2006-01") month := time.Now().Format("2006-01")
for _, v := range bl { for _, v := range bl {
if v.Month == month {
continue
}
cal := func(total, limit int) int { // 计算本月发放的限制类型数量 cal := func(total, limit int) int { // 计算本月发放的限制类型数量
var released int // 已释放的次数 var released int // 已释放的次数
@ -527,18 +544,34 @@ inner join (
return min(limit, remaining) return min(limit, remaining)
} }
// 当月可用的限制类型数等于本月方法的套餐和增值两种类型的总和
v.MonthlyLimitVideoExpireNumber = cal(v.BundleLimitVideoExpiredNumber, v.MonthlyLimitVideoQuotaNumber) + cal(v.IncreaseLimitVideoExpiredNumber, v.MonthlyLimitVideoQuotaNumber)
v.MonthlyLimitVideoNumber = cal(v.BundleLimitVideoNumber, v.MonthlyLimitVideoQuotaNumber) + cal(v.IncreaseLimitVideoNumber, v.MonthlyLimitVideoQuotaNumber)
v.MonthlyInvalidBundleVideoNumber = v.MonthlyLimitVideoExpireNumber - v.MonthlyLimitVideoExpireConsumptionNumber // 当月过期的视频数 v.MonthlyInvalidBundleVideoNumber = v.MonthlyLimitVideoExpireNumber - v.MonthlyLimitVideoExpireConsumptionNumber // 当月过期的视频数
v.InvalidBundleVideoNumber += v.MonthlyInvalidBundleVideoNumber v.InvalidBundleVideoNumber += v.MonthlyInvalidBundleVideoNumber
v.MonthlyInvalidBundleImageNumber = v.MonthlyLimitImageExpireNumber - v.MonthlyLimitImageExpireConsumptionNumber
v.InvalidBundleImageNumber += v.MonthlyInvalidBundleImageNumber
v.MonthlyInvalidBundleDataAnalysisNumber = v.MonthlyLimitDataAnalysisExpireNumber - v.MonthlyLimitDataAnalysisExpireConsumptionNumber
v.InvalidBundleDataAnalysisNumber += v.MonthlyInvalidBundleDataAnalysisNumber
v.MonthlyLimitVideoConsumptionNumber = 0 // 当月可用的限制类型数等于本月方法的套餐和增值两种类型的总和
v.MonthlyLimitVideoExpireNumber = cal(v.BundleLimitVideoExpiredNumber, v.MonthlyLimitVideoQuotaNumber) + cal(v.IncreaseLimitVideoExpiredNumber, v.MonthlyLimitVideoQuotaNumber)
v.MonthlyLimitVideoNumber = v.MonthlyLimitVideoNumber - v.MonthlyLimitVideoConsumptionNumber + cal(v.BundleLimitVideoNumber, v.MonthlyLimitVideoQuotaNumber) + cal(v.IncreaseLimitVideoNumber, v.MonthlyLimitVideoQuotaNumber)
v.MonthlyLimitImageExpireNumber = cal(v.BundleLimitImageExpiredNumber, v.MonthlyLimitImageQuotaNumber) + cal(v.IncreaseLimitImageExpiredNumber, v.MonthlyLimitImageQuotaNumber)
v.MonthlyLimitImageNumber = v.MonthlyLimitImageNumber - v.MonthlyLimitImageConsumptionNumber + cal(v.BundleLimitImageNumber, v.MonthlyLimitImageQuotaNumber) + cal(v.IncreaseLimitImageNumber, v.MonthlyLimitImageQuotaNumber)
v.MonthlyLimitDataAnalysisExpireNumber = cal(v.BundleLimitDataAnalysisExpiredNumber, v.MonthlyLimitDataAnalysisQuotaNumber) + cal(v.IncreaseLimitDataAnalysisExpiredNumber, v.MonthlyLimitDataAnalysisQuotaNumber)
v.MonthlyLimitDataAnalysisNumber = v.MonthlyLimitDataAnalysisNumber - v.MonthlyLimitDataAnalysisConsumptionNumber + cal(v.BundleLimitDataAnalysisNumber, v.MonthlyLimitDataAnalysisQuotaNumber) + cal(v.IncreaseLimitDataAnalysisNumber, v.MonthlyLimitDataAnalysisQuotaNumber)
v.MonthlyLimitVideoConsumptionNumber = 0 // 重置单月消耗数量
v.MonthlyLimitVideoExpireConsumptionNumber = 0 v.MonthlyLimitVideoExpireConsumptionNumber = 0
v.MonthlyManualVideoConsumptionNumber = 0 v.MonthlyManualVideoConsumptionNumber = 0
v.MonthlyLimitImageConsumptionNumber = 0
v.MonthlyLimitImageExpireConsumptionNumber = 0
v.MonthlyManualImageConsumptionNumber = 0
v.MonthlyLimitDataAnalysisConsumptionNumber = 0
v.MonthlyLimitDataAnalysisExpireConsumptionNumber = 0
v.MonthlyManualDataAnalysisConsumptionNumber = 0
v.Month = month v.Month = month
v.ID = 0
app.ModuleClients.BundleDB.Create(&v)
} }
return nil return nil
} }

49
internal/logic/bundleExtendLogic.go
View File

@ -101,7 +101,10 @@ func AddBundleBalance(req *bundle.AddBundleBalanceReq) (*bundle.AddBundleBalance
VideoNumber: int(req.VideoConsumptionNumber), VideoNumber: int(req.VideoConsumptionNumber),
DataAnalysisNumber: int(req.DataAnalysisConsumptionNumber), DataAnalysisNumber: int(req.DataAnalysisConsumptionNumber),
} }
return nil, dao.AddBundleBalanceByUserId(data) uesdType, err := dao.AddBundleBalanceByUserId(data)
return &bundle.AddBundleBalanceResp{
UsedType: uint32(uesdType),
}, err
} }
func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBundleBalanceResp, error) { func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBundleBalanceResp, error) {
@ -125,7 +128,7 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
case 1: // 视频类型 case 1: // 视频类型
if v.EquityType == 1 { // 套餐权益 if v.EquityType == 1 { // 套餐权益
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitVideoNumber = int(v.QuotaValue) data.MonthlyLimitVideoQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.BundleLimitVideoExpiredNumber += int(v.Num) data.BundleLimitVideoExpiredNumber += int(v.Num)
} else { } else {
@ -136,7 +139,7 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
} }
} else { } else {
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitVideoNumber = int(v.QuotaValue) data.MonthlyLimitVideoQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.IncreaseLimitVideoExpiredNumber += int(v.Num) data.IncreaseLimitVideoExpiredNumber += int(v.Num)
} else { } else {
@ -149,7 +152,7 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
case 2: // 图文类型 case 2: // 图文类型
if v.EquityType == 1 { // 套餐权益 if v.EquityType == 1 { // 套餐权益
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitImageNumber = int(v.QuotaValue) data.MonthlyLimitImageQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.BundleLimitImageExpiredNumber += int(v.Num) data.BundleLimitImageExpiredNumber += int(v.Num)
} else { } else {
@ -160,21 +163,20 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
} }
} else { } else {
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitImageNumber = int(v.QuotaValue) data.MonthlyLimitImageQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.IncreaseLimitImageExpiredNumber += int(v.Num) data.IncreaseLimitImageExpiredNumber += int(v.Num)
} else { } else {
data.IncreaseLimitImageNumber += int(v.Num) data.IncreaseLimitImageNumber += int(v.Num)
} }
} else { } else {
data.IncreaseImageNumber += int(v.Num) data.IncreaseImageNumber += int(v.Num)
} }
} }
case 3: // 数据分析 case 3: // 数据分析
if v.EquityType == 1 { // 套餐权益 if v.EquityType == 1 { // 套餐权益
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitDataAnalysisNumber = int(v.QuotaValue) data.MonthlyLimitDataAnalysisQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.BundleLimitDataAnalysisExpiredNumber += int(v.Num) data.BundleLimitDataAnalysisExpiredNumber += int(v.Num)
} else { } else {
@ -185,7 +187,7 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
} }
} else { } else {
if v.QuotaType == 2 { // 限制额度 if v.QuotaType == 2 { // 限制额度
data.MonthlyLimitDataAnalysisNumber = int(v.QuotaValue) data.MonthlyLimitDataAnalysisQuotaNumber = int(v.QuotaValue)
if v.IsExpired { // 会过期的限制类型 if v.IsExpired { // 会过期的限制类型
data.IncreaseLimitDataAnalysisExpiredNumber += int(v.Num) data.IncreaseLimitDataAnalysisExpiredNumber += int(v.Num)
} else { } else {
@ -213,6 +215,35 @@ func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBund
} }
} }
} }
now := time.Now()
cal := func(total, limit int) int { // 计算本月发放的限制类型数量
var released int // 已释放的次数
if data.StartAt.Month() == now.Month() && data.StartAt.Year() == now.Year() {
} else if data.StartAt.Day() >= 16 { //第一个月释放的
released += limit/2 + 1
} else {
released += limit
}
interval := now.Year()*12 + int(now.Month()) - (data.StartAt.Year()*12 + int(data.StartAt.Month())) // 后续月份释放的
released += interval * limit
remaining := max(total-released, 0) // 还剩余多少次没有发放
if data.StartAt.Month() == now.Month() && data.StartAt.Year() == now.Year() && data.StartAt.Day() >= 16 { // 本月为第一个月并且16号后购买只给一半（向上取整）
return min(limit/2+1, remaining)
}
if data.ExpiredAt.Month() == now.Month() && data.ExpiredAt.Year() == now.Year() && data.ExpiredAt.Day() < 16 { // 本月为最后一个月并且16号前到期只给一半（向下取整）
return min(limit/2, remaining)
}
return min(limit, remaining)
}
// 当月可用的限制类型数等于本月方法的套餐和增值两种类型的总和
data.MonthlyLimitVideoExpireNumber = cal(data.BundleLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber) + cal(data.IncreaseLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber)
data.MonthlyLimitVideoNumber = cal(data.BundleLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber) + cal(data.IncreaseLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber)
data.MonthlyLimitImageExpireNumber = cal(data.BundleLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber) + cal(data.IncreaseLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber)
data.MonthlyLimitImageNumber = cal(data.BundleLimitImageNumber, data.MonthlyLimitImageQuotaNumber) + cal(data.IncreaseLimitImageNumber, data.MonthlyLimitImageQuotaNumber)
data.MonthlyLimitDataAnalysisExpireNumber = cal(data.BundleLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber) + cal(data.IncreaseLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber)
data.MonthlyLimitDataAnalysisNumber = cal(data.BundleLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber) + cal(data.IncreaseLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber)
err = dao.CreateBundleBalance(data) err = dao.CreateBundleBalance(data)
if err != nil { if err != nil {
@ -290,5 +321,5 @@ func BundleActivate(req *bundle.BundleActivateReq) error {
} }
func UpdateBundleBalance() { func UpdateBundleBalance() {
dao.UpdateBundleBalance()
} }

1
internal/logic/bundleLogic.go
View File

@ -636,6 +636,7 @@ func diffUpdateBundleToValueAddService(tx *gorm.DB, bundleUuid string, selectSer
} }
return nil return nil
} }
func saveBundleHistory(tx *gorm.DB, bundleUuid string, operator string, operatorId uint64) error { func saveBundleHistory(tx *gorm.DB, bundleUuid string, operator string, operatorId uint64) error {
// 保存历史记录 // 保存历史记录
data, err := dao.GetBundleDetailByUuid(bundleUuid) data, err := dao.GetBundleDetailByUuid(bundleUuid)

6
internal/model/bundle.go
View File

@ -242,6 +242,9 @@ type BundleBalance struct {
IncreaseLimitImageExpiredConsumptionNumber int `gorm:"column:increase_limit_image_expired_consumption_number;not null;comment:增值权益限制类型会过期使用数"` IncreaseLimitImageExpiredConsumptionNumber int `gorm:"column:increase_limit_image_expired_consumption_number;not null;comment:增值权益限制类型会过期使用数"`
MonthlyLimitImageNumber int `gorm:"column:monthly_limit_image_number;not null;comment:当月限制类型图片可使用额度"` MonthlyLimitImageNumber int `gorm:"column:monthly_limit_image_number;not null;comment:当月限制类型图片可使用额度"`
MonthlyLimitImageConsumptionNumber int `gorm:"column:monthly_limit_image_consumption_number;not null;comment:当月限制类型图片已使用额度"` MonthlyLimitImageConsumptionNumber int `gorm:"column:monthly_limit_image_consumption_number;not null;comment:当月限制类型图片已使用额度"`
MonthlyLimitImageExpireNumber int `gorm:"column:monthly_limit_image_expired_number;not null;comment:当月限制类型图片会过期可用数"`
MonthlyLimitImageExpireConsumptionNumber int `gorm:"column:monthly_limit_image_expired_consumption_number;not null;comment:当月限制类型图片会过期已使用额度"`
MonthlyLimitImageQuotaNumber int `gorm:"column:monthly_limit_image_quota_number;not null;comment:当月限制类型图片额度"`
ManualImageNumber int `gorm:"column:manual_image_number;comment:手动扩展图片总数"` ManualImageNumber int `gorm:"column:manual_image_number;comment:手动扩展图片总数"`
ManualImageConsumptionNumber int `gorm:"column:manual_image_consumption_number;comment:手动扩展图片使用数"` ManualImageConsumptionNumber int `gorm:"column:manual_image_consumption_number;comment:手动扩展图片使用数"`
MonthlyNewManualImageNumber int `gorm:"column:monthly_new_manual_image_number;comment:当月手动扩展图片新增数"` MonthlyNewManualImageNumber int `gorm:"column:monthly_new_manual_image_number;comment:当月手动扩展图片新增数"`
@ -265,6 +268,9 @@ type BundleBalance struct {
IncreaseLimitDataAnalysisExpiredConsumptionNumber int `gorm:"column:increase_limit_data_analysis_expired_consumption_number;not null;comment:增值权益限制类型会过期使用数"` IncreaseLimitDataAnalysisExpiredConsumptionNumber int `gorm:"column:increase_limit_data_analysis_expired_consumption_number;not null;comment:增值权益限制类型会过期使用数"`
MonthlyLimitDataAnalysisNumber int `gorm:"column:monthly_limit_data_analysis_number;not null;comment:当月限制类型数据分析可使用额度"` MonthlyLimitDataAnalysisNumber int `gorm:"column:monthly_limit_data_analysis_number;not null;comment:当月限制类型数据分析可使用额度"`
MonthlyLimitDataAnalysisConsumptionNumber int `gorm:"column:monthly_limit_data_analysis_consumption_number;not null;comment:当月限制类型数据分析已使用额度"` MonthlyLimitDataAnalysisConsumptionNumber int `gorm:"column:monthly_limit_data_analysis_consumption_number;not null;comment:当月限制类型数据分析已使用额度"`
MonthlyLimitDataAnalysisExpireNumber int `gorm:"column:monthly_limit_data_analysis_expired_number;not null;comment:当月限制类型数据分析会过期可用数"`
MonthlyLimitDataAnalysisExpireConsumptionNumber int `gorm:"column:monthly_limit_data_analysis_expired_consumption_number;not null;comment:当月限制类型数据分析会过期已使用额度"`
MonthlyLimitDataAnalysisQuotaNumber int `gorm:"column:monthly_limit_data_analysis_quota_number;not null;comment:当月限制类型数据分析额度"`
ManualDataAnalysisNumber int `gorm:"column:manual_data_analysis_number;comment:手动扩展数据分析总数"` ManualDataAnalysisNumber int `gorm:"column:manual_data_analysis_number;comment:手动扩展数据分析总数"`
ManualDataAnalysisConsumptionNumber int `gorm:"column:manual_data_analysis_consumption_number;comment:手动扩展数据分析使用数"` ManualDataAnalysisConsumptionNumber int `gorm:"column:manual_data_analysis_consumption_number;comment:手动扩展数据分析使用数"`
MonthlyNewManualDataAnalysisNumber int `gorm:"column:monthly_new_manual_data_analysis_number;comment:当月手动扩展数据分析新增数"` MonthlyNewManualDataAnalysisNumber int `gorm:"column:monthly_new_manual_data_analysis_number;comment:当月手动扩展数据分析新增数"`

2
pb/bundle.proto
View File

@ -748,7 +748,7 @@ message AddBundleBalanceReq{
} }
message AddBundleBalanceResp{ message AddBundleBalanceResp{
uint32 usedType = 1; // 0 套餐内 1 增值 2 手动
} }
message GetUsedRecordListReq{ message GetUsedRecordListReq{

1638
pb/bundle/bundle.pb.go
View File

File diff suppressed because it is too large Load Diff

25
pkg/cron/cron.go Normal file
View File

@ -0,0 +1,25 @@
package cron
import (
"log"
"micro-bundle/internal/logic"
"github.com/robfig/cron/v3"
)
func InitCronJob() {
c := cron.New(cron.WithSeconds())
spec := "0 0 0 1 * *"
_, err := c.AddFunc(spec, func() {
log.Printf("执行余量每月数据更新")
logic.UpdateBundleBalance()
})
if err != nil {
panic(err)
}
c.Start()
}