余量查询接口

internal/dao/bundleExtend.go

@@ -107,8 +107,8 @@ func GetBundleBalanceList(req *bundle.GetBundleBalanceListReq) (data []model.Bun
 		FROM bundle_order_records
 		GROUP BY customer_id
 	) bor2 ON bor1.customer_id = bor2.customer_id AND bor1.created_at = bor2.max_created_time`)
-	session := app.ModuleClients.BundleDB.Table("`micro-account`.`user` AS u").
+	session := app.ModuleClients.BundleDB.Table("`micro-account`.`user` AS u").Unscoped().
-		Select(`bb.*, bor.expiration_time as expired_time, bor.bundle_name, bor.status,
+		Select(`bb.*, bor.bundle_name, bor.status,
 	        bor.uuid as order_uuid, rn.name as user_name,
 	        u.tel_num as user_phone_number, u.id as user_id`).
 		Joins("LEFT JOIN `micro-account`.real_name rn ON u.real_name_id = rn.id").
@@ -116,6 +116,7 @@ func GetBundleBalanceList(req *bundle.GetBundleBalanceListReq) (data []model.Bun
 		Joins("LEFT JOIN fiee_bundle.bundle_balance bb ON u.id = bb.user_id AND bb.order_uuid = bor.uuid").
 		Where("rn.name IS NOT NULL").
 		Where("u.deleted_at = 0").
+		Where("bb.month = ?", req.Month).
 		Order("bor.expiration_time desc")
 	if req.UserName != "" {
 		if utils.IsPhoneNumber(req.UserName) {
@@ -201,8 +202,20 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				usedType = 2
 				goto Over
 			}
+			if oldData.ManualAccountConsumptionNumber < oldData.ManualAccountNumber { // 最后消耗手动扩展的
+				oldData.ManualAccountConsumptionNumber++
+				oldData.MonthlyManualAccountConsumptionNumber++
+				usedType = 3
+				goto Over
+			}
 			return errors.New("账号数不足")
 		} else if data.AccountNumber < 0 { // 减少账号消耗数，用于解绑账号
+			if oldData.ManualAccountConsumptionNumber > 0 { // 最后消耗手动扩展的
+				oldData.ManualAccountConsumptionNumber--
+				oldData.MonthlyManualAccountConsumptionNumber--
+				usedType = 3
+				goto Over
+			}
 			if oldData.IncreaseAccountConsumptionNumber > 0 {
 				oldData.IncreaseAccountConsumptionNumber--
 				usedType = 2
@@ -220,12 +233,14 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitVideoExpiredConsumptionNumber < oldData.BundleLimitVideoExpiredNumber { // 套餐内会过期的限制类型视频充足
 					oldData.MonthlyLimitVideoExpireConsumptionNumber++
 					oldData.BundleLimitVideoExpiredConsumptionNumber++
+					oldData.MonthlyBundleVideoConsumptionNumber++
 					usedType = 1
 					goto Over
 				}
 				if oldData.IncreaseLimitVideoExpiredConsumptionNumber < oldData.IncreaseLimitVideoExpiredNumber { // 增值服务会过期的限制类型视频充足
 					oldData.MonthlyLimitVideoExpireConsumptionNumber++
 					oldData.IncreaseLimitVideoExpiredConsumptionNumber++
+					oldData.MonthlyIncreaseVideoConsumptionNumber++
 					usedType = 2
 					goto Over
 				}
@@ -234,23 +249,27 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitVideoConsumptionNumber < oldData.BundleLimitVideoNumber { // 套餐内不过期的限制类型视频充足
 					oldData.MonthlyLimitVideoConsumptionNumber++
 					oldData.BundleLimitVideoConsumptionNumber++
+					oldData.MonthlyBundleVideoConsumptionNumber++
 					usedType = 1
 					goto Over
 				}
 				if oldData.IncreaseLimitVideoConsumptionNumber < oldData.IncreaseLimitVideoNumber { // 增值服务不过期的限制类型视频充足
 					oldData.MonthlyLimitVideoConsumptionNumber++
 					oldData.IncreaseLimitVideoConsumptionNumber++
+					oldData.MonthlyIncreaseVideoConsumptionNumber++
 					usedType = 2
 					goto Over
 				}
 			}
 			if oldData.BundleVideoConsumptionNumber < oldData.BundleVideoNumber { //套餐内非限制类型的视频充足
 				oldData.BundleVideoConsumptionNumber++
+				oldData.MonthlyBundleVideoConsumptionNumber++
 				usedType = 1
 				goto Over
 			}
 			if oldData.IncreaseVideoConsumptionNumber < oldData.IncreaseVideoNumber { //增值服务非限制类型的视频充足
 				oldData.IncreaseVideoConsumptionNumber++
+				oldData.MonthlyIncreaseVideoConsumptionNumber++
 				usedType = 2
 				goto Over
 			}
@@ -268,11 +287,13 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitImageExpiredConsumptionNumber < oldData.BundleLimitImageExpiredNumber { // 套餐内会过期的限制类型图文充足
 					oldData.MonthlyLimitImageExpireConsumptionNumber++
 					oldData.BundleLimitImageExpiredConsumptionNumber++
+					oldData.MonthlyBundleImageConsumptionNumber++
 					goto Over
 				}
 				if oldData.IncreaseLimitImageExpiredConsumptionNumber < oldData.IncreaseLimitImageExpiredNumber { // 增值服务会过期的限制类型图文充足
 					oldData.MonthlyLimitImageExpireConsumptionNumber++
 					oldData.IncreaseLimitImageExpiredConsumptionNumber++
+					oldData.MonthlyIncreaseImageConsumptionNumber++
 					goto Over
 				}
 			}
@@ -280,20 +301,24 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitImageConsumptionNumber < oldData.BundleLimitImageNumber { // 套餐内不过期的限制类型图文充足
 					oldData.MonthlyLimitImageConsumptionNumber++
 					oldData.BundleLimitImageConsumptionNumber++
+					oldData.MonthlyBundleImageConsumptionNumber++
 					goto Over
 				}
 				if oldData.IncreaseLimitImageConsumptionNumber < oldData.IncreaseLimitImageNumber { // 增值服务不过期的限制类型图文充足
 					oldData.MonthlyLimitImageConsumptionNumber++
 					oldData.IncreaseLimitImageConsumptionNumber++
+					oldData.MonthlyIncreaseImageConsumptionNumber++
 					goto Over
 				}
 			}
 			if oldData.BundleImageConsumptionNumber < oldData.BundleImageNumber { //套餐内非限制类型的图文充足
 				oldData.BundleImageConsumptionNumber++
+				oldData.MonthlyBundleImageConsumptionNumber++
 				goto Over
 			}
 			if oldData.IncreaseImageConsumptionNumber < oldData.IncreaseImageNumber { //增值服务非限制类型的图文充足
 				oldData.IncreaseImageConsumptionNumber++
+				oldData.MonthlyIncreaseImageConsumptionNumber++
 				goto Over
 			}
 			if oldData.ManualImageConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足
@@ -309,11 +334,13 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitDataAnalysisExpiredConsumptionNumber < oldData.BundleLimitDataAnalysisExpiredNumber { // 套餐内会过期的限制类型数据分析充足
 					oldData.MonthlyLimitDataAnalysisExpireConsumptionNumber++
 					oldData.BundleLimitDataAnalysisExpiredConsumptionNumber++
+					oldData.MonthlyBundleDataAnalysisConsumptionNumber++
 					goto Over
 				}
 				if oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber < oldData.IncreaseLimitDataAnalysisExpiredNumber { // 增值服务会过期的限制类型数据分析充足
 					oldData.MonthlyLimitDataAnalysisExpireConsumptionNumber++
 					oldData.IncreaseLimitDataAnalysisExpiredConsumptionNumber++
+					oldData.MonthlyIncreaseDataAnalysisConsumptionNumber++
 					goto Over
 				}
 			}
@@ -321,20 +348,24 @@ func AddBundleBalanceByUserId(data model.BundleBalanceUsePo) (usedType int, err
 				if oldData.BundleLimitDataAnalysisConsumptionNumber < oldData.BundleLimitDataAnalysisNumber { // 套餐内不过期的限制类型数据分析充足
 					oldData.MonthlyLimitDataAnalysisConsumptionNumber++
 					oldData.BundleLimitDataAnalysisConsumptionNumber++
+					oldData.MonthlyBundleDataAnalysisConsumptionNumber++
 					goto Over
 				}
 				if oldData.IncreaseLimitDataAnalysisConsumptionNumber < oldData.IncreaseLimitDataAnalysisNumber { // 增值服务不过期的限制类型数据分析充足
 					oldData.MonthlyLimitDataAnalysisConsumptionNumber++
 					oldData.IncreaseLimitDataAnalysisConsumptionNumber++
+					oldData.MonthlyIncreaseDataAnalysisConsumptionNumber++
 					goto Over
 				}
 			}
 			if oldData.BundleLimitDataAnalysisNumber < oldData.BundleDataAnalysisNumber { //套餐内非限制类型的数据分析充足
 				oldData.BundleLimitDataAnalysisNumber++
+				oldData.MonthlyBundleDataAnalysisConsumptionNumber++
 				goto Over
 			}
 			if oldData.IncreaseDataAnalysisConsumptionNumber < oldData.IncreaseDataAnalysisNumber { //增值服务非限制类型的数据分析充足
 				oldData.IncreaseDataAnalysisConsumptionNumber++
+				oldData.MonthlyIncreaseDataAnalysisConsumptionNumber++
 				goto Over
 			}
 			if oldData.ManualDataAnalysisConsumptionNumber < oldData.ManualDataAnalysisNumber { // 手动扩展类型充足
@@ -568,7 +599,12 @@ inner join (
 		v.MonthlyLimitDataAnalysisConsumptionNumber = 0
 		v.MonthlyLimitDataAnalysisExpireConsumptionNumber = 0
 		v.MonthlyManualDataAnalysisConsumptionNumber = 0
-
+		v.MonthlyBundleVideoConsumptionNumber = 0
+		v.MonthlyBundleImageConsumptionNumber = 0
+		v.MonthlyBundleDataAnalysisConsumptionNumber = 0
+		v.MonthlyIncreaseVideoConsumptionNumber = 0
+		v.MonthlyIncreaseImageConsumptionNumber = 0
+		v.MonthlyIncreaseDataAnalysisConsumptionNumber = 0
 		v.Month = month
 		v.ID = 0
 		app.ModuleClients.BundleDB.Create(&v)

internal/logic/bundleExtendLogic.go

@@ -61,17 +61,73 @@ func GetBundleBalanceList(req *bundle.GetBundleBalanceListReq) (*bundle.GetBundl
 	}
 	resp := &bundle.GetBundleBalanceListResp{}
 	resp.Total = total
+	date, err := time.Parse("2006-01", req.Month)
+	if err != nil {
+		return nil, errors.New("请求时间有误")
+	}
 	resp.Data = lo.Map(data, func(m model.BundleBalancePo, _ int) *bundle.BundleBalanceItem {
-		result := &bundle.BundleBalanceItem{}
+		result := &bundle.BundleBalanceItem{
-		copier.Copy(result, &m)
+			UserId:          int32(m.UserId),
-		loc, _ := time.LoadLocation("Asia/Shanghai")
+			UserName:        m.UserName,
-		t, _ := time.ParseInLocation(time.DateTime, m.ExpirationTime, loc)
+			UserPhoneNumber: m.UserPhoneNumber,
+			Status:          int32(m.Status),
+			BundleName:      m.BundleName,
+			ExpiredTime:     m.ExpiredAt.UnixMilli(),
+			// 账号类
+			BundleAccountNumber:              int32(m.BundleAccountNumber),
+			IncreaseAccountNumber:            int32(m.IncreaseAccountNumber),
+			BundleAccountConsumptionNumber:   int32(m.BundleAccountConsumptionNumber),
+			IncreaseAccountConsumptionNumber: int32(m.IncreaseAccountConsumptionNumber),
+			// 视频类
+			BundleVideoNumber:                 int32(m.BundleVideoNumber) + int32(m.BundleLimitVideoNumber) + int32(m.BundleLimitVideoExpiredNumber),
+			IncreaseVideoNumber:               int32(m.IncreaseVideoNumber) + int32(m.IncreaseLimitVideoNumber) + int32(m.IncreaseLimitVideoExpiredNumber),
+			BundleVideoConsumptionNumber:      int32(m.BundleVideoConsumptionNumber) + int32(m.BundleLimitVideoConsumptionNumber) + int32(m.BundleLimitVideoExpiredConsumptionNumber),
+			IncreaseVideoConsumptionNumber:    int32(m.IncreaseVideoConsumptionNumber) + int32(m.IncreaseLimitVideoConsumptionNumber) + int32(m.IncreaseLimitVideoExpiredConsumptionNumber),
+			InvalidBundleVideoNumber:          int32(m.InvalidBundleVideoNumber),
+			InvalidIncreaseVideoNumber:        int32(m.InvalidIncreaseVideoNumber),
+			MonthlyNewBundleVideoNumber:       int32(cal(m.BundleBalance, m.BundleLimitVideoNumber, m.MonthlyLimitVideoQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitVideoExpiredNumber, m.MonthlyLimitVideoQuotaNumber, date)),
+			MonthlyNewIncreaseVideoNumber:     int32(cal(m.BundleBalance, m.IncreaseLimitVideoNumber, m.MonthlyLimitVideoQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitVideoExpiredNumber, m.MonthlyLimitVideoQuotaNumber, date)),
+			MonthlyInvalidBundleVideoNumber:   int32(m.MonthlyInvalidBundleVideoNumber),
+			MonthlyInvalidIncreaseVideoNumber: int32(m.MonthlyInvalidIncreaseVideoNumber),
+			// 图文类
+			BundleImageNumber:                 int32(m.BundleImageNumber) + int32(m.BundleLimitImageNumber) + int32(m.BundleLimitImageExpiredNumber),
+			IncreaseImageNumber:               int32(m.IncreaseImageNumber) + int32(m.IncreaseLimitImageNumber) + int32(m.IncreaseLimitImageExpiredNumber),
+			BundleImageConsumptionNumber:      int32(m.BundleImageConsumptionNumber) + int32(m.BundleLimitImageConsumptionNumber) + int32(m.BundleLimitImageExpiredConsumptionNumber),
+			IncreaseImageConsumptionNumber:    int32(m.IncreaseImageConsumptionNumber) + int32(m.IncreaseLimitImageConsumptionNumber) + int32(m.IncreaseLimitImageExpiredConsumptionNumber),
+			InvalidBundleImageNumber:          int32(m.InvalidBundleImageNumber),
+			InvalidIncreaseImageNumber:        int32(m.InvalidIncreaseImageNumber),
+			MonthlyNewBundleImageNumber:       int32(cal(m.BundleBalance, m.BundleLimitImageNumber, m.MonthlyLimitImageQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitImageExpiredNumber, m.MonthlyLimitImageQuotaNumber, date)),
+			MonthlyNewIncreaseImageNumber:     int32(cal(m.BundleBalance, m.IncreaseLimitImageNumber, m.MonthlyLimitImageQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitImageExpiredNumber, m.MonthlyLimitImageQuotaNumber, date)),
+			MonthlyInvalidBundleImageNumber:   int32(m.MonthlyInvalidBundleImageNumber),
+			MonthlyInvalidIncreaseImageNumber: int32(m.MonthlyInvalidIncreaseImageNumber),
+			// 数据分析类
+			BundleDataAnalysisNumber:                 int32(m.BundleDataAnalysisNumber) + int32(m.BundleLimitDataAnalysisNumber) + int32(m.BundleLimitDataAnalysisExpiredNumber),
+			IncreaseDataAnalysisNumber:               int32(m.IncreaseDataAnalysisNumber) + int32(m.IncreaseLimitDataAnalysisNumber) + int32(m.IncreaseLimitDataAnalysisExpiredNumber),
+			BundleDataAnalysisConsumptionNumber:      int32(m.BundleDataAnalysisConsumptionNumber) + int32(m.BundleLimitDataAnalysisConsumptionNumber) + int32(m.BundleLimitDataAnalysisExpiredConsumptionNumber),
+			IncreaseDataAnalysisConsumptionNumber:    int32(m.IncreaseDataAnalysisConsumptionNumber) + int32(m.IncreaseLimitDataAnalysisConsumptionNumber) + int32(m.IncreaseLimitDataAnalysisExpiredConsumptionNumber),
+			InvalidBundleDataAnalysisNumber:          int32(m.InvalidBundleDataAnalysisNumber),
+			InvalidIncreaseDataAnalysisNumber:        int32(m.InvalidIncreaseDataAnalysisNumber),
+			MonthlyNewBundleDataAnalysisNumber:       int32(cal(m.BundleBalance, m.BundleLimitDataAnalysisNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitDataAnalysisExpiredNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date)),
+			MonthlyNewIncreaseDataAnalysisNumber:     int32(cal(m.BundleBalance, m.IncreaseLimitDataAnalysisNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitDataAnalysisExpiredNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date)),
+			MonthlyInvalidBundleDataAnalysisNumber:   int32(m.MonthlyInvalidBundleDataAnalysisNumber),
+			MonthlyInvalidIncreaseDataAnalysisNumber: int32(m.MonthlyInvalidIncreaseDataAnalysisNumber),
+			// 手动扩展类
+			MonthlyNewManualAccountNumber:              int32(m.MonthlyNewAccountNumber),
+			MonthlyNewManualVideoNumber:                int32(m.MonthlyNewManualVideoNumber),
+			MonthlyNewManualImageNumber:                int32(m.MonthlyNewManualImageNumber),
+			MonthlyNewManualDataAnalysisNumber:         int32(m.MonthlyNewManualDataAnalysisNumber),
+			MonthlyNewDurationNumber:                   int32(m.MonthlyNewDurationNumber),
+			MonthlyManualAccountConsumptionNumber:      int32(m.MonthlyManualAccountConsumptionNumber),
+			MonthlyManualVideoConsumptionNumber:        int32(m.MonthlyManualVideoConsumptionNumber),
+			MonthlyManualImageConsumptionNumber:        int32(m.MonthlyManualImageConsumptionNumber),
+			MonthlyManualDataAnalysisConsumptionNumber: int32(m.MonthlyManualDataAnalysisConsumptionNumber),
+		}
+
 		if m.OrderUUID != "" {
 			result.Bought = 2
 		} else {
 			result.Bought = 1
 		}
-		result.ExpiredTime = t.UnixMilli()
 		return result
 	})
 	return resp, nil
@@ -107,6 +163,28 @@ func AddBundleBalance(req *bundle.AddBundleBalanceReq) (*bundle.AddBundleBalance
 	}, err
 }
 
+// 计算本月发放的限制类型数量
+func cal(data model.BundleBalance, total, limit int, date time.Time) int {
+	var released int // 已释放的次数
+	if data.StartAt.Month() == date.Month() && data.StartAt.Year() == date.Year() {
+	} else if data.StartAt.Day() >= 16 { //第一个月释放的
+		released += limit/2 + 1
+	} else {
+		released += limit
+	}
+	interval := date.Year()*12 + int(date.Month()) - (data.StartAt.Year()*12 + int(data.StartAt.Month())) // 后续月份释放的
+	released += interval * limit
+	remaining := max(total-released, 0) // 还剩余多少次没有发放
+
+	if data.StartAt.Month() == date.Month() && data.StartAt.Year() == date.Year() && data.StartAt.Day() >= 16 { // 本月为第一个月并且16号后购买只给一半（向上取整）
+		return min(limit/2+1, remaining)
+	}
+	if data.ExpiredAt.Month() == date.Month() && data.ExpiredAt.Year() == date.Year() && data.ExpiredAt.Day() < 16 { // 本月为最后一个月并且16号前到期只给一半（向下取整）
+		return min(limit/2, remaining)
+	}
+	return min(limit, remaining)
+}
+
 func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBundleBalanceResp, error) {
 	var data model.BundleBalance
 
@@ -216,34 +294,13 @@ 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.MonthlyLimitVideoExpireNumber = cal(data, data.BundleLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber, now) + cal(data, data.IncreaseLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber, now)
-	data.MonthlyLimitVideoNumber = cal(data.BundleLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber) + cal(data.IncreaseLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber)
+	data.MonthlyLimitVideoNumber = cal(data, data.BundleLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber, now) + cal(data, data.IncreaseLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber, now)
-	data.MonthlyLimitImageExpireNumber = cal(data.BundleLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber) + cal(data.IncreaseLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber)
+	data.MonthlyLimitImageExpireNumber = cal(data, data.BundleLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber, now) + cal(data, data.IncreaseLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber, now)
-	data.MonthlyLimitImageNumber = cal(data.BundleLimitImageNumber, data.MonthlyLimitImageQuotaNumber) + cal(data.IncreaseLimitImageNumber, data.MonthlyLimitImageQuotaNumber)
+	data.MonthlyLimitImageNumber = cal(data, data.BundleLimitImageNumber, data.MonthlyLimitImageQuotaNumber, now) + cal(data, data.IncreaseLimitImageNumber, data.MonthlyLimitImageQuotaNumber, now)
-	data.MonthlyLimitDataAnalysisExpireNumber = cal(data.BundleLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber) + cal(data.IncreaseLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber)
+	data.MonthlyLimitDataAnalysisExpireNumber = cal(data, data.BundleLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now) + cal(data, data.IncreaseLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now)
-	data.MonthlyLimitDataAnalysisNumber = cal(data.BundleLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber) + cal(data.IncreaseLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber)
+	data.MonthlyLimitDataAnalysisNumber = cal(data, data.BundleLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now) + cal(data, data.IncreaseLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now)
 
 	err = dao.CreateBundleBalance(data)
 	if err != nil {

internal/model/bundle.go

@@ -144,22 +144,13 @@ type BundleExtendRecordItemDto struct {
 }
 
 type BundleBalancePo struct {
-	UserId                        int    `gorm:"column:user_id"`
+	UserId          int    `gorm:"column:user_id"`
-	UserName                      string `gorm:"column:user_name"`
+	UserName        string `gorm:"column:user_name"`
-	UserPhoneNumber               string `gorm:"column:user_phone_number"`
+	UserPhoneNumber string `gorm:"column:user_phone_number"`
-	BundleName                    string `gorm:"column:bundle_name"`
+	BundleName      string `gorm:"column:bundle_name"`
-	ExpirationTime                string `gorm:"column:expired_time"`
+	Status          int    `gorm:"column:status"`
-	Status                        int    `gorm:"column:status"`
+	OrderUUID       string `gorm:"column:order_uuid"`
-	OrderUUID                     string `gorm:"column:order_uuid"`
+	BundleBalance
-	AccountNumber                 int    `gorm:"column:account_number;not null"`
-	AccountConsumptionNumber      int    `gorm:"column:account_consumption_number;not null"`
-	VideoNumber                   int    `gorm:"column:video_number;not null"`
-	VideoConsumptionNumber        int    `gorm:"column:video_consumption_number;not null"`
-	ImageNumber                   int    `gorm:"column:image_number;not null"`
-	ImageConsumptionNumber        int    `gorm:"column:image_consumption_number;not null"`
-	DataAnalysisNumber            int    `gorm:"column:data_analysis_number;not null"`
-	DataAnalysisConsumptionNumber int    `gorm:"column:data_analysis_consumption_number;not null"`
-	ExpansionPacksNumber          int    `gorm:"column:expansion_packs_number;not null"`
 }
 
 type UserBundleBalancePo struct {
@@ -188,16 +179,26 @@ type UserBundleBalancePo struct {
 
 type BundleBalance struct {
 	gorm.Model
-	UserId                           int       `gorm:"column:user_id;not null"`
+	UserId    int       `gorm:"column:user_id;not null"`
-	Month                            string    `gorm:"column:month;type:varchar(32);not null"`
+	Month     string    `gorm:"column:month;type:varchar(32);not null"`
-	OrderUUID                        string    `gorm:"column:order_uuid;type:varchar(1024);not null"`
+	OrderUUID string    `gorm:"column:order_uuid;type:varchar(1024);not null"`
-	ExpiredAt                        time.Time `gorm:"column:expired_at;type:datetime;comment:套餐过期时间"`
+	ExpiredAt time.Time `gorm:"column:expired_at;type:datetime;comment:套餐过期时间"`
-	StartAt                          time.Time `gorm:"column:start_at;type:datetime;comment:套餐开始时间"`
+	StartAt   time.Time `gorm:"column:start_at;type:datetime;comment:套餐开始时间"`
-	BundleAccountNumber              int       `gorm:"column:bundle_account_number;not null;comment:套餐账号总数"`
-	IncreaseAccountNumber            int       `gorm:"column:increase_account_number;not null;comment:增值账号总数"`
-	BundleAccountConsumptionNumber   int       `gorm:"column:bundle_account_number;not null;comment:套餐账号使用数"`
-	IncreaseAccountConsumptionNumber int       `gorm:"column:increase_account_number;not null;comment:增值账号使用数"`
 
+	// 套餐与增值账号
+	BundleAccountNumber              int `gorm:"column:bundle_account_number;not null;comment:套餐账号总数"`
+	IncreaseAccountNumber            int `gorm:"column:increase_account_number;not null;comment:增值账号总数"`
+	BundleAccountConsumptionNumber   int `gorm:"column:bundle_account_consumption_number;not null;comment:套餐账号使用数"`
+	IncreaseAccountConsumptionNumber int `gorm:"column:increase_account_consumption_number;not null;comment:增值账号使用数"`
+
+	// 手动账号扩展
+	MonthlyNewAccountNumber               int `gorm:"column:monthly_new_account_number;comment:当月手动扩展账号新增数"`
+	MonthlyManualAccountConsumptionNumber int `gorm:"column:monthly_manual_account_consumption_number;comment:当月手动扩展账号使用数"`
+	ManualAccountNumber                   int `gorm:"column:manual_account_number;comment:手动扩展账号总数"`
+	ManualAccountConsumptionNumber        int `gorm:"column:manual_account_consumption_number;comment:手动扩展账号使用数"`
+	MonthlyNewManualAccountNumber         int `gorm:"column:monthly_new_manual_account_number;comment:当月手动扩展账号新增数"`
+
+	// ===== 视频类 =====
 	BundleVideoNumber                          int `gorm:"column:bundle_video_number;not null;comment:非限制类型套餐权益视频总数"`
 	IncreaseVideoNumber                        int `gorm:"column:increase_video_number;not null;comment:非限制类型增值权益视频总数"`
 	BundleLimitVideoNumber                     int `gorm:"column:bundle_limit_video_number;not null;comment:套餐权益限制类型非过期总数"`
@@ -218,12 +219,15 @@ type BundleBalance struct {
 	MonthlyLimitVideoConsumptionNumber         int `gorm:"column:monthly_limit_video_consumption_number;not null;comment:当月限制类型视频已使用额度"`
 	MonthlyLimitVideoExpireNumber              int `gorm:"column:monthly_limit_video_expired_number;not null;comment:当月限制类型视频会过期可用数"`
 	MonthlyLimitVideoExpireConsumptionNumber   int `gorm:"column:monthly_limit_video_expired_consumption_number;not null;comment:当月限制类型视频会过期已使用额度"`
+	MonthlyBundleVideoConsumptionNumber        int `gorm:"column:monthly_bundle_video_consumption_number;not null;comment:当月套餐类型总使用数"`
+	MonthlyIncreaseVideoConsumptionNumber      int `gorm:"column:monthly_increase_video_consumption_number;not null;comment:当月增值类型总使用数"`
 	MonthlyLimitVideoQuotaNumber               int `gorm:"column:monthly_limit_video_quota_number;not null;comment:当月限制类型视频额度"`
 	ManualVideoNumber                          int `gorm:"column:manual_video_number;comment:手动扩展视频总数"`
 	ManualVideoConsumptionNumber               int `gorm:"column:manual_video_consumption_number;comment:手动扩展视频使用数"`
 	MonthlyNewManualVideoNumber                int `gorm:"column:monthly_new_manual_video_number;comment:当月手动扩展视频新增数"`
 	MonthlyManualVideoConsumptionNumber        int `gorm:"column:monthly_manual_video_consumption_number;comment:当月手动扩展视频使用数"`
 
+	// ===== 图片类 =====
 	BundleImageNumber                          int `gorm:"column:bundle_image_number;not null;comment:非限制类型套餐权益图片总数"`
 	IncreaseImageNumber                        int `gorm:"column:increase_image_number;not null;comment:非限制类型增值权益图片总数"`
 	BundleLimitImageNumber                     int `gorm:"column:bundle_limit_image_number;not null;comment:套餐权益限制类型非过期总数"`
@@ -244,12 +248,15 @@ type BundleBalance struct {
 	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:当月限制类型图片会过期已使用额度"`
+	MonthlyBundleImageConsumptionNumber        int `gorm:"column:monthly_bundle_image_consumption_number;not null;comment:当月套餐类型总使用数"`
+	MonthlyIncreaseImageConsumptionNumber      int `gorm:"column:monthly_increase_image_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:手动扩展图片总数"`
 	ManualImageConsumptionNumber               int `gorm:"column:manual_image_consumption_number;comment:手动扩展图片使用数"`
 	MonthlyNewManualImageNumber                int `gorm:"column:monthly_new_manual_image_number;comment:当月手动扩展图片新增数"`
 	MonthlyManualImageConsumptionNumber        int `gorm:"column:monthly_manual_image_consumption_number;comment:当月手动扩展图片使用数"`
 
+	// ===== 数据分析类 =====
 	BundleDataAnalysisNumber                          int `gorm:"column:bundle_data_analysis_number;not null;comment:非限制类型套餐权益数据分析总数"`
 	IncreaseDataAnalysisNumber                        int `gorm:"column:increase_data_analysis_number;not null;comment:非限制类型增值权益数据分析总数"`
 	BundleLimitDataAnalysisNumber                     int `gorm:"column:bundle_limit_data_analysis_number;not null;comment:套餐权益限制类型非过期总数"`
@@ -270,6 +277,8 @@ type BundleBalance struct {
 	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:当月限制类型数据分析会过期已使用额度"`
+	MonthlyBundleDataAnalysisConsumptionNumber        int `gorm:"column:monthly_bundle_data_analysis_consumption_number;not null;comment:当月套餐类型总使用数"`
+	MonthlyIncreaseDataAnalysisConsumptionNumber      int `gorm:"column:monthly_increase_data_analysis_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:手动扩展数据分析总数"`
 	ManualDataAnalysisConsumptionNumber               int `gorm:"column:manual_data_analysis_consumption_number;comment:手动扩展数据分析使用数"`
@@ -277,8 +286,7 @@ type BundleBalance struct {
 	MonthlyManualDataAnalysisConsumptionNumber        int `gorm:"column:monthly_manual_data_analysis_consumption_number;comment:当月手动扩展数据分析使用数"`
 
 	MonthlyNewDurationNumber int `gorm:"column:monthly_new_duration_number;comment:当月新增手动扩展时长（天）"`
-
+	ExpansionPacksNumber     int `gorm:"column:expansion_packs_number;not null;comment:扩展包数量"`
-	ExpansionPacksNumber int `gorm:"column:expansion_packs_number;not null;comment:扩展包数量"`
 }
 
 // TableName 表名称

pb/bundle.proto

@@ -65,7 +65,7 @@ service Bundle {
   // 使用记录
   rpc GetUsedRecordList(GetUsedRecordListReq) returns (GetUsedRecordListResp) {} // 获取套餐使用记录列表
   rpc GetImageWorkDetail(GetImageWorkDetailReq) returns (GetImageWorkDetailResp) {} // 获取图文作品详情
-  rpc GetVedioWorkDetail(GetVedioWorkDetailReq) returns (GetVedioeWorkDetailResp) {} // 获取视频作品详情
+  rpc GetVedioWorkDetail(GetVedioWorkDetailReq) returns (GetVedioeWorkDetailResp) {} // 获取数据分析作品详情
 
   rpc ToBeComfirmedWorks(ToBeComfirmedWorksReq) returns (ToBeComfirmedWorksResp) {} // 待确认作品列表
   rpc ConfirmWork(ConfirmWorkReq) returns (ConfirmWorkResp) {} // 确认作品
@@ -553,7 +553,7 @@ message ValueAddService {
 message ValueAddServiceLang {
   string uuid = 1 [json_name = "uuid"];
   string serviceName = 2 [json_name = "serviceName"]; //服务名称
-  int32 serviceType = 3 [json_name = "serviceType"]; //服务类型 1:视频 2:图文 3:数据报表 4:账号数 5:可用时长
+  int32 serviceType = 3 [json_name = "serviceType"]; //服务类型 1:数据分析 2:图文 3:数据报表 4:账号数 5:可用时长
   int32 priceMode = 4 [json_name = "priceMode"]; //套餐价格类型 1:单价 2:总价
   string originalPrice = 5 [json_name = "originalPrice"];//原单价
   string unit = 6 [json_name = "unit"];//单位 1:个 2:条 3:天 4:月 5:年 6:自然月 7:自然季度 8:半年 9:自然年
@@ -678,6 +678,7 @@ message GetBundleBalanceListReq{
   int64 expiredTimeEnd = 6;
   int32 page = 7;
   int32 pageSize = 8;
+  string month = 9;
 }
 
 message GetBundleBalanceReq{
@@ -690,23 +691,67 @@ message GetBundleBalanceReq{
   int32 pageSize = 7;
 }
 
-message BundleBalanceItem{
+message BundleBalanceItem {
   int32 userId = 1;
   string userName = 2;
   string userPhoneNumber = 3;
   int32 status = 4;
   string bundleName = 5;
   int64 expiredTime = 6;
-  int32 accountNumber = 7;
+  int32 bought = 7;
-  int32 accountConsumptionNumber = 8;
+
-  int32 videoNumber = 9;
+  // 账号类
-  int32 videoConsumptionNumber = 10;
+  int32 bundleAccountNumber = 8; // 套餐账号总数
-  int32 imageNumber = 11;
+  int32 increaseAccountNumber = 9; // 增值账号总数
-  int32 imageConsumptionNumber = 12;
+  int32 bundleAccountConsumptionNumber = 10; // 套餐账号使用数
-  int32 dataAnalysisNumber = 13;
+  int32 increaseAccountConsumptionNumber = 11; // 增值账号使用数
-  int32 dataAnalysisConsumptionNumber = 14;
+
-  int32 expansionPacksNumber = 15;
+  // 视频类
-  int32 bought = 16;
+  int32 bundleVideoNumber = 12; // 当前可用套餐视频数
+  int32 increaseVideoNumber = 13; // 当前可用增值视频数
+  int32 bundleVideoConsumptionNumber = 14; // 当前已用套餐视频数
+  int32 increaseVideoConsumptionNumber = 15; // 当前已用增值视频数
+  int32 invalidBundleVideoNumber = 16; // 当前作废套餐视频数
+  int32 invalidIncreaseVideoNumber = 17; // 当前作废增值视频数
+  int32 monthlyNewBundleVideoNumber = 18; // 当月新增套餐视频数
+  int32 monthlyNewIncreaseVideoNumber = 19; // 当月新增增值视频数
+  int32 monthlyInvalidBundleVideoNumber = 20; // 当月作废套餐视频数
+  int32 monthlyInvalidIncreaseVideoNumber = 21; // 当月作废增值视频数
+
+  // 图文类
+  int32 bundleImageNumber = 22; // 当前可用套餐图文数
+  int32 increaseImageNumber = 23; // 当前可用增值图文数
+  int32 bundleImageConsumptionNumber = 24; // 当前已用套餐图文数
+  int32 increaseImageConsumptionNumber = 25; // 当前已用增值图文数
+  int32 invalidBundleImageNumber = 26; // 当前作废套餐图文数
+  int32 invalidIncreaseImageNumber = 27; // 当前作废增值图文数
+  int32 monthlyNewBundleImageNumber = 28; // 当月新增套餐图文数
+  int32 monthlyNewIncreaseImageNumber = 29; // 当月新增增值图文数
+  int32 monthlyInvalidBundleImageNumber = 30; // 当月作废套餐图文数
+  int32 monthlyInvalidIncreaseImageNumber = 31; // 当月作废增值图文数
+
+  // 数据分析类
+  int32 bundleDataAnalysisNumber = 32; // 当前可用套餐数据分析数
+  int32 increaseDataAnalysisNumber = 33; // 当前可用增值数据分析数
+  int32 bundleDataAnalysisConsumptionNumber = 34; // 当前已用套餐数据分析数
+  int32 increaseDataAnalysisConsumptionNumber = 35; // 当前已用增值数据分析数
+  int32 invalidBundleDataAnalysisNumber = 36; // 当前作废套餐数据分析数
+  int32 invalidIncreaseDataAnalysisNumber = 37; // 当前作废增值数据分析数
+  int32 monthlyNewBundleDataAnalysisNumber = 38; // 当月新增套餐数据分析数
+  int32 monthlyNewIncreaseDataAnalysisNumber = 39; // 当月新增增值数据分析数
+  int32 monthlyInvalidBundleDataAnalysisNumber = 40; // 当月作废套餐数据分析数
+  int32 monthlyInvalidIncreaseDataAnalysisNumber = 41; // 当月作废增值数据分析数
+
+  // 手动扩展类
+  int32 monthlyNewManualAccountNumber = 42; // 当月手动扩展账号新增数
+  int32 monthlyNewManualVideoNumber = 43; // 当月手动扩展视频新增数
+  int32 monthlyNewManualImageNumber = 44; // 当月手动扩展图文新增数
+  int32 monthlyNewManualDataAnalysisNumber = 45; // 当月手动扩展数据分析新增数
+  int32 monthlyNewDurationNumber = 46; // 当月新增手动扩展时长（天）
+  int32 monthlyManualAccountConsumptionNumber = 47; // 当月手动扩展账号使用数
+  int32 monthlyManualVideoConsumptionNumber = 48; // 当月手动扩展视频使用数
+  int32 monthlyManualImageConsumptionNumber = 49; // 当月手动扩展图文使用数
+  int32 monthlyManualDataAnalysisConsumptionNumber = 50; // 当月手动扩展数据分析使用数
 }
 
 message GetBundleBalanceListResp{
@@ -774,7 +819,7 @@ message WorkCastItem{
   string artistName = 2;     // 艺人名称
   string artistPhone = 3;    // 艺人手机号
   string workUuid = 4;       // 作品uuid
-  uint32 workCategory = 5;   // 1 图文 2 视频
+  uint32 workCategory = 5;   // 1 图文 2 数据分析
   string bundleUuid = 6;     // 套餐ID uuid
   string bundleName = 7;     // 套餐名称
   string platformIds = 8;    // 发布平台ID集合 (json 格式字符串)
@@ -960,7 +1005,7 @@ message TaskManagementInfo {
   string subNum = 1 [json_name = "subNum"];                     // 艺人编号
   string telNum = 2 [json_name = "telNum"];                     // 手机号
   string artistName = 3 [json_name = "artistName"];             // 艺人姓名
-  int32 pendingVideoCount = 4 [json_name = "pendingVideoCount"]; // 待发视频数量
+  int32 pendingVideoCount = 4 [json_name = "pendingVideoCount"]; // 待发数据分析数量
   int32 pendingPostCount = 5 [json_name = "pendingPostCount"];   // 待发图文数量
   int32 pendingDataCount = 6 [json_name = "pendingDataCount"];   // 待发数据数量
   int32 progressTaskCount = 7 [json_name = "progressTaskCount"]; // 进行中任务数量
@@ -978,7 +1023,7 @@ message TaskAssignRequest {
   string taskAssigneeNum = 5 [json_name = "taskAssigneeNum"];   // 任务指派人账号
   string operator = 6 [json_name = "operator"];                // 操作人
   string operatorNum = 7 [json_name = "operatorNum"];           // 操作人账号
-  int32 assignVideoCount = 8 [json_name = "assignVideoCount"];  // 指派视频数
+  int32 assignVideoCount = 8 [json_name = "assignVideoCount"];  // 指派数据分析数
   int32 assignPostCount = 9 [json_name = "assignPostCount"];    // 指派图文数
   int32 assignDataCount = 10 [json_name = "assignDataCount"];    // 指派数据数
 }
@@ -988,7 +1033,7 @@ message UpdatePendingCountRequest {
   string subNum = 1 [json_name = "subNum"];                     // 艺人编号
   string telNum = 2 [json_name = "telNum"];                     // 艺人手机号
   string artistName = 3 [json_name = "artistName"];             // 艺人姓名
-  int32 pendingVideoCount = 4 [json_name = "pendingVideoCount"]; // 待发视频数量
+  int32 pendingVideoCount = 4 [json_name = "pendingVideoCount"]; // 待发数据分析数量
   int32 pendingPostCount = 5 [json_name = "pendingPostCount"];   // 待发图文数量
   int32 pendingDataCount = 6 [json_name = "pendingDataCount"];   // 待发数据数量
   string operator = 7 [json_name = "operator"];                // 操作人
@@ -1041,7 +1086,7 @@ message TaskAssignRecordInfo {
   string operatorTime = 11 [json_name = "operatorTime"];         // 操作时间
   string taskAssignee = 12 [json_name = "taskAssignee"];         // 任务指派人
   string taskAssigneeNum = 13 [json_name = "taskAssigneeNum"];   // 任务指派人账号
-  int32 pendingVideoCount = 14 [json_name = "pendingVideoCount"]; // 待发视频数量
+  int32 pendingVideoCount = 14 [json_name = "pendingVideoCount"]; // 待发数据分析数量
   int32 pendingPostCount = 15 [json_name = "pendingPostCount"];   // 待发图文数量
   int32 pendingDataCount = 16 [json_name = "pendingDataCount"];   // 待发数据数量
   string updatedAt = 24 [json_name = "updatedAt"];               // 更新时间
@@ -1091,7 +1136,7 @@ message ArtistBundleBalanceRequest {
 
 // 艺人套餐剩余数量响应
 message ArtistBundleBalanceResponse {
-  int32 remainingVideoCount = 1 [json_name = "remainingVideoCount"]; // 剩余视频数量
+  int32 remainingVideoCount = 1 [json_name = "remainingVideoCount"]; // 剩余数据分析数量
   int32 remainingImageCount = 2 [json_name = "remainingImageCount"]; // 剩余图片数量
   int32 remainingDataAnalysisCount = 3 [json_name = "remainingDataAnalysisCount"]; // 剩余数据分析数量
 }