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

bugfix: 根据余额表细分的情况，将任务表细分，并添加任务余额表，不依赖套餐余额

Browse Source
This commit is contained in:
cjy 2025-10-17 14:25:41 +08:00
parent 6d0ccb0c9d
commit 5269d7e24c
7 changed files with 2437 additions and 1114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
internal/controller/task.go
View File

@ -268,29 +268,45 @@ func convertToTaskAssignRecordInfo(record *dao.TaskAssignRecordsResponse) *bundl
} }
} }
// GetArtistBundleBalance 查询艺人套餐剩余数量 // GetArtistBundleBalance 查询艺人的当前任务余额与待发数量（区分套餐/增值两类）
// 说明：
// - 查询条件优先使用艺人编号（customerNum），为空时使用手机号（telNum）
// - 返回同时包含“套餐类型”和“增值类型”的余额与待发数量，均按视频/图文/数据分析三类区分
func (b *BundleProvider) GetArtistBundleBalance(_ context.Context, req *bundle.ArtistBundleBalanceRequest) (*bundle.ArtistBundleBalanceResponse, error) { func (b *BundleProvider) GetArtistBundleBalance(_ context.Context, req *bundle.ArtistBundleBalanceRequest) (*bundle.ArtistBundleBalanceResponse, error) {
// 参数验证 // 参数校验
if req.CustomerNum == "" && req.TelNum == "" { if req.CustomerNum == "" && req.TelNum == "" {
return nil, fmt.Errorf("艺人编号和手机号不能同时为空") return nil, fmt.Errorf("艺人编号和手机号不能同时为空")
} }
// 转换请求参数 // 组装查询参数（逻辑层/DAO层使用 SubNum 与 TelNum）
daoReq := &dao.ArtistBundleBalanceRequest{ pendingReq := &dao.PendingAndBalanceRequest{
CustomerNum: req.CustomerNum, SubNum: req.CustomerNum, // 映射 customerNum -> SubNum
TelNum: req.TelNum, TelNum: req.TelNum, // 映射 telNum -> TelNum
} }
// 调用logic层 // 调用逻辑层：查询待发数量与任务余额（区分套餐/增值）
result, err := logic.GetArtistBundleBalance(daoReq) resp, err := logic.GetPendingAndTaskBalances(pendingReq)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 转换响应数据 // 映射为proto响应结构（套餐/增值分别返回视频/图文/数据分析的余额与待发数量）
return &bundle.ArtistBundleBalanceResponse{ return &bundle.ArtistBundleBalanceResponse{
RemainingVideoCount: int32(result.RemainingVideoCount), // 套餐类型余额
RemainingImageCount: int32(result.RemainingImageCount), BundleVideoBalance: int32(resp.BundleVideoBalance),
RemainingDataAnalysisCount: int32(result.RemainingDataAnalysisCount), BundleImageBalance: int32(resp.BundleImageBalance),
BundleDataAnalysisBalance: int32(resp.BundleDataAnalysisBalance),
// 增值类型余额
IncreaseVideoBalance: int32(resp.IncreaseVideoBalance),
IncreaseImageBalance: int32(resp.IncreaseImageBalance),
IncreaseDataAnalysisBalance: int32(resp.IncreaseDataAnalysisBalance),
// 套餐类型待发数量
BundlePendingVideoCount: int32(resp.PendingBundleVideoCount),
BundlePendingImageCount: int32(resp.PendingBundleImageCount),
BundlePendingDataAnalysisCount: int32(resp.PendingBundleDataAnalysisCount),
// 增值类型待发数量
IncreasePendingVideoCount: int32(resp.PendingIncreaseVideoCount),
IncreasePendingImageCount: int32(resp.PendingIncreaseImageCount),
IncreasePendingDataAnalysisCount: int32(resp.PendingIncreaseDataAnalysisCount),
}, nil }, nil
} }

858
internal/dao/taskDao.go
View File

@ -12,6 +12,90 @@ import (
"gorm.io/gorm" "gorm.io/gorm"
) )
// ===== 聚合和扣减的辅助函数 =====
// aggregatePendingVideo 汇总所有视频分类的待发数量
func aggregatePendingVideo(t *model.TaskManagement) int {
return t.PendingBundleLimitVideoExpiredCount + t.PendingBundleLimitVideoCount +
t.PendingIncreaseLimitVideoExpiredCount + t.PendingIncreaseLimitVideoCount +
t.PendingBundleVideoCount + t.PendingIncreaseVideoCount
}
// aggregatePendingImage 汇总所有图文分类的待发数量
func aggregatePendingImage(t *model.TaskManagement) int {
return t.PendingBundleLimitImageExpiredCount + t.PendingBundleLimitImageCount +
t.PendingIncreaseLimitImageExpiredCount + t.PendingIncreaseLimitImageCount +
t.PendingBundleImageCount + t.PendingIncreaseImageCount
}
// aggregatePendingData 汇总所有数据分析分类的待发数量
func aggregatePendingData(t *model.TaskManagement) int {
return t.PendingBundleLimitDataAnalysisExpiredCount + t.PendingBundleLimitDataAnalysisCount +
t.PendingIncreaseLimitDataAnalysisExpiredCount + t.PendingIncreaseLimitDataAnalysisCount +
t.PendingBundleDataAnalysisCount + t.PendingIncreaseDataAnalysisCount
}
// deductCount 按顺序从各个桶中扣减数量，剩余未扣减数量应为0（正常情况）
func deductCount(count *int, buckets ...*int) {
if count == nil {
return
}
for _, b := range buckets {
if *count <= 0 {
break
}
if b == nil || *b <= 0 {
continue
}
if *b >= *count {
*b = *b - *count
*count = 0
} else {
*count = *count - *b
*b = 0
}
}
}
// deductVideo 视频扣减优先级：受限 > 非受限；同类型中：打包 > 增量；受限类型中：过期优先
func deductVideo(t *model.TaskManagement, n int) {
c := n
deductCount(&c,
&t.PendingBundleLimitVideoExpiredCount,
&t.PendingBundleLimitVideoCount,
&t.PendingIncreaseLimitVideoExpiredCount,
&t.PendingIncreaseLimitVideoCount,
&t.PendingBundleVideoCount,
&t.PendingIncreaseVideoCount,
)
}
// deductImage 图文扣减优先级：受限 > 非受限；同类型中：打包 > 增量；受限类型中：过期优先
func deductImage(t *model.TaskManagement, n int) {
c := n
deductCount(&c,
&t.PendingBundleLimitImageExpiredCount,
&t.PendingBundleLimitImageCount,
&t.PendingIncreaseLimitImageExpiredCount,
&t.PendingIncreaseLimitImageCount,
&t.PendingBundleImageCount,
&t.PendingIncreaseImageCount,
)
}
// deductData 数据分析扣减优先级：受限 > 非受限；同类型中：打包 > 增量；受限类型中：过期优先
func deductData(t *model.TaskManagement, n int) {
c := n
deductCount(&c,
&t.PendingBundleLimitDataAnalysisExpiredCount,
&t.PendingBundleLimitDataAnalysisCount,
&t.PendingIncreaseLimitDataAnalysisExpiredCount,
&t.PendingIncreaseLimitDataAnalysisCount,
&t.PendingBundleDataAnalysisCount,
&t.PendingIncreaseDataAnalysisCount,
)
}
// TaskQueryRequest 查询待指派任务记录请求参数 // TaskQueryRequest 查询待指派任务记录请求参数
type TaskQueryRequest struct { type TaskQueryRequest struct {
Keyword string `json:"keyword"` // 艺人姓名、编号、手机号搜索关键词 Keyword string `json:"keyword"` // 艺人姓名、编号、手机号搜索关键词
@ -162,6 +246,147 @@ type ArtistBundleBalanceResponse struct {
RemainingDataAnalysisCount int `json:"remainingDataAnalysisCount"` // 剩余数据分析数量 (data_analysis_number - data_analysis_consumption_number) RemainingDataAnalysisCount int `json:"remainingDataAnalysisCount"` // 剩余数据分析数量 (data_analysis_number - data_analysis_consumption_number)
} }
// PendingAndBalanceRequest 查询待发与任务余额请求参数
// 优先使用艺人编号查询，如果为空则使用手机号查询
type PendingAndBalanceRequest struct {
SubNum string `json:"subNum"` // 艺人编号（推荐使用）
TelNum string `json:"telNum"` // 艺人手机号（备选）
}
// PendingAndBalanceResponse 查询待发与任务余额响应结构
// 待发数量为细分待发字段求和；余额为对应总数减已使用数后再按类别（套餐/增值）聚合
type PendingAndBalanceResponse struct {
// 待发（按类别聚合）
PendingBundleVideoCount int `json:"pendingBundleVideoCount"` // 待发套餐视频数量（非限制+限制非过期+限制会过期）
PendingBundleImageCount int `json:"pendingBundleImageCount"` // 待发套餐图文数量（非限制+限制非过期+限制会过期）
PendingBundleDataAnalysisCount int `json:"pendingBundleDataAnalysisCount"` // 待发套餐数据分析数量（非限制+限制非过期+限制会过期）
PendingIncreaseVideoCount int `json:"pendingIncreaseVideoCount"` // 待发增值视频数量（非限制+限制非过期+限制会过期）
PendingIncreaseImageCount int `json:"pendingIncreaseImageCount"` // 待发增值图文数量（非限制+限制非过期+限制会过期）
PendingIncreaseDataAnalysisCount int `json:"pendingIncreaseDataAnalysisCount"` // 待发增值数据分析数量（非限制+限制非过期+限制会过期）
// 任务余额（套餐/增值按类别聚合）
BundleVideoBalance int `json:"bundleVideoBalance"` // 套餐视频余额
BundleImageBalance int `json:"bundleImageBalance"` // 套餐图文余额
BundleDataAnalysisBalance int `json:"bundleDataAnalysisBalance"` // 套餐数据分析余额
IncreaseVideoBalance int `json:"increaseVideoBalance"` // 增值视频余额
IncreaseImageBalance int `json:"increaseImageBalance"` // 增值图文余额
IncreaseDataAnalysisBalance int `json:"increaseDataAnalysisBalance"` // 增值数据分析余额
}
// calculateBundleBalances 计算套餐类别下的三类余额（视频/图文/数据分析）
// 余额=对应类别总数-对应类别已使用数；再将非限制、限制非过期、限制会过期三类相加
func calculateBundleBalances(tb *model.TaskBalance) (video int, image int, data int) {
// 视频套餐余额
video = (tb.TaskBundleVideoNumber - tb.TaskBundleVideoConsumptionNumber) +
(tb.TaskBundleLimitVideoNumber - tb.TaskBundleLimitVideoConsumptionNumber) +
(tb.TaskBundleLimitVideoExpiredNumber - tb.TaskBundleLimitVideoExpiredConsumptionNumber)
// 图文套餐余额
image = (tb.TaskBundleImageNumber - tb.TaskBundleImageConsumptionNumber) +
(tb.TaskBundleLimitImageNumber - tb.TaskBundleLimitImageConsumptionNumber) +
(tb.TaskBundleLimitImageExpiredNumber - tb.TaskBundleLimitImageExpiredConsumptionNumber)
// 数据分析套餐余额
data = (tb.TaskBundleDataAnalysisNumber - tb.TaskBundleDataAnalysisConsumptionNumber) +
(tb.TaskBundleLimitDataAnalysisNumber - tb.TaskBundleLimitDataAnalysisConsumptionNumber) +
(tb.TaskBundleLimitDataAnalysisExpiredNumber - tb.TaskBundleLimitDataAnalysisExpiredConsumptionNumber)
return
}
// calculateIncreaseBalances 计算增值类别下的三类余额（视频/图文/数据分析）
// 余额=对应类别总数-对应类别已使用数；再将非限制、限制非过期、限制会过期三类相加
func calculateIncreaseBalances(tb *model.TaskBalance) (video int, image int, data int) {
// 视频增值余额
video = (tb.TaskIncreaseVideoNumber - tb.TaskIncreaseVideoConsumptionNumber) +
(tb.TaskIncreaseLimitVideoNumber - tb.TaskIncreaseLimitVideoConsumptionNumber) +
(tb.TaskIncreaseLimitVideoExpiredNumber - tb.TaskIncreaseLimitVideoExpiredConsumptionNumber)
// 图文增值余额
image = (tb.TaskIncreaseImageNumber - tb.TaskIncreaseImageConsumptionNumber) +
(tb.TaskIncreaseLimitImageNumber - tb.TaskIncreaseLimitImageConsumptionNumber) +
(tb.TaskIncreaseLimitImageExpiredNumber - tb.TaskIncreaseLimitImageExpiredConsumptionNumber)
// 数据分析增值余额
data = (tb.TaskIncreaseDataAnalysisNumber - tb.TaskIncreaseDataAnalysisConsumptionNumber) +
(tb.TaskIncreaseLimitDataAnalysisNumber - tb.TaskIncreaseLimitDataAnalysisConsumptionNumber) +
(tb.TaskIncreaseLimitDataAnalysisExpiredNumber - tb.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber)
return
}
// GetUserPendingAndTaskBalances 查询用户待发套餐/增值数量与任务余额（套餐/增值）
// 待发数量来自 task_management，余额来自 task_balance；均按视频/图文/数据分析三类返回
// 待发聚合口径：将该类别下（套餐或增值）的非限制、限制非过期、限制会过期三类相加
// 余额聚合口径：对应类别总数减已使用数后，再将三类相加
func GetUserPendingAndTaskBalances(req *PendingAndBalanceRequest) (*PendingAndBalanceResponse, error) {
// 校验查询条件
if req.SubNum == "" && req.TelNum == "" {
return nil, commonErr.ReturnError(nil, "查询参数错误", "艺人编号和手机号不能同时为空")
}
// 查询任务管理表（待发）
var tm model.TaskManagement
tmQuery := app.ModuleClients.TaskBenchDB.Model(&model.TaskManagement{})
if req.SubNum != "" {
tmQuery = tmQuery.Where("sub_num = ?", req.SubNum)
} else {
tmQuery = tmQuery.Where("tel_num = ?", req.TelNum)
}
// 若不存在，待发视为 0
_ = tmQuery.Take(&tm).Error
// 聚合待发（套餐与增值分开统计）
pendingBundleVideo := tm.PendingBundleVideoCount + tm.PendingBundleLimitVideoCount + tm.PendingBundleLimitVideoExpiredCount
pendingBundleImage := tm.PendingBundleImageCount + tm.PendingBundleLimitImageCount + tm.PendingBundleLimitImageExpiredCount
pendingBundleData := tm.PendingBundleDataAnalysisCount + tm.PendingBundleLimitDataAnalysisCount + tm.PendingBundleLimitDataAnalysisExpiredCount
pendingIncreaseVideo := tm.PendingIncreaseVideoCount + tm.PendingIncreaseLimitVideoCount + tm.PendingIncreaseLimitVideoExpiredCount
pendingIncreaseImage := tm.PendingIncreaseImageCount + tm.PendingIncreaseLimitImageCount + tm.PendingIncreaseLimitImageExpiredCount
pendingIncreaseData := tm.PendingIncreaseDataAnalysisCount + tm.PendingIncreaseLimitDataAnalysisCount + tm.PendingIncreaseLimitDataAnalysisExpiredCount
// 查询任务余额表（当前有效月份优先）
var tb model.TaskBalance
now := time.Now()
tbQuery := app.ModuleClients.TaskBenchDB.Model(&model.TaskBalance{})
if req.SubNum != "" {
tbQuery = tbQuery.Where("sub_num = ?", req.SubNum)
} else {
tbQuery = tbQuery.Where("tel_num = ?", req.TelNum)
}
// 选择当前有效区间的记录，若无则回退到最近一条
err := tbQuery.Where("start_at <= ? AND expired_at >= ?", now, now).Order("start_at DESC").Take(&tb).Error
if err != nil {
// 回退：取最近一条记录（可能没有有效期覆盖 now）
_ = tbQuery.Order("start_at DESC").Take(&tb).Error
}
// 计算套餐与增值余额
bundleVideo, bundleImage, bundleData := calculateBundleBalances(&tb)
increaseVideo, increaseImage, increaseData := calculateIncreaseBalances(&tb)
resp := &PendingAndBalanceResponse{
PendingBundleVideoCount: pendingBundleVideo,
PendingBundleImageCount: pendingBundleImage,
PendingBundleDataAnalysisCount: pendingBundleData,
PendingIncreaseVideoCount: pendingIncreaseVideo,
PendingIncreaseImageCount: pendingIncreaseImage,
PendingIncreaseDataAnalysisCount: pendingIncreaseData,
BundleVideoBalance: bundleVideo,
BundleImageBalance: bundleImage,
BundleDataAnalysisBalance: bundleData,
IncreaseVideoBalance: increaseVideo,
IncreaseImageBalance: increaseImage,
IncreaseDataAnalysisBalance: increaseData,
}
return resp, nil
}
// GetPendingTaskList 查询待指派任务记录 // GetPendingTaskList 查询待指派任务记录
// 根据套餐没有过期的艺人查询TaskManagement表中的记录，如果不存在则构建默认值 // 根据套餐没有过期的艺人查询TaskManagement表中的记录，如果不存在则构建默认值
func GetPendingTaskList(req *TaskQueryRequest, validArtist []ValidArtistInfo) ([]*model.TaskManagement, int64, error) { func GetPendingTaskList(req *TaskQueryRequest, validArtist []ValidArtistInfo) ([]*model.TaskManagement, int64, error) {
@ -204,13 +429,49 @@ func GetPendingTaskList(req *TaskQueryRequest, validArtist []ValidArtistInfo) ([
if !existingSubNums[subNum] { if !existingSubNums[subNum] {
artist := artistMap[subNum] artist := artistMap[subNum]
// 构建默认任务记录 // 构建默认任务记录
// 默认将剩余数量分配到“非限制-套餐权益”类别，其它类别置零
remainingVideo := artist.VideoNumber - artist.VideoConsumptionNumber
remainingImage := artist.ImageNumber - artist.ImageConsumptionNumber
remainingData := artist.DataAnalysisNumber - artist.DataAnalysisConsumptionNumber
if remainingVideo < 0 {
remainingVideo = 0
}
if remainingImage < 0 {
remainingImage = 0
}
if remainingData < 0 {
remainingData = 0
}
defaultTask := &model.TaskManagement{ defaultTask := &model.TaskManagement{
SubNum: subNum, SubNum: subNum,
TelNum: artist.UserPhoneNumber, TelNum: artist.UserPhoneNumber,
ArtistName: artist.UserName, ArtistName: artist.UserName,
PendingVideoCount: artist.VideoNumber - artist.VideoConsumptionNumber,
PendingPostCount: artist.ImageNumber - artist.ImageConsumptionNumber, // 视频
PendingDataCount: artist.DataAnalysisNumber - artist.DataAnalysisConsumptionNumber, PendingBundleVideoCount: remainingVideo,
PendingIncreaseVideoCount: 0,
PendingBundleLimitVideoCount: 0,
PendingIncreaseLimitVideoCount: 0,
PendingBundleLimitVideoExpiredCount: 0,
PendingIncreaseLimitVideoExpiredCount: 0,
// 图片
PendingBundleImageCount: remainingImage,
PendingIncreaseImageCount: 0,
PendingBundleLimitImageCount: 0,
PendingIncreaseLimitImageCount: 0,
PendingBundleLimitImageExpiredCount: 0,
PendingIncreaseLimitImageExpiredCount: 0,
// 数据分析
PendingBundleDataAnalysisCount: remainingData,
PendingIncreaseDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisCount: 0,
PendingIncreaseLimitDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisExpiredCount: 0,
PendingIncreaseLimitDataAnalysisExpiredCount: 0,
ProgressCount: 0, ProgressCount: 0,
CompleteCount: 0, CompleteCount: 0,
CreatedAt: time.Now(), CreatedAt: time.Now(),
@ -248,11 +509,25 @@ func GetPendingTaskList(req *TaskQueryRequest, validArtist []ValidArtistInfo) ([
// 排序 // 排序
if req.SortBy != "" && req.SortType != "" { if req.SortBy != "" && req.SortType != "" {
orderClause := fmt.Sprintf("%s %s", req.SortBy, req.SortType) sortBy := req.SortBy
sortType := req.SortType
if sortType != "asc" && sortType != "desc" && sortType != "ASC" && sortType != "DESC" {
sortType = "DESC"
}
// 将常用聚合字段映射为详细字段总和表达式
switch sortBy {
case "pending_video_count", "pendingVideoCount":
sortBy = "(pending_bundle_limit_video_expired_count + pending_bundle_limit_video_count + pending_increase_limit_video_expired_count + pending_increase_limit_video_count + pending_bundle_video_count + pending_increase_video_count)"
case "pending_post_count", "pendingPostCount":
sortBy = "(pending_bundle_limit_image_expired_count + pending_bundle_limit_image_count + pending_increase_limit_image_expired_count + pending_increase_limit_image_count + pending_bundle_image_count + pending_increase_image_count)"
case "pending_data_count", "pendingDataCount":
sortBy = "(pending_bundle_limit_data_analysis_expired_count + pending_bundle_limit_data_analysis_count + pending_increase_limit_data_analysis_expired_count + pending_increase_limit_data_analysis_count + pending_bundle_data_analysis_count + pending_increase_data_analysis_count)"
}
orderClause := fmt.Sprintf("%s %s", sortBy, sortType)
query = query.Order(orderClause) query = query.Order(orderClause)
} else { } else {
// 默认按待发视频降序 // 默认按待发视频总和降序
query = query.Order("pending_video_count DESC") query = query.Order("(pending_bundle_limit_video_expired_count + pending_bundle_limit_video_count + pending_increase_limit_video_expired_count + pending_increase_limit_video_count + pending_bundle_video_count + pending_increase_video_count) DESC")
} }
// 分页 // 分页
@ -289,9 +564,30 @@ func AssignTask(req *TaskAssignRequest, progressTaskCount int, completeTaskCount
SubNum: req.SubNum, SubNum: req.SubNum,
TelNum: req.TelNum, TelNum: req.TelNum,
ArtistName: req.ArtistName, ArtistName: req.ArtistName,
PendingVideoCount: 0, // 待发视频
PendingPostCount: 0, PendingBundleVideoCount: 0,
PendingDataCount: 0, PendingIncreaseVideoCount: 0,
PendingBundleLimitVideoCount: 0,
PendingIncreaseLimitVideoCount: 0,
PendingBundleLimitVideoExpiredCount: 0,
PendingIncreaseLimitVideoExpiredCount: 0,
// 待发图片
PendingBundleImageCount: 0,
PendingIncreaseImageCount: 0,
PendingBundleLimitImageCount: 0,
PendingIncreaseLimitImageCount: 0,
PendingBundleLimitImageExpiredCount: 0,
PendingIncreaseLimitImageExpiredCount: 0,
// 待发数据分析
PendingBundleDataAnalysisCount: 0,
PendingIncreaseDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisCount: 0,
PendingIncreaseLimitDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisExpiredCount: 0,
PendingIncreaseLimitDataAnalysisExpiredCount: 0,
// 其他字段
ProgressCount: 0,
CompleteCount: 0,
CreatedAt: time.Now(), CreatedAt: time.Now(),
UpdatedAt: time.Now(), UpdatedAt: time.Now(),
} }
@ -305,8 +601,8 @@ func AssignTask(req *TaskAssignRequest, progressTaskCount int, completeTaskCount
} }
} }
// 2. 检查待发数量是否大于0 // 2. 检查待发数量是否大于0（聚合总和）
if taskManagement.PendingVideoCount <= 0 && taskManagement.PendingPostCount <= 0 && taskManagement.PendingDataCount <= 0 { if aggregatePendingVideo(&taskManagement) <= 0 && aggregatePendingImage(&taskManagement) <= 0 && aggregatePendingData(&taskManagement) <= 0 {
tx.Rollback() tx.Rollback()
return commonErr.ReturnError(nil, "无可指派任务", "当前艺人待发视频数、图文数、数据数均为0，无法指派任务") return commonErr.ReturnError(nil, "无可指派任务", "当前艺人待发视频数、图文数、数据数均为0，无法指派任务")
} }
@ -317,13 +613,13 @@ func AssignTask(req *TaskAssignRequest, progressTaskCount int, completeTaskCount
return commonErr.ReturnError(nil, "指派数量不能为负数", "指派数量必须大于等于0") return commonErr.ReturnError(nil, "指派数量不能为负数", "指派数量必须大于等于0")
} }
if req.AssignVideoCount > taskManagement.PendingVideoCount || if req.AssignVideoCount > aggregatePendingVideo(&taskManagement) ||
req.AssignPostCount > taskManagement.PendingPostCount || req.AssignPostCount > aggregatePendingImage(&taskManagement) ||
req.AssignDataCount > taskManagement.PendingDataCount { req.AssignDataCount > aggregatePendingData(&taskManagement) {
tx.Rollback() tx.Rollback()
return commonErr.ReturnError(nil, "指派数量超出限制", return commonErr.ReturnError(nil, "指派数量超出限制",
fmt.Sprintf("指派数量不能超过待发数量。当前待发：视频%d，图文%d，数据%d", fmt.Sprintf("指派数量不能超过待发数量。当前待发：视频%d，图文%d，数据%d",
taskManagement.PendingVideoCount, taskManagement.PendingPostCount, taskManagement.PendingDataCount)) aggregatePendingVideo(&taskManagement), aggregatePendingImage(&taskManagement), aggregatePendingData(&taskManagement)))
} }
if req.AssignVideoCount == 0 && req.AssignPostCount == 0 && req.AssignDataCount == 0 { if req.AssignVideoCount == 0 && req.AssignPostCount == 0 && req.AssignDataCount == 0 {
@ -331,11 +627,41 @@ func AssignTask(req *TaskAssignRequest, progressTaskCount int, completeTaskCount
return commonErr.ReturnError(nil, "指派数量不能全为0", "至少需要指派一种类型的任务") return commonErr.ReturnError(nil, "指派数量不能全为0", "至少需要指派一种类型的任务")
} }
// 4. 更新TaskManagement表 // 4. 按优先级扣减详细待发数量
if req.AssignVideoCount > 0 {
deductVideo(&taskManagement, req.AssignVideoCount)
}
if req.AssignPostCount > 0 {
deductImage(&taskManagement, req.AssignPostCount)
}
if req.AssignDataCount > 0 {
deductData(&taskManagement, req.AssignDataCount)
}
// 汇总更新字段
updateData := map[string]interface{}{ updateData := map[string]interface{}{
"pending_video_count": taskManagement.PendingVideoCount - req.AssignVideoCount, // 视频
"pending_post_count": taskManagement.PendingPostCount - req.AssignPostCount, "pending_bundle_limit_video_expired_count": taskManagement.PendingBundleLimitVideoExpiredCount,
"pending_data_count": taskManagement.PendingDataCount - req.AssignDataCount, "pending_bundle_limit_video_count": taskManagement.PendingBundleLimitVideoCount,
"pending_increase_limit_video_expired_count": taskManagement.PendingIncreaseLimitVideoExpiredCount,
"pending_increase_limit_video_count": taskManagement.PendingIncreaseLimitVideoCount,
"pending_bundle_video_count": taskManagement.PendingBundleVideoCount,
"pending_increase_video_count": taskManagement.PendingIncreaseVideoCount,
// 图片
"pending_bundle_limit_image_expired_count": taskManagement.PendingBundleLimitImageExpiredCount,
"pending_bundle_limit_image_count": taskManagement.PendingBundleLimitImageCount,
"pending_increase_limit_image_expired_count": taskManagement.PendingIncreaseLimitImageExpiredCount,
"pending_increase_limit_image_count": taskManagement.PendingIncreaseLimitImageCount,
"pending_bundle_image_count": taskManagement.PendingBundleImageCount,
"pending_increase_image_count": taskManagement.PendingIncreaseImageCount,
// 数据分析
"pending_bundle_limit_data_analysis_expired_count": taskManagement.PendingBundleLimitDataAnalysisExpiredCount,
"pending_bundle_limit_data_analysis_count": taskManagement.PendingBundleLimitDataAnalysisCount,
"pending_increase_limit_data_analysis_expired_count": taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount,
"pending_increase_limit_data_analysis_count": taskManagement.PendingIncreaseLimitDataAnalysisCount,
"pending_bundle_data_analysis_count": taskManagement.PendingBundleDataAnalysisCount,
"pending_increase_data_analysis_count": taskManagement.PendingIncreaseDataAnalysisCount,
// 其他字段
"last_task_assignee": req.TaskAssignee, "last_task_assignee": req.TaskAssignee,
"task_assignee_num": req.TaskAssigneeNum, "task_assignee_num": req.TaskAssigneeNum,
"progress_count": progressTaskCount, "progress_count": progressTaskCount,
@ -362,9 +688,9 @@ func AssignTask(req *TaskAssignRequest, progressTaskCount int, completeTaskCount
OperatorTime: time.Now(), OperatorTime: time.Now(),
TaskAssignee: req.TaskAssignee, // 指派员工姓名 TaskAssignee: req.TaskAssignee, // 指派员工姓名
TaskAssigneeNum: req.TaskAssigneeNum, // 指派员工账号 TaskAssigneeNum: req.TaskAssigneeNum, // 指派员工账号
PendingVideoCount: taskManagement.PendingVideoCount, PendingVideoCount: aggregatePendingVideo(&taskManagement),
PendingPostCount: taskManagement.PendingPostCount, PendingPostCount: aggregatePendingImage(&taskManagement),
PendingDataCount: taskManagement.PendingDataCount, PendingDataCount: aggregatePendingData(&taskManagement),
AssignVideoCount: req.AssignVideoCount, AssignVideoCount: req.AssignVideoCount,
AssignPostCount: req.AssignPostCount, AssignPostCount: req.AssignPostCount,
AssignDataCount: req.AssignDataCount, AssignDataCount: req.AssignDataCount,
@ -400,7 +726,14 @@ func UpdatePendingCount(req *UpdatePendingCountRequest) error {
// 1. 查询或创建TaskManagement记录 // 1. 查询或创建TaskManagement记录
var taskManagement model.TaskManagement var taskManagement model.TaskManagement
err := tx.Where("sub_num = ? AND tel_num = ?", req.SubNum, req.TelNum).First(&taskManagement).Error // 与查询余额保持一致：优先使用 sub_num，否则使用 tel_num
tmQuery := tx.Model(&model.TaskManagement{})
if req.SubNum != "" {
tmQuery = tmQuery.Where("sub_num = ?", req.SubNum)
} else {
tmQuery = tmQuery.Where("tel_num = ?", req.TelNum)
}
err := tmQuery.First(&taskManagement).Error
if err != nil { if err != nil {
if err == gorm.ErrRecordNotFound { if err == gorm.ErrRecordNotFound {
return commonErr.ReturnError(err, "无该艺人任务记录", "无该艺人任务记录") return commonErr.ReturnError(err, "无该艺人任务记录", "无该艺人任务记录")
@ -408,18 +741,356 @@ func UpdatePendingCount(req *UpdatePendingCountRequest) error {
tx.Rollback() tx.Rollback()
return commonErr.ReturnError(err, "查询任务记录失败", "查询任务记录失败: ") return commonErr.ReturnError(err, "查询任务记录失败", "查询任务记录失败: ")
} }
}
// 2. 查询任务余额记录（当前有效月份优先，若无则回退到最近一条）
var taskBalance model.TaskBalance
now := time.Now()
tbQuery := tx.Model(&model.TaskBalance{})
if req.SubNum != "" {
tbQuery = tbQuery.Where("sub_num = ?", req.SubNum)
} else { } else {
// 更新现有记录 tbQuery = tbQuery.Where("tel_num = ?", req.TelNum)
}
tbErr := tbQuery.Where("start_at <= ? AND expired_at >= ?", now, now).Order("start_at DESC").Take(&taskBalance).Error
if tbErr != nil {
// 回退：取最近一条记录
_ = tbQuery.Order("start_at DESC").Take(&taskBalance).Error
}
// 若余额记录不存在，且本次需要“扣返余额”（目标小于当前）或“占用余额”（目标大于当前），直接报错
// 说明：此处不创建余额记录，避免无源数据导致余额错账
hasBalanceRecord := taskBalance.ID != 0
// 3. 计算当前聚合待发与目标值的差异（目标为绝对值，不是增减）
curVideo := aggregatePendingVideo(&taskManagement)
curImage := aggregatePendingImage(&taskManagement)
curData := aggregatePendingData(&taskManagement)
diffVideo := req.PendingVideoCount - curVideo
diffImage := req.PendingPostCount - curImage
diffData := req.PendingDataCount - curData
// 4. 若需要增加目标（diff>0），从艺人余额中按优先级占用并分配到待发分类
// 优先级：受限>非受限；同类型：打包>增量；受限内：过期优先
if diffVideo > 0 || diffImage > 0 || diffData > 0 {
if !hasBalanceRecord {
tx.Rollback()
return commonErr.ReturnError(nil, "无可用任务余额记录", "该艺人没有任务余额记录，无法占用余额用于增加待发")
}
// 视频占用
if diffVideo > 0 {
need := diffVideo
// 可用余额按分类拆分
availBLE := taskBalance.TaskBundleLimitVideoExpiredNumber - taskBalance.TaskBundleLimitVideoExpiredConsumptionNumber
availILE := taskBalance.TaskIncreaseLimitVideoExpiredNumber - taskBalance.TaskIncreaseLimitVideoExpiredConsumptionNumber
availBL := taskBalance.TaskBundleLimitVideoNumber - taskBalance.TaskBundleLimitVideoConsumptionNumber
availIL := taskBalance.TaskIncreaseLimitVideoNumber - taskBalance.TaskIncreaseLimitVideoConsumptionNumber
availB := taskBalance.TaskBundleVideoNumber - taskBalance.TaskBundleVideoConsumptionNumber
availI := taskBalance.TaskIncreaseVideoNumber - taskBalance.TaskIncreaseVideoConsumptionNumber
// 逐类占用并写入待发分类与消费数
if need > 0 && availBLE > 0 {
take := minInt(need, availBLE)
taskManagement.PendingBundleLimitVideoExpiredCount += take
taskBalance.TaskBundleLimitVideoExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availILE > 0 {
take := minInt(need, availILE)
taskManagement.PendingIncreaseLimitVideoExpiredCount += take
taskBalance.TaskIncreaseLimitVideoExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availBL > 0 {
take := minInt(need, availBL)
taskManagement.PendingBundleLimitVideoCount += take
taskBalance.TaskBundleLimitVideoConsumptionNumber += take
need -= take
}
if need > 0 && availIL > 0 {
take := minInt(need, availIL)
taskManagement.PendingIncreaseLimitVideoCount += take
taskBalance.TaskIncreaseLimitVideoConsumptionNumber += take
need -= take
}
if need > 0 && availB > 0 {
take := minInt(need, availB)
taskManagement.PendingBundleVideoCount += take
taskBalance.TaskBundleVideoConsumptionNumber += take
need -= take
}
if need > 0 && availI > 0 {
take := minInt(need, availI)
taskManagement.PendingIncreaseVideoCount += take
taskBalance.TaskIncreaseVideoConsumptionNumber += take
need -= take
}
if need > 0 {
tx.Rollback()
return commonErr.ReturnError(nil, "视频任务余额不足", "可用余额不足以达到目标待发视频数量")
}
}
// 图片占用
if diffImage > 0 {
need := diffImage
availBLE := taskBalance.TaskBundleLimitImageExpiredNumber - taskBalance.TaskBundleLimitImageExpiredConsumptionNumber
availILE := taskBalance.TaskIncreaseLimitImageExpiredNumber - taskBalance.TaskIncreaseLimitImageExpiredConsumptionNumber
availBL := taskBalance.TaskBundleLimitImageNumber - taskBalance.TaskBundleLimitImageConsumptionNumber
availIL := taskBalance.TaskIncreaseLimitImageNumber - taskBalance.TaskIncreaseLimitImageConsumptionNumber
availB := taskBalance.TaskBundleImageNumber - taskBalance.TaskBundleImageConsumptionNumber
availI := taskBalance.TaskIncreaseImageNumber - taskBalance.TaskIncreaseImageConsumptionNumber
if need > 0 && availBLE > 0 {
take := minInt(need, availBLE)
taskManagement.PendingBundleLimitImageExpiredCount += take
taskBalance.TaskBundleLimitImageExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availILE > 0 {
take := minInt(need, availILE)
taskManagement.PendingIncreaseLimitImageExpiredCount += take
taskBalance.TaskIncreaseLimitImageExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availBL > 0 {
take := minInt(need, availBL)
taskManagement.PendingBundleLimitImageCount += take
taskBalance.TaskBundleLimitImageConsumptionNumber += take
need -= take
}
if need > 0 && availIL > 0 {
take := minInt(need, availIL)
taskManagement.PendingIncreaseLimitImageCount += take
taskBalance.TaskIncreaseLimitImageConsumptionNumber += take
need -= take
}
if need > 0 && availB > 0 {
take := minInt(need, availB)
taskManagement.PendingBundleImageCount += take
taskBalance.TaskBundleImageConsumptionNumber += take
need -= take
}
if need > 0 && availI > 0 {
take := minInt(need, availI)
taskManagement.PendingIncreaseImageCount += take
taskBalance.TaskIncreaseImageConsumptionNumber += take
need -= take
}
if need > 0 {
tx.Rollback()
return commonErr.ReturnError(nil, "图文任务余额不足", "可用余额不足以达到目标待发图文数量")
}
}
// 数据分析占用
if diffData > 0 {
need := diffData
availBLE := taskBalance.TaskBundleLimitDataAnalysisExpiredNumber - taskBalance.TaskBundleLimitDataAnalysisExpiredConsumptionNumber
availILE := taskBalance.TaskIncreaseLimitDataAnalysisExpiredNumber - taskBalance.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber
availBL := taskBalance.TaskBundleLimitDataAnalysisNumber - taskBalance.TaskBundleLimitDataAnalysisConsumptionNumber
availIL := taskBalance.TaskIncreaseLimitDataAnalysisNumber - taskBalance.TaskIncreaseLimitDataAnalysisConsumptionNumber
availB := taskBalance.TaskBundleDataAnalysisNumber - taskBalance.TaskBundleDataAnalysisConsumptionNumber
availI := taskBalance.TaskIncreaseDataAnalysisNumber - taskBalance.TaskIncreaseDataAnalysisConsumptionNumber
if need > 0 && availBLE > 0 {
take := minInt(need, availBLE)
taskManagement.PendingBundleLimitDataAnalysisExpiredCount += take
taskBalance.TaskBundleLimitDataAnalysisExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availILE > 0 {
take := minInt(need, availILE)
taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount += take
taskBalance.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber += take
need -= take
}
if need > 0 && availBL > 0 {
take := minInt(need, availBL)
taskManagement.PendingBundleLimitDataAnalysisCount += take
taskBalance.TaskBundleLimitDataAnalysisConsumptionNumber += take
need -= take
}
if need > 0 && availIL > 0 {
take := minInt(need, availIL)
taskManagement.PendingIncreaseLimitDataAnalysisCount += take
taskBalance.TaskIncreaseLimitDataAnalysisConsumptionNumber += take
need -= take
}
if need > 0 && availB > 0 {
take := minInt(need, availB)
taskManagement.PendingBundleDataAnalysisCount += take
taskBalance.TaskBundleDataAnalysisConsumptionNumber += take
need -= take
}
if need > 0 && availI > 0 {
take := minInt(need, availI)
taskManagement.PendingIncreaseDataAnalysisCount += take
taskBalance.TaskIncreaseDataAnalysisConsumptionNumber += take
need -= take
}
if need > 0 {
tx.Rollback()
return commonErr.ReturnError(nil, "数据分析任务余额不足", "可用余额不足以达到目标待发数据分析数量")
}
}
}
// 5. 若需要减少目标（diff<0），先按优先级从待发分类扣减，并将扣减的数量按对应分类冲回余额（减少消费数）
if diffVideo < 0 || diffImage < 0 || diffData < 0 {
if !hasBalanceRecord {
tx.Rollback()
return commonErr.ReturnError(nil, "无可用任务余额记录", "该艺人没有任务余额记录，无法将多余待发冲回余额")
}
// 视频冲回
if diffVideo < 0 {
refund := -diffVideo
// 记录扣减前的各分类待发值
prevBLE := taskManagement.PendingBundleLimitVideoExpiredCount
prevILE := taskManagement.PendingIncreaseLimitVideoExpiredCount
prevBL := taskManagement.PendingBundleLimitVideoCount
prevIL := taskManagement.PendingIncreaseLimitVideoCount
prevB := taskManagement.PendingBundleVideoCount
prevI := taskManagement.PendingIncreaseVideoCount
deductVideo(&taskManagement, refund)
// 计算各分类被扣减的数量，并减少对应消费数（不可小于0）
removedBLE := prevBLE - taskManagement.PendingBundleLimitVideoExpiredCount
removedILE := prevILE - taskManagement.PendingIncreaseLimitVideoExpiredCount
removedBL := prevBL - taskManagement.PendingBundleLimitVideoCount
removedIL := prevIL - taskManagement.PendingIncreaseLimitVideoCount
removedB := prevB - taskManagement.PendingBundleVideoCount
removedI := prevI - taskManagement.PendingIncreaseVideoCount
taskBalance.TaskBundleLimitVideoExpiredConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitVideoExpiredConsumptionNumber-removedBLE)
taskBalance.TaskIncreaseLimitVideoExpiredConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitVideoExpiredConsumptionNumber-removedILE)
taskBalance.TaskBundleLimitVideoConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitVideoConsumptionNumber-removedBL)
taskBalance.TaskIncreaseLimitVideoConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitVideoConsumptionNumber-removedIL)
taskBalance.TaskBundleVideoConsumptionNumber = maxInt(0, taskBalance.TaskBundleVideoConsumptionNumber-removedB)
taskBalance.TaskIncreaseVideoConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseVideoConsumptionNumber-removedI)
}
// 图片冲回
if diffImage < 0 {
refund := -diffImage
prevBLE := taskManagement.PendingBundleLimitImageExpiredCount
prevILE := taskManagement.PendingIncreaseLimitImageExpiredCount
prevBL := taskManagement.PendingBundleLimitImageCount
prevIL := taskManagement.PendingIncreaseLimitImageCount
prevB := taskManagement.PendingBundleImageCount
prevI := taskManagement.PendingIncreaseImageCount
deductImage(&taskManagement, refund)
removedBLE := prevBLE - taskManagement.PendingBundleLimitImageExpiredCount
removedILE := prevILE - taskManagement.PendingIncreaseLimitImageExpiredCount
removedBL := prevBL - taskManagement.PendingBundleLimitImageCount
removedIL := prevIL - taskManagement.PendingIncreaseLimitImageCount
removedB := prevB - taskManagement.PendingBundleImageCount
removedI := prevI - taskManagement.PendingIncreaseImageCount
taskBalance.TaskBundleLimitImageExpiredConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitImageExpiredConsumptionNumber-removedBLE)
taskBalance.TaskIncreaseLimitImageExpiredConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitImageExpiredConsumptionNumber-removedILE)
taskBalance.TaskBundleLimitImageConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitImageConsumptionNumber-removedBL)
taskBalance.TaskIncreaseLimitImageConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitImageConsumptionNumber-removedIL)
taskBalance.TaskBundleImageConsumptionNumber = maxInt(0, taskBalance.TaskBundleImageConsumptionNumber-removedB)
taskBalance.TaskIncreaseImageConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseImageConsumptionNumber-removedI)
}
// 数据分析冲回
if diffData < 0 {
refund := -diffData
prevBLE := taskManagement.PendingBundleLimitDataAnalysisExpiredCount
prevILE := taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount
prevBL := taskManagement.PendingBundleLimitDataAnalysisCount
prevIL := taskManagement.PendingIncreaseLimitDataAnalysisCount
prevB := taskManagement.PendingBundleDataAnalysisCount
prevI := taskManagement.PendingIncreaseDataAnalysisCount
deductData(&taskManagement, refund)
removedBLE := prevBLE - taskManagement.PendingBundleLimitDataAnalysisExpiredCount
removedILE := prevILE - taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount
removedBL := prevBL - taskManagement.PendingBundleLimitDataAnalysisCount
removedIL := prevIL - taskManagement.PendingIncreaseLimitDataAnalysisCount
removedB := prevB - taskManagement.PendingBundleDataAnalysisCount
removedI := prevI - taskManagement.PendingIncreaseDataAnalysisCount
taskBalance.TaskBundleLimitDataAnalysisExpiredConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitDataAnalysisExpiredConsumptionNumber-removedBLE)
taskBalance.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber-removedILE)
taskBalance.TaskBundleLimitDataAnalysisConsumptionNumber = maxInt(0, taskBalance.TaskBundleLimitDataAnalysisConsumptionNumber-removedBL)
taskBalance.TaskIncreaseLimitDataAnalysisConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseLimitDataAnalysisConsumptionNumber-removedIL)
taskBalance.TaskBundleDataAnalysisConsumptionNumber = maxInt(0, taskBalance.TaskBundleDataAnalysisConsumptionNumber-removedB)
taskBalance.TaskIncreaseDataAnalysisConsumptionNumber = maxInt(0, taskBalance.TaskIncreaseDataAnalysisConsumptionNumber-removedI)
}
}
// 6. 更新TaskManagement表
updateData := map[string]interface{}{ updateData := map[string]interface{}{
"pending_video_count": req.PendingVideoCount, // 视频
"pending_post_count": req.PendingPostCount, "pending_bundle_limit_video_expired_count": taskManagement.PendingBundleLimitVideoExpiredCount,
"pending_data_count": req.PendingDataCount, "pending_bundle_limit_video_count": taskManagement.PendingBundleLimitVideoCount,
"pending_increase_limit_video_expired_count": taskManagement.PendingIncreaseLimitVideoExpiredCount,
"pending_increase_limit_video_count": taskManagement.PendingIncreaseLimitVideoCount,
"pending_bundle_video_count": taskManagement.PendingBundleVideoCount,
"pending_increase_video_count": taskManagement.PendingIncreaseVideoCount,
// 图片
"pending_bundle_limit_image_expired_count": taskManagement.PendingBundleLimitImageExpiredCount,
"pending_bundle_limit_image_count": taskManagement.PendingBundleLimitImageCount,
"pending_increase_limit_image_expired_count": taskManagement.PendingIncreaseLimitImageExpiredCount,
"pending_increase_limit_image_count": taskManagement.PendingIncreaseLimitImageCount,
"pending_bundle_image_count": taskManagement.PendingBundleImageCount,
"pending_increase_image_count": taskManagement.PendingIncreaseImageCount,
// 数据分析
"pending_bundle_limit_data_analysis_expired_count": taskManagement.PendingBundleLimitDataAnalysisExpiredCount,
"pending_bundle_limit_data_analysis_count": taskManagement.PendingBundleLimitDataAnalysisCount,
"pending_increase_limit_data_analysis_expired_count": taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount,
"pending_increase_limit_data_analysis_count": taskManagement.PendingIncreaseLimitDataAnalysisCount,
"pending_bundle_data_analysis_count": taskManagement.PendingBundleDataAnalysisCount,
"pending_increase_data_analysis_count": taskManagement.PendingIncreaseDataAnalysisCount,
// 通用
"updated_at": time.Now(), "updated_at": time.Now(),
} }
if err = tx.Model(&taskManagement).Updates(updateData).Error; err != nil { if err = tx.Model(&taskManagement).Updates(updateData).Error; err != nil {
tx.Rollback() tx.Rollback()
return commonErr.ReturnError(err, "更新任务记录失败", "更新任务记录失败: ") return commonErr.ReturnError(err, "更新任务记录失败", "更新任务记录失败: ")
} }
// 7. 更新TaskBalance（消费数发生变化时）
if hasBalanceRecord {
updateBal := map[string]interface{}{
// 视频消费数
"task_bundle_limit_video_expired_consumption_number": taskBalance.TaskBundleLimitVideoExpiredConsumptionNumber,
"task_increase_limit_video_expired_consumption_number": taskBalance.TaskIncreaseLimitVideoExpiredConsumptionNumber,
"task_bundle_limit_video_consumption_number": taskBalance.TaskBundleLimitVideoConsumptionNumber,
"task_increase_limit_video_consumption_number": taskBalance.TaskIncreaseLimitVideoConsumptionNumber,
"task_bundle_video_consumption_number": taskBalance.TaskBundleVideoConsumptionNumber,
"task_increase_video_consumption_number": taskBalance.TaskIncreaseVideoConsumptionNumber,
// 图片消费数
"task_bundle_limit_image_expired_consumption_number": taskBalance.TaskBundleLimitImageExpiredConsumptionNumber,
"task_increase_limit_image_expired_consumption_number": taskBalance.TaskIncreaseLimitImageExpiredConsumptionNumber,
"task_bundle_limit_image_consumption_number": taskBalance.TaskBundleLimitImageConsumptionNumber,
"task_increase_limit_image_consumption_number": taskBalance.TaskIncreaseLimitImageConsumptionNumber,
"task_bundle_image_consumption_number": taskBalance.TaskBundleImageConsumptionNumber,
"task_increase_image_consumption_number": taskBalance.TaskIncreaseImageConsumptionNumber,
// 数据分析消费数
"task_bundle_limit_data_analysis_expired_consumption_number": taskBalance.TaskBundleLimitDataAnalysisExpiredConsumptionNumber,
"task_increase_limit_data_analysis_expired_consumption_number": taskBalance.TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber,
"task_bundle_limit_data_analysis_consumption_number": taskBalance.TaskBundleLimitDataAnalysisConsumptionNumber,
"task_increase_limit_data_analysis_consumption_number": taskBalance.TaskIncreaseLimitDataAnalysisConsumptionNumber,
"task_bundle_data_analysis_consumption_number": taskBalance.TaskBundleDataAnalysisConsumptionNumber,
"task_increase_data_analysis_consumption_number": taskBalance.TaskIncreaseDataAnalysisConsumptionNumber,
// 通用
"updated_at": time.Now(),
}
if err = tx.Model(&taskBalance).Updates(updateBal).Error; err != nil {
tx.Rollback()
return commonErr.ReturnError(err, "更新任务余额失败", "更新任务余额失败: ")
}
} }
// 提交事务 // 提交事务
@ -430,6 +1101,22 @@ func UpdatePendingCount(req *UpdatePendingCountRequest) error {
return nil return nil
} }
// minInt 返回两个整数的较小值
func minInt(a, b int) int {
if a < b {
return a
}
return b
}
// maxInt 返回两个整数的较大值
func maxInt(a, b int) int {
if a > b {
return a
}
return b
}
// GetRecentAssignRecords 查询最近被指派记录 // GetRecentAssignRecords 查询最近被指派记录
// 查询操作类型为"指派"的最近n条不同员工的记录 // 查询操作类型为"指派"的最近n条不同员工的记录
func GetRecentAssignRecords(limit int) ([]*model.TaskAssignRecords, error) { func GetRecentAssignRecords(limit int) ([]*model.TaskAssignRecords, error) {
@ -752,9 +1439,16 @@ func GetValidArtistList() ([]ValidArtistInfo, error) {
session := app.ModuleClients.BundleDB.Table("`micro-account`.`user` AS u"). session := app.ModuleClients.BundleDB.Table("`micro-account`.`user` AS u").
Select(`u.id as user_id, bor.customer_num, rn.name as user_name, Select(`u.id as user_id, bor.customer_num, rn.name as user_name,
u.tel_num as user_phone_number, bor.bundle_name, bor.expiration_time, u.tel_num as user_phone_number, bor.bundle_name, bor.expiration_time,
bor.status, bor.uuid as order_uuid, bb.account_number, bb.account_consumption_number, bor.status, bor.uuid as order_uuid,
bb.video_number, bb.video_consumption_number, bb.image_number, bb.image_consumption_number, (bb.bundle_account_number + bb.increase_account_number + bb.manual_account_number) as account_number,
bb.data_analysis_number, bb.data_analysis_consumption_number, bb.expansion_packs_number`). (bb.bundle_account_consumption_number + bb.increase_account_consumption_number + bb.manual_account_consumption_number) as account_consumption_number,
(bb.bundle_video_number + bb.increase_video_number) as video_number,
(bb.bundle_video_consumption_number + bb.increase_video_consumption_number) as video_consumption_number,
(bb.bundle_image_number + bb.increase_image_number + bb.manual_image_number) as image_number,
(bb.bundle_image_consumption_number + bb.increase_image_consumption_number + bb.manual_image_consumption_number) as image_consumption_number,
(bb.bundle_data_analysis_number + bb.increase_data_analysis_number + bb.manual_data_analysis_number) as data_analysis_number,
(bb.bundle_data_analysis_consumption_number + bb.increase_data_analysis_consumption_number + bb.manual_data_analysis_consumption_number) as data_analysis_consumption_number,
bb.expansion_packs_number`).
Joins("LEFT JOIN `micro-account`.real_name rn ON u.real_name_id = rn.id"). Joins("LEFT JOIN `micro-account`.real_name rn ON u.real_name_id = rn.id").
Joins("LEFT JOIN (?) as bor ON bor.customer_id = u.id", subQuery). Joins("LEFT JOIN (?) as bor ON bor.customer_id = u.id", subQuery).
Joins("LEFT JOIN bundle_balance bb ON u.id = bb.user_id AND bb.order_uuid = bor.uuid"). Joins("LEFT JOIN bundle_balance bb ON u.id = bb.user_id AND bb.order_uuid = bor.uuid").
@ -892,29 +1586,53 @@ func AdjustPendingCount(req *AdjustPendingCountRequest) error {
if err != nil { if err != nil {
if err == gorm.ErrRecordNotFound { if err == gorm.ErrRecordNotFound {
if req.CreateIfNotExists { if req.CreateIfNotExists {
// 创建新记录 // 创建新记录，正数增加分配到“非限制-套餐权益”，负数忽略（置0）
video := req.AdjustVideoCount
post := req.AdjustPostCount
data := req.AdjustDataCount
if video < 0 {
video = 0
}
if post < 0 {
post = 0
}
if data < 0 {
data = 0
}
taskManagement = model.TaskManagement{ taskManagement = model.TaskManagement{
SubNum: req.SubNum, SubNum: req.SubNum,
TelNum: req.TelNum, TelNum: req.TelNum,
ArtistName: req.ArtistName, ArtistName: req.ArtistName,
PendingVideoCount: req.AdjustVideoCount,
PendingPostCount: req.AdjustPostCount, // 视频
PendingDataCount: req.AdjustDataCount, PendingBundleVideoCount: video,
PendingIncreaseVideoCount: 0,
PendingBundleLimitVideoCount: 0,
PendingIncreaseLimitVideoCount: 0,
PendingBundleLimitVideoExpiredCount: 0,
PendingIncreaseLimitVideoExpiredCount: 0,
// 图片
PendingBundleImageCount: post,
PendingIncreaseImageCount: 0,
PendingBundleLimitImageCount: 0,
PendingIncreaseLimitImageCount: 0,
PendingBundleLimitImageExpiredCount: 0,
PendingIncreaseLimitImageExpiredCount: 0,
// 数据分析
PendingBundleDataAnalysisCount: data,
PendingIncreaseDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisCount: 0,
PendingIncreaseLimitDataAnalysisCount: 0,
PendingBundleLimitDataAnalysisExpiredCount: 0,
PendingIncreaseLimitDataAnalysisExpiredCount: 0,
ProgressCount: 0, ProgressCount: 0,
CompleteCount: 0, CompleteCount: 0,
CreatedAt: time.Now(), CreatedAt: time.Now(),
UpdatedAt: time.Now(), UpdatedAt: time.Now(),
} }
// 确保数量不为负数
if taskManagement.PendingVideoCount < 0 {
taskManagement.PendingVideoCount = 0
}
if taskManagement.PendingPostCount < 0 {
taskManagement.PendingPostCount = 0
}
if taskManagement.PendingDataCount < 0 {
taskManagement.PendingDataCount = 0
}
if err = tx.Create(&taskManagement).Error; err != nil { if err = tx.Create(&taskManagement).Error; err != nil {
tx.Rollback() tx.Rollback()
return commonErr.ReturnError(err, "创建任务记录失败", "创建任务记录失败: ") return commonErr.ReturnError(err, "创建任务记录失败", "创建任务记录失败: ")
@ -928,27 +1646,49 @@ func AdjustPendingCount(req *AdjustPendingCountRequest) error {
return commonErr.ReturnError(err, "查询任务记录失败", "查询任务记录失败: ") return commonErr.ReturnError(err, "查询任务记录失败", "查询任务记录失败: ")
} }
} else { } else {
// 2. 计算调整后的数量 // 2. 计算调整：正数增加分配到“非限制-套餐权益”；负数按优先级扣减
newVideoCount := taskManagement.PendingVideoCount + req.AdjustVideoCount if req.AdjustVideoCount > 0 {
newPostCount := taskManagement.PendingPostCount + req.AdjustPostCount taskManagement.PendingBundleVideoCount += req.AdjustVideoCount
newDataCount := taskManagement.PendingDataCount + req.AdjustDataCount } else if req.AdjustVideoCount < 0 {
deductVideo(&taskManagement, -req.AdjustVideoCount)
}
// 3. 确保调整后的数量不为负数 if req.AdjustPostCount > 0 {
if newVideoCount < 0 { taskManagement.PendingBundleImageCount += req.AdjustPostCount
newVideoCount = 0 } else if req.AdjustPostCount < 0 {
deductImage(&taskManagement, -req.AdjustPostCount)
} }
if newPostCount < 0 {
newPostCount = 0 if req.AdjustDataCount > 0 {
} taskManagement.PendingBundleDataAnalysisCount += req.AdjustDataCount
if newDataCount < 0 { } else if req.AdjustDataCount < 0 {
newDataCount = 0 deductData(&taskManagement, -req.AdjustDataCount)
} }
// 4. 更新TaskManagement表 // 4. 更新TaskManagement表
updateData := map[string]interface{}{ updateData := map[string]interface{}{
"pending_video_count": newVideoCount, // 视频
"pending_post_count": newPostCount, "pending_bundle_limit_video_expired_count": taskManagement.PendingBundleLimitVideoExpiredCount,
"pending_data_count": newDataCount, "pending_bundle_limit_video_count": taskManagement.PendingBundleLimitVideoCount,
"pending_increase_limit_video_expired_count": taskManagement.PendingIncreaseLimitVideoExpiredCount,
"pending_increase_limit_video_count": taskManagement.PendingIncreaseLimitVideoCount,
"pending_bundle_video_count": taskManagement.PendingBundleVideoCount,
"pending_increase_video_count": taskManagement.PendingIncreaseVideoCount,
// 图片
"pending_bundle_limit_image_expired_count": taskManagement.PendingBundleLimitImageExpiredCount,
"pending_bundle_limit_image_count": taskManagement.PendingBundleLimitImageCount,
"pending_increase_limit_image_expired_count": taskManagement.PendingIncreaseLimitImageExpiredCount,
"pending_increase_limit_image_count": taskManagement.PendingIncreaseLimitImageCount,
"pending_bundle_image_count": taskManagement.PendingBundleImageCount,
"pending_increase_image_count": taskManagement.PendingIncreaseImageCount,
// 数据分析
"pending_bundle_limit_data_analysis_expired_count": taskManagement.PendingBundleLimitDataAnalysisExpiredCount,
"pending_bundle_limit_data_analysis_count": taskManagement.PendingBundleLimitDataAnalysisCount,
"pending_increase_limit_data_analysis_expired_count": taskManagement.PendingIncreaseLimitDataAnalysisExpiredCount,
"pending_increase_limit_data_analysis_count": taskManagement.PendingIncreaseLimitDataAnalysisCount,
"pending_bundle_data_analysis_count": taskManagement.PendingBundleDataAnalysisCount,
"pending_increase_data_analysis_count": taskManagement.PendingIncreaseDataAnalysisCount,
// 通用
"updated_at": time.Now(), "updated_at": time.Now(),
} }

131
internal/logic/taskLogic.go
View File

@ -1,6 +1,7 @@
package logic package logic
import ( import (
"fmt"
"micro-bundle/internal/dao" "micro-bundle/internal/dao"
commonErr "micro-bundle/pkg/err" commonErr "micro-bundle/pkg/err"
) )
@ -77,6 +78,11 @@ func GetPendingTaskList(req *dao.TaskQueryRequest) ([]*dao.TaskQueryResponse, in
// 3. 转换为响应结构体 // 3. 转换为响应结构体
var recordResponse []*dao.TaskQueryResponse var recordResponse []*dao.TaskQueryResponse
for _, record := range record { for _, record := range record {
// 计算聚合的待发数量：视频、图文、数据分析
videoTotal := record.PendingBundleLimitVideoExpiredCount + record.PendingBundleLimitVideoCount + record.PendingIncreaseLimitVideoExpiredCount + record.PendingIncreaseLimitVideoCount + record.PendingBundleVideoCount + record.PendingIncreaseVideoCount
imageTotal := record.PendingBundleLimitImageExpiredCount + record.PendingBundleLimitImageCount + record.PendingIncreaseLimitImageExpiredCount + record.PendingIncreaseLimitImageCount + record.PendingBundleImageCount + record.PendingIncreaseImageCount
dataTotal := record.PendingBundleLimitDataAnalysisExpiredCount + record.PendingBundleLimitDataAnalysisCount + record.PendingIncreaseLimitDataAnalysisExpiredCount + record.PendingIncreaseLimitDataAnalysisCount + record.PendingBundleDataAnalysisCount + record.PendingIncreaseDataAnalysisCount
// 根据 SubNum 和 TelNum 查询对应的员工正在进行中的任务和已完成任务数量 // 根据 SubNum 和 TelNum 查询对应的员工正在进行中的任务和已完成任务数量
progressTaskCount, completeTaskCount, err := dao.GetTaskAssigneeInfo(record.TaskAssigneeNum) progressTaskCount, completeTaskCount, err := dao.GetTaskAssigneeInfo(record.TaskAssigneeNum)
if err != nil { if err != nil {
@ -85,9 +91,9 @@ func GetPendingTaskList(req *dao.TaskQueryRequest) ([]*dao.TaskQueryResponse, in
TelNum: record.TelNum, TelNum: record.TelNum,
ArtistName: record.ArtistName, ArtistName: record.ArtistName,
TaskAssigneeNum: record.TaskAssigneeNum, TaskAssigneeNum: record.TaskAssigneeNum,
PendingPostCount: record.PendingPostCount, PendingPostCount: imageTotal,
PendingVideoCount: record.PendingVideoCount, PendingVideoCount: videoTotal,
PendingDataCount: record.PendingDataCount, PendingDataCount: dataTotal,
ProgressTaskCount: 0, ProgressTaskCount: 0,
CompleteTaskCount: 0, CompleteTaskCount: 0,
LastTaskAssignee: record.LastTaskAssignee, LastTaskAssignee: record.LastTaskAssignee,
@ -98,9 +104,9 @@ func GetPendingTaskList(req *dao.TaskQueryRequest) ([]*dao.TaskQueryResponse, in
TelNum: record.TelNum, TelNum: record.TelNum,
ArtistName: record.ArtistName, ArtistName: record.ArtistName,
TaskAssigneeNum: record.TaskAssigneeNum, TaskAssigneeNum: record.TaskAssigneeNum,
PendingPostCount: record.PendingPostCount, PendingPostCount: imageTotal,
PendingVideoCount: record.PendingVideoCount, PendingVideoCount: videoTotal,
PendingDataCount: record.PendingDataCount, PendingDataCount: dataTotal,
ProgressTaskCount: progressTaskCount, ProgressTaskCount: progressTaskCount,
CompleteTaskCount: completeTaskCount, CompleteTaskCount: completeTaskCount,
LastTaskAssignee: record.LastTaskAssignee, LastTaskAssignee: record.LastTaskAssignee,
@ -154,7 +160,46 @@ func UpdatePendingCount(req *dao.UpdatePendingCountRequest) error {
return commonErr.ReturnError(nil, "艺人套餐已过期", "该艺人没有有效的套餐，无法修改待发数量") return commonErr.ReturnError(nil, "艺人套餐已过期", "该艺人没有有效的套餐，无法修改待发数量")
} }
// todo 需要调用套餐的接口，判断艺人是否有那么数量可以修改 // 查询艺人当前任务余额与待发汇总，校验待发数量和余额的总和是否足够
resp, err := dao.GetUserPendingAndTaskBalances(&dao.PendingAndBalanceRequest{
SubNum: req.SubNum,
TelNum: req.TelNum,
})
if err != nil {
return commonErr.ReturnError(err, "查询艺人任务余额失败", "查询艺人任务余额失败: ")
}
// 计算当前待发数量（聚合所有类型）
curVideo := resp.PendingBundleVideoCount + resp.PendingIncreaseVideoCount
curImage := resp.PendingBundleImageCount + resp.PendingIncreaseImageCount
curData := resp.PendingBundleDataAnalysisCount + resp.PendingIncreaseDataAnalysisCount
// 计算可用余额（套餐 + 增值）
availVideo := resp.BundleVideoBalance + resp.IncreaseVideoBalance
availImage := resp.BundleImageBalance + resp.IncreaseImageBalance
availData := resp.BundleDataAnalysisBalance + resp.IncreaseDataAnalysisBalance
// 校验：当前待发数量 + 艺人余额 >= 目标数量
// 这确保了可以优先扣减待发数量，不足时再扣减余额
totalAvailVideo := curVideo + availVideo
totalAvailImage := curImage + availImage
totalAvailData := curData + availData
if req.PendingVideoCount > totalAvailVideo {
return commonErr.ReturnError(nil, "视频任务数量不足",
fmt.Sprintf("目标待发视频数量(%d)超出当前待发数量(%d)和可用余额(%d)的总和(%d)",
req.PendingVideoCount, curVideo, availVideo, totalAvailVideo))
}
if req.PendingPostCount > totalAvailImage {
return commonErr.ReturnError(nil, "图文任务数量不足",
fmt.Sprintf("目标待发图文数量(%d)超出当前待发数量(%d)和可用余额(%d)的总和(%d)",
req.PendingPostCount, curImage, availImage, totalAvailImage))
}
if req.PendingDataCount > totalAvailData {
return commonErr.ReturnError(nil, "数据分析任务数量不足",
fmt.Sprintf("目标待发数据分析数量(%d)超出当前待发数量(%d)和可用余额(%d)的总和(%d)",
req.PendingDataCount, curData, availData, totalAvailData))
}
// 2. 调用DAO层更新待发数量 // 2. 调用DAO层更新待发数量
return dao.UpdatePendingCount(req) return dao.UpdatePendingCount(req)
@ -212,11 +257,11 @@ func GetEmployeeAssignedTasks(req *dao.EmployeeTaskQueryRequest) ([]*dao.TaskAss
// CompleteTaskManually 员工手动点击完成任务 // CompleteTaskManually 员工手动点击完成任务
func CompleteTaskManually(assignRecordsUUID string, taskAssigneeNum string) error { func CompleteTaskManually(assignRecordsUUID string, taskAssigneeNum string) error {
// 第一步，批量更新记录被指派的员工为taskAssigneeNum的待完成任务数量和已经完成任务的数量 // // 第一步，批量更新记录被指派的员工为taskAssigneeNum的待完成任务数量和已经完成任务的数量
err := dao.UpdateTaskRecordsByAssigneeNum(taskAssigneeNum) // err := dao.UpdateTaskRecordsByAssigneeNum(taskAssigneeNum)
if err != nil { // if err != nil {
return err // return err
} // }
return dao.CompleteTaskManually(assignRecordsUUID) return dao.CompleteTaskManually(assignRecordsUUID)
} }
@ -225,55 +270,6 @@ func UpdateTaskProgress(req *dao.CompleteTaskRequest) error {
return dao.UpdateTaskProgress(req) return dao.UpdateTaskProgress(req)
} }
// // GetArtistBundleInfo 获取艺人套餐信息（用于判断套餐多媒体数量）
// func GetArtistBundleInfo(customerNum string) ([]*model.BundleOrderRecords, error) {
// var orderRecords []*model.BundleOrderRecords
// currentTime := time.Now().Format("2006-01-02 15:04:05")
// // 查询该艺人的有效套餐订单
// err := app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).
// Where("customer_num = ? AND expiration_time > ? AND status = ?",
// customerNum, currentTime, 2). // 2:已签已支付
// Preload("BundleOrderValueAdd").
// Find(&orderRecords).Error
// if err != nil {
// return nil, commonErr.ReturnError(err, "查询艺人套餐信息失败", "查询艺人套餐信息失败: ")
// }
// return orderRecords, nil
// }
// // CalculateArtistPendingCounts 计算艺人的待发数量
// // 根据套餐信息计算艺人可以额外多发的多媒体内容数量
// func CalculateArtistPendingCounts(customerNum string) (videoCount, postCount, dataCount int, err error) {
// // 获取艺人套餐信息
// orderRecords, err := GetArtistBundleInfo(customerNum)
// if err != nil {
// return 0, 0, 0, err
// }
// // 计算总的可用数量
// for _, record := range orderRecords {
// // 从套餐基础数量计算
// videoCount += int(record.Num) // 假设Num字段表示视频数量
// // 从增值服务计算
// for _, valueAdd := range record.BundleOrderValueAdd {
// switch valueAdd.ServiceType {
// case 1: // 视频
// videoCount += int(valueAdd.Num)
// case 2: // 图文
// postCount += int(valueAdd.Num)
// case 3: // 数据报表
// dataCount += int(valueAdd.Num)
// }
// }
// }
// return videoCount, postCount, dataCount, nil
// }
// GetTaskAssignRecordsList 多条件查询操作记录表 // GetTaskAssignRecordsList 多条件查询操作记录表
func GetTaskAssignRecordsList(req *dao.TaskAssignRecordsQueryRequest) ([]*dao.TaskAssignRecordsResponse, int64, error) { func GetTaskAssignRecordsList(req *dao.TaskAssignRecordsQueryRequest) ([]*dao.TaskAssignRecordsResponse, int64, error) {
record, total, err := dao.GetTaskAssignRecordsList(req) record, total, err := dao.GetTaskAssignRecordsList(req)
@ -308,7 +304,14 @@ func GetTaskAssignRecordsList(req *dao.TaskAssignRecordsQueryRequest) ([]*dao.Ta
return recordResponse, total, nil return recordResponse, total, nil
} }
// GetArtistBundleBalance 查询艺人套餐剩余数量 // // GetArtistBundleBalance 查询艺人套餐剩余数量
func GetArtistBundleBalance(req *dao.ArtistBundleBalanceRequest) (*dao.ArtistBundleBalanceResponse, error) { // func GetArtistBundleBalance(req *dao.ArtistBundleBalanceRequest) (*dao.ArtistBundleBalanceResponse, error) {
return dao.GetArtistBundleBalance(req) // return dao.GetArtistBundleBalance(req)
// }
// GetPendingAndTaskBalances 查询艺人当前的待发数量与任务余额（区分套餐/增值）
// 根据艺人的编号 SubNum 或手机号 TelNum 进行查询，优先使用编号
// 返回的数据会区分为“套餐类型”和“增值类型”两大类，涵盖视频/图文/数据分析三种任务
func GetPendingAndTaskBalances(req *dao.PendingAndBalanceRequest) (*dao.PendingAndBalanceResponse, error) {
return dao.GetUserPendingAndTaskBalances(req)
} }

156
internal/model/task.go
View File

@ -11,9 +11,31 @@ type TaskManagement struct {
SubNum string `gorm:"column:sub_num;comment:用户编号;index:idx_sub_num;index:idx_sub_tel,priority:1" json:"subNum"` SubNum string `gorm:"column:sub_num;comment:用户编号;index:idx_sub_num;index:idx_sub_tel,priority:1" json:"subNum"`
TelNum string `gorm:"column:tel_num;comment:手机号;index:idx_tel_num;index:idx_sub_tel,priority:2" json:"telNum"` TelNum string `gorm:"column:tel_num;comment:手机号;index:idx_tel_num;index:idx_sub_tel,priority:2" json:"telNum"`
ArtistName string `gorm:"column:artist_name;comment:艺人名称;index:idx_artist_name" json:"artistName"` ArtistName string `gorm:"column:artist_name;comment:艺人名称;index:idx_artist_name" json:"artistName"`
PendingVideoCount int `gorm:"column:pending_video_count;comment:待发视频数量;index:idx_pending_video" json:"pendingVideoCount"`
PendingPostCount int `gorm:"column:pending_post_count;comment:待发图文数量" json:"pendingPostCount"` // ===== 待发视频类任务 =====
PendingDataCount int `gorm:"column:pending_data_count;comment:待发数据数量" json:"pendingDataCount"` PendingBundleVideoCount int `gorm:"column:pending_bundle_video_count;comment:待发非限制类型套餐权益视频数量" json:"pendingBundleVideoCount"`
PendingIncreaseVideoCount int `gorm:"column:pending_increase_video_count;comment:待发非限制类型增值权益视频数量" json:"pendingIncreaseVideoCount"`
PendingBundleLimitVideoCount int `gorm:"column:pending_bundle_limit_video_count;comment:待发套餐权益限制类型非过期视频数量" json:"pendingBundleLimitVideoCount"`
PendingIncreaseLimitVideoCount int `gorm:"column:pending_increase_limit_video_count;comment:待发增值权益限制类型非过期视频数量" json:"pendingIncreaseLimitVideoCount"`
PendingBundleLimitVideoExpiredCount int `gorm:"column:pending_bundle_limit_video_expired_count;comment:待发套餐权益限制类型会过期视频数量" json:"pendingBundleLimitVideoExpiredCount"`
PendingIncreaseLimitVideoExpiredCount int `gorm:"column:pending_increase_limit_video_expired_count;comment:待发增值权益限制类型会过期视频数量" json:"pendingIncreaseLimitVideoExpiredCount"`
// ===== 待发图片类任务 =====
PendingBundleImageCount int `gorm:"column:pending_bundle_image_count;comment:待发非限制类型套餐权益图片数量" json:"pendingBundleImageCount"`
PendingIncreaseImageCount int `gorm:"column:pending_increase_image_count;comment:待发非限制类型增值权益图片数量" json:"pendingIncreaseImageCount"`
PendingBundleLimitImageCount int `gorm:"column:pending_bundle_limit_image_count;comment:待发套餐权益限制类型非过期图片数量" json:"pendingBundleLimitImageCount"`
PendingIncreaseLimitImageCount int `gorm:"column:pending_increase_limit_image_count;comment:待发增值权益限制类型非过期图片数量" json:"pendingIncreaseLimitImageCount"`
PendingBundleLimitImageExpiredCount int `gorm:"column:pending_bundle_limit_image_expired_count;comment:待发套餐权益限制类型会过期图片数量" json:"pendingBundleLimitImageExpiredCount"`
PendingIncreaseLimitImageExpiredCount int `gorm:"column:pending_increase_limit_image_expired_count;comment:待发增值权益限制类型会过期图片数量" json:"pendingIncreaseLimitImageExpiredCount"`
// ===== 待发数据分析类任务 =====
PendingBundleDataAnalysisCount int `gorm:"column:pending_bundle_data_analysis_count;comment:待发非限制类型套餐权益数据分析数量" json:"pendingBundleDataAnalysisCount"`
PendingIncreaseDataAnalysisCount int `gorm:"column:pending_increase_data_analysis_count;comment:待发非限制类型增值权益数据分析数量" json:"pendingIncreaseDataAnalysisCount"`
PendingBundleLimitDataAnalysisCount int `gorm:"column:pending_bundle_limit_data_analysis_count;comment:待发套餐权益限制类型非过期数据分析数量" json:"pendingBundleLimitDataAnalysisCount"`
PendingIncreaseLimitDataAnalysisCount int `gorm:"column:pending_increase_limit_data_analysis_count;comment:待发增值权益限制类型非过期数据分析数量" json:"pendingIncreaseLimitDataAnalysisCount"`
PendingBundleLimitDataAnalysisExpiredCount int `gorm:"column:pending_bundle_limit_data_analysis_expired_count;comment:待发套餐权益限制类型会过期数据分析数量" json:"pendingBundleLimitDataAnalysisExpiredCount"`
PendingIncreaseLimitDataAnalysisExpiredCount int `gorm:"column:pending_increase_limit_data_analysis_expired_count;comment:待发增值权益限制类型会过期数据分析数量" json:"pendingIncreaseLimitDataAnalysisExpiredCount"`
LastTaskAssignee string `gorm:"column:last_task_assignee;comment:最后一次的任务指派人" json:"lastTaskAssignee"` LastTaskAssignee string `gorm:"column:last_task_assignee;comment:最后一次的任务指派人" json:"lastTaskAssignee"`
TaskAssigneeNum string `gorm:"column:task_assignee_num;comment:任务指派人账号" json:"taskAssigneeNum"` TaskAssigneeNum string `gorm:"column:task_assignee_num;comment:任务指派人账号" json:"taskAssigneeNum"`
ProgressCount int `gorm:"column:progress_count;comment:进行中的任务数量" json:"progressCount"` ProgressCount int `gorm:"column:progress_count;comment:进行中的任务数量" json:"progressCount"`
@ -60,3 +82,131 @@ type TaskAssignRecords struct {
func (t *TaskAssignRecords) TableName() string { func (t *TaskAssignRecords) TableName() string {
return "task_assign_records" return "task_assign_records"
} }
// 任务余额表
type TaskBalance struct {
ID int64 `gorm:"primarykey"`
SubNum string `gorm:"column:sub_num;comment:用户编号;index:idx_task_sub_num;not null" json:"subNum"`
TelNum string `gorm:"column:tel_num;comment:手机号;index:idx_task_tel_num;not null" json:"telNum"`
Month string `gorm:"column:month;type:varchar(32);comment:月份;index:idx_task_month;not null" json:"month"`
ExpiredAt time.Time `gorm:"column:expired_at;type:datetime;comment:任务过期时间" json:"expiredAt"`
StartAt time.Time `gorm:"column:start_at;type:datetime;comment:任务开始时间" json:"startAt"`
// ===== 任务视频类 =====
TaskBundleVideoNumber int `gorm:"column:task_bundle_video_number;not null;comment:任务非限制类型套餐权益视频总数" json:"taskBundleVideoNumber"`
TaskIncreaseVideoNumber int `gorm:"column:task_increase_video_number;not null;comment:任务非限制类型增值权益视频总数" json:"taskIncreaseVideoNumber"`
TaskBundleLimitVideoNumber int `gorm:"column:task_bundle_limit_video_number;not null;comment:任务套餐权益限制类型非过期总数" json:"taskBundleLimitVideoNumber"`
TaskIncreaseLimitVideoNumber int `gorm:"column:task_increase_limit_video_number;not null;comment:任务增值权益限制类型非过期总数" json:"taskIncreaseLimitVideoNumber"`
TaskBundleLimitVideoExpiredNumber int `gorm:"column:task_bundle_limit_video_expired_number;not null;comment:任务套餐权益限制类型会过期总数" json:"taskBundleLimitVideoExpiredNumber"`
TaskIncreaseLimitVideoExpiredNumber int `gorm:"column:task_increase_limit_video_expired_number;not null;comment:任务增值权益限制类型会过期总数" json:"taskIncreaseLimitVideoExpiredNumber"`
TaskMonthlyInvalidBundleVideoNumber int `gorm:"column:task_monthly_invalid_bundle_video_number;not null;comment:任务当月失效的套餐权益视频总数" json:"taskMonthlyInvalidBundleVideoNumber"`
TaskInvalidBundleVideoNumber int `gorm:"column:task_invalid_bundle_video_number;not null;comment:任务历史失效的套餐权益视频总数" json:"taskInvalidBundleVideoNumber"`
TaskMonthlyInvalidIncreaseVideoNumber int `gorm:"column:task_monthly_invalid_increase_video_number;not null;comment:任务当月失效的增值权益视频总数" json:"taskMonthlyInvalidIncreaseVideoNumber"`
TaskInvalidIncreaseVideoNumber int `gorm:"column:task_invalid_increase_video_number;not null;comment:任务历史失效的增值权益视频总数" json:"taskInvalidIncreaseVideoNumber"`
TaskBundleVideoConsumptionNumber int `gorm:"column:task_bundle_video_consumption_number;not null;comment:任务非限制类型套餐权益视频使用数" json:"taskBundleVideoConsumptionNumber"`
TaskIncreaseVideoConsumptionNumber int `gorm:"column:task_increase_video_consumption_number;not null;comment:任务非限制类型增值权益视频使用数" json:"taskIncreaseVideoConsumptionNumber"`
TaskBundleLimitVideoConsumptionNumber int `gorm:"column:task_bundle_limit_video_consumption_number;not null;comment:任务套餐权益限制类型非过期使用数" json:"taskBundleLimitVideoConsumptionNumber"`
TaskIncreaseLimitVideoConsumptionNumber int `gorm:"column:task_increase_limit_video_consumption_number;not null;comment:任务增值权益限制类型非过期使用数" json:"taskIncreaseLimitVideoConsumptionNumber"`
TaskBundleLimitVideoExpiredConsumptionNumber int `gorm:"column:task_bundle_limit_video_expired_consumption_number;not null;comment:任务套餐权益限制类型会过期使用数" json:"taskBundleLimitVideoExpiredConsumptionNumber"`
TaskIncreaseLimitVideoExpiredConsumptionNumber int `gorm:"column:task_increase_limit_video_expired_consumption_number;not null;comment:任务增值权益限制类型会过期使用数" json:"taskIncreaseLimitVideoExpiredConsumptionNumber"`
TaskMonthlyLimitVideoNumber int `gorm:"column:task_monthly_limit_video_number;not null;comment:任务当月限制类型视频可用数" json:"taskMonthlyLimitVideoNumber"`
TaskMonthlyLimitVideoConsumptionNumber int `gorm:"column:task_monthly_limit_video_consumption_number;not null;comment:任务当月限制类型视频已使用额度" json:"taskMonthlyLimitVideoConsumptionNumber"`
TaskMonthlyLimitVideoExpireNumber int `gorm:"column:task_monthly_limit_video_expired_number;not null;comment:任务当月限制类型视频会过期可用数" json:"taskMonthlyLimitVideoExpireNumber"`
TaskMonthlyLimitVideoExpireConsumptionNumber int `gorm:"column:task_monthly_limit_video_expired_consumption_number;not null;comment:任务当月限制类型视频会过期已使用额度" json:"taskMonthlyLimitVideoExpireConsumptionNumber"`
TaskMonthlyBundleVideoConsumptionNumber int `gorm:"column:task_monthly_bundle_video_consumption_number;not null;comment:任务当月套餐类型总使用数" json:"taskMonthlyBundleVideoConsumptionNumber"`
TaskMonthlyIncreaseVideoConsumptionNumber int `gorm:"column:task_monthly_increase_video_consumption_number;not null;comment:任务当月增值类型总使用数" json:"taskMonthlyIncreaseVideoConsumptionNumber"`
TaskMonthlyLimitVideoQuotaNumber int `gorm:"column:task_monthly_limit_video_quota_number;not null;comment:任务当月限制类型视频额度" json:"taskMonthlyLimitVideoQuotaNumber"`
// ===== 任务图片类 =====
TaskBundleImageNumber int `gorm:"column:task_bundle_image_number;not null;comment:任务非限制类型套餐权益图片总数" json:"taskBundleImageNumber"`
TaskIncreaseImageNumber int `gorm:"column:task_increase_image_number;not null;comment:任务非限制类型增值权益图片总数" json:"taskIncreaseImageNumber"`
TaskBundleLimitImageNumber int `gorm:"column:task_bundle_limit_image_number;not null;comment:任务套餐权益限制类型非过期总数" json:"taskBundleLimitImageNumber"`
TaskIncreaseLimitImageNumber int `gorm:"column:task_increase_limit_image_number;not null;comment:任务增值权益限制类型非过期总数" json:"taskIncreaseLimitImageNumber"`
TaskBundleLimitImageExpiredNumber int `gorm:"column:task_bundle_limit_image_expired_number;not null;comment:任务套餐权益限制类型会过期总数" json:"taskBundleLimitImageExpiredNumber"`
TaskIncreaseLimitImageExpiredNumber int `gorm:"column:task_increase_limit_image_expired_number;not null;comment:任务增值权益限制类型会过期总数" json:"taskIncreaseLimitImageExpiredNumber"`
TaskMonthlyInvalidBundleImageNumber int `gorm:"column:task_monthly_invalid_bundle_image_number;not null;comment:任务当月失效的套餐权益图片总数" json:"taskMonthlyInvalidBundleImageNumber"`
TaskInvalidBundleImageNumber int `gorm:"column:task_invalid_bundle_image_number;not null;comment:任务历史失效的套餐权益图片总数" json:"taskInvalidBundleImageNumber"`
TaskMonthlyInvalidIncreaseImageNumber int `gorm:"column:task_monthly_invalid_increase_image_number;not null;comment:任务当月失效的增值权益图片总数" json:"taskMonthlyInvalidIncreaseImageNumber"`
TaskInvalidIncreaseImageNumber int `gorm:"column:task_invalid_increase_image_number;not null;comment:任务历史失效的增值权益图片总数" json:"taskInvalidIncreaseImageNumber"`
TaskBundleImageConsumptionNumber int `gorm:"column:task_bundle_image_consumption_number;not null;comment:任务非限制类型套餐权益图片使用数" json:"taskBundleImageConsumptionNumber"`
TaskIncreaseImageConsumptionNumber int `gorm:"column:task_increase_image_consumption_number;not null;comment:任务非限制类型增值权益图片使用数" json:"taskIncreaseImageConsumptionNumber"`
TaskBundleLimitImageConsumptionNumber int `gorm:"column:task_bundle_limit_image_consumption_number;not null;comment:任务套餐权益限制类型非过期使用数" json:"taskBundleLimitImageConsumptionNumber"`
TaskIncreaseLimitImageConsumptionNumber int `gorm:"column:task_increase_limit_image_consumption_number;not null;comment:任务增值权益限制类型非过期使用数" json:"taskIncreaseLimitImageConsumptionNumber"`
TaskBundleLimitImageExpiredConsumptionNumber int `gorm:"column:task_bundle_limit_image_expired_consumption_number;not null;comment:任务套餐权益限制类型会过期使用数" json:"taskBundleLimitImageExpiredConsumptionNumber"`
TaskIncreaseLimitImageExpiredConsumptionNumber int `gorm:"column:task_increase_limit_image_expired_consumption_number;not null;comment:任务增值权益限制类型会过期使用数" json:"taskIncreaseLimitImageExpiredConsumptionNumber"`
TaskMonthlyLimitImageNumber int `gorm:"column:task_monthly_limit_image_number;not null;comment:任务当月限制类型图片可使用额度" json:"taskMonthlyLimitImageNumber"`
TaskMonthlyLimitImageConsumptionNumber int `gorm:"column:task_monthly_limit_image_consumption_number;not null;comment:任务当月限制类型图片已使用额度" json:"taskMonthlyLimitImageConsumptionNumber"`
TaskMonthlyLimitImageExpireNumber int `gorm:"column:task_monthly_limit_image_expired_number;not null;comment:任务当月限制类型图片会过期可用数" json:"taskMonthlyLimitImageExpireNumber"`
TaskMonthlyLimitImageExpireConsumptionNumber int `gorm:"column:task_monthly_limit_image_expired_consumption_number;not null;comment:任务当月限制类型图片会过期已使用额度" json:"taskMonthlyLimitImageExpireConsumptionNumber"`
TaskMonthlyBundleImageConsumptionNumber int `gorm:"column:task_monthly_bundle_image_consumption_number;not null;comment:任务当月套餐类型总使用数" json:"taskMonthlyBundleImageConsumptionNumber"`
TaskMonthlyIncreaseImageConsumptionNumber int `gorm:"column:task_monthly_increase_image_consumption_number;not null;comment:任务当月增值类型总使用数" json:"taskMonthlyIncreaseImageConsumptionNumber"`
TaskMonthlyLimitImageQuotaNumber int `gorm:"column:task_monthly_limit_image_quota_number;not null;comment:任务当月限制类型图片额度" json:"taskMonthlyLimitImageQuotaNumber"`
// ===== 任务数据分析类 =====
TaskBundleDataAnalysisNumber int `gorm:"column:task_bundle_data_analysis_number;not null;comment:任务非限制类型套餐权益数据分析总数" json:"taskBundleDataAnalysisNumber"`
TaskIncreaseDataAnalysisNumber int `gorm:"column:task_increase_data_analysis_number;not null;comment:任务非限制类型增值权益数据分析总数" json:"taskIncreaseDataAnalysisNumber"`
TaskBundleLimitDataAnalysisNumber int `gorm:"column:task_bundle_limit_data_analysis_number;not null;comment:任务套餐权益限制类型非过期总数" json:"taskBundleLimitDataAnalysisNumber"`
TaskIncreaseLimitDataAnalysisNumber int `gorm:"column:task_increase_limit_data_analysis_number;not null;comment:任务增值权益限制类型非过期总数" json:"taskIncreaseLimitDataAnalysisNumber"`
TaskBundleLimitDataAnalysisExpiredNumber int `gorm:"column:task_bundle_limit_data_analysis_expired_number;not null;comment:任务套餐权益限制类型会过期总数" json:"taskBundleLimitDataAnalysisExpiredNumber"`
TaskIncreaseLimitDataAnalysisExpiredNumber int `gorm:"column:task_increase_limit_data_analysis_expired_number;not null;comment:任务增值权益限制类型会过期总数" json:"taskIncreaseLimitDataAnalysisExpiredNumber"`
TaskMonthlyInvalidBundleDataAnalysisNumber int `gorm:"column:task_monthly_invalid_bundle_data_analysis_number;not null;comment:任务当月失效的套餐权益数据分析总数" json:"taskMonthlyInvalidBundleDataAnalysisNumber"`
TaskInvalidBundleDataAnalysisNumber int `gorm:"column:task_invalid_bundle_data_analysis_number;not null;comment:任务历史失效的套餐权益数据分析总数" json:"taskInvalidBundleDataAnalysisNumber"`
TaskMonthlyInvalidIncreaseDataAnalysisNumber int `gorm:"column:task_monthly_invalid_increase_data_analysis_number;not null;comment:任务当月失效的增值权益数据分析总数" json:"taskMonthlyInvalidIncreaseDataAnalysisNumber"`
TaskInvalidIncreaseDataAnalysisNumber int `gorm:"column:task_invalid_increase_data_analysis_number;not null;comment:任务历史失效的增值权益数据分析总数" json:"taskInvalidIncreaseDataAnalysisNumber"`
TaskBundleDataAnalysisConsumptionNumber int `gorm:"column:task_bundle_data_analysis_consumption_number;not null;comment:任务非限制类型套餐权益数据分析使用数" json:"taskBundleDataAnalysisConsumptionNumber"`
TaskIncreaseDataAnalysisConsumptionNumber int `gorm:"column:task_increase_data_analysis_consumption_number;not null;comment:任务非限制类型增值权益数据分析使用数" json:"taskIncreaseDataAnalysisConsumptionNumber"`
TaskBundleLimitDataAnalysisConsumptionNumber int `gorm:"column:task_bundle_limit_data_analysis_consumption_number;not null;comment:任务套餐权益限制类型非过期使用数" json:"taskBundleLimitDataAnalysisConsumptionNumber"`
TaskIncreaseLimitDataAnalysisConsumptionNumber int `gorm:"column:task_increase_limit_data_analysis_consumption_number;not null;comment:任务增值权益限制类型非过期使用数" json:"taskIncreaseLimitDataAnalysisConsumptionNumber"`
TaskBundleLimitDataAnalysisExpiredConsumptionNumber int `gorm:"column:task_bundle_limit_data_analysis_expired_consumption_number;not null;comment:任务套餐权益限制类型会过期使用数" json:"taskBundleLimitDataAnalysisExpiredConsumptionNumber"`
TaskIncreaseLimitDataAnalysisExpiredConsumptionNumber int `gorm:"column:task_increase_limit_data_analysis_expired_consumption_number;not null;comment:任务增值权益限制类型会过期使用数" json:"taskIncreaseLimitDataAnalysisExpiredConsumptionNumber"`
TaskMonthlyLimitDataAnalysisNumber int `gorm:"column:task_monthly_limit_data_analysis_number;not null;comment:任务当月限制类型数据分析可使用额度" json:"taskMonthlyLimitDataAnalysisNumber"`
TaskMonthlyLimitDataAnalysisConsumptionNumber int `gorm:"column:task_monthly_limit_data_analysis_consumption_number;not null;comment:任务当月限制类型数据分析已使用额度" json:"taskMonthlyLimitDataAnalysisConsumptionNumber"`
TaskMonthlyLimitDataAnalysisExpireNumber int `gorm:"column:task_monthly_limit_data_analysis_expired_number;not null;comment:任务当月限制类型数据分析会过期可用数" json:"taskMonthlyLimitDataAnalysisExpireNumber"`
TaskMonthlyLimitDataAnalysisExpireConsumptionNumber int `gorm:"column:task_monthly_limit_data_analysis_expired_consumption_number;not null;comment:任务当月限制类型数据分析会过期已使用额度" json:"taskMonthlyLimitDataAnalysisExpireConsumptionNumber"`
TaskMonthlyBundleDataAnalysisConsumptionNumber int `gorm:"column:task_monthly_bundle_data_analysis_consumption_number;not null;comment:任务当月套餐类型总使用数" json:"taskMonthlyBundleDataAnalysisConsumptionNumber"`
TaskMonthlyIncreaseDataAnalysisConsumptionNumber int `gorm:"column:task_monthly_increase_data_analysis_consumption_number;not null;comment:任务当月增值类型总使用数" json:"taskMonthlyIncreaseDataAnalysisConsumptionNumber"`
TaskMonthlyLimitDataAnalysisQuotaNumber int `gorm:"column:task_monthly_limit_data_analysis_quota_number;not null;comment:任务当月限制类型数据分析额度" json:"taskMonthlyLimitDataAnalysisQuotaNumber"`
CreatedAt time.Time `gorm:"column:created_at;comment:创建时间" json:"createdAt"`
UpdatedAt time.Time `gorm:"column:updated_at;comment:更新时间" json:"updatedAt"`
DeletedAt soft_delete.DeletedAt `gorm:"column:deleted_at;type:int(11);index:idx_task_balance_deleted_at" json:"deletedAt"`
}
func (t *TaskBalance) TableName() string {
return "task_balance"
}
// 任务日志表
type TaskLog struct {
LogUUID string `gorm:"column:log_uuid;type:varchar(50)comment:任务日志UUID;uniqueIndex:idx_task_log_uuid;not null" json:"taskLogUUID"`
SubNum string `gorm:"column:sub_num;comment:任务用户编号;index:idx_task_log_sub_num;not null" json:"taskSubNum"`
TelNum string `gorm:"column:tel_num;comment:任务用户手机号;index:idx_task_log_tel_num;not null" json:"taskTelNum"`
ArtistName string `gorm:"column:artist_name;comment:任务艺人名称;index:idx_task_log_artist_name" json:"taskArtistName"`
// ===== 操作信息 =====
OperationType int `gorm:"column:operation_type;type:int(11);comment:任务操作类型 1:加任务 2:消耗任务 3:完成任务;4:任务过期;index:idx_task_operation_type;not null" json:"taskOperationType"`
TaskType int `gorm:"column:task_type;type:int(11);comment:任务类型 1:视频 2:图片 3:数据分析;index:idx_task_type;not null" json:"taskType"`
TaskCount int `gorm:"column:task_count;type:int(11);comment:任务数量;not null" json:"taskCount"`
Remark string `gorm:"column:remark;type:varchar(500);comment:任务备注" json:"taskRemark"`
// ===== 操作人信息 =====
OperatorName string `gorm:"column:operator_name;comment:任务操作人姓名;index:idx_task_operator_name" json:"taskOperatorName"`
OperatorNum string `gorm:"column:operator_num;comment:任务操作人账号;index:idx_task_operator_num" json:"taskOperatorNum"`
CompletorName string `gorm:"column:completor_name;comment:任务完成人姓名;index:idx_task_completor_name" json:"taskCompletorName"`
CompletorNum string `gorm:"column:completor_num;comment:任务完成人账号;index:idx_task_completor_num" json:"taskCompletorNum"`
// ===== 关联ID字段 =====
VideoPublishUUID string `gorm:"column:video_publish_id;type:varchar(50);comment:任务关联的发布视频UUID;index:idx_task_video_publish_id" json:"taskVideoPublishID"`
PostPublishUUID string `gorm:"column:post_publish_id;type:varchar(50);comment:任务关联的图文发布UUID;index:idx_task_post_publish_id" json:"taskPostPublishID"`
DataAnalysisUUID string `gorm:"column:data_analysis_id;type:varchar(50);comment:任务关联的数据分析UUID;index:idx_task_data_analysis_id" json:"taskDataAnalysisID"`
// ===== 时间字段 =====
OperationTime int `gorm:"column:operation_time;type:int(11);comment:任务操作时间;index:idx_task_operation_time;not null" json:"taskOperationTime"`
CreatedAt int `gorm:"column:created_at;type:int(11);comment:任务日志创建时间" json:"taskCreatedAt"`
UpdatedAt int `gorm:"column:updated_at;type:int(11);comment:任务日志更新时间" json:"taskUpdatedAt"`
DeletedAt soft_delete.DeletedAt `gorm:"column:deleted_at;type:int(11);index:idx_task_log_deleted_at" json:"taskDeletedAt"`
}
func (t *TaskLog) TableName() string {
return "task_log"
}

27
pb/bundle.proto
View File

@ -999,7 +999,7 @@ message TaskAssignRecordInfo {
int32 pendingVideoCount = 14 [json_name = "pendingVideoCount"]; // 待发视频数量 int32 pendingVideoCount = 14 [json_name = "pendingVideoCount"]; // 待发视频数量
int32 pendingPostCount = 15 [json_name = "pendingPostCount"]; // 待发图文数量 int32 pendingPostCount = 15 [json_name = "pendingPostCount"]; // 待发图文数量
int32 pendingDataCount = 16 [json_name = "pendingDataCount"]; // 待发数据数量 int32 pendingDataCount = 16 [json_name = "pendingDataCount"]; // 待发数据数量
string updatedAt = 24 [json_name = "updatedAt"]; // 更新时间 string updatedAt = 17 [json_name = "updatedAt"]; // 更新时间
} }
// 手动完成任务 // 手动完成任务
@ -1046,7 +1046,26 @@ message ArtistBundleBalanceRequest {
// 艺人套餐剩余数量响应 // 艺人套餐剩余数量响应
message ArtistBundleBalanceResponse { message ArtistBundleBalanceResponse {
int32 remainingVideoCount = 1 [json_name = "remainingVideoCount"]; // 剩余视频数量 // 以下返回值同时包含“套餐类型”和“增值类型”两类的任务余额与待发数量
int32 remainingImageCount = 2 [json_name = "remainingImageCount"]; // 剩余图片数量 // 余额来自任务余额表（task_balance），待发数量来自任务管理表（task_management），均按视频/图文/数据分析三类区分
int32 remainingDataAnalysisCount = 3 [json_name = "remainingDataAnalysisCount"]; // 剩余数据分析数量
// 套餐类型 - 任务余额（视频/图文/数据分析）
int32 bundleVideoBalance = 1 [json_name = "bundleVideoBalance"]; // 套餐类型视频余额
int32 bundleImageBalance = 2 [json_name = "bundleImageBalance"]; // 套餐类型图文余额
int32 bundleDataAnalysisBalance = 3 [json_name = "bundleDataAnalysisBalance"]; // 套餐类型数据分析余额
// 增值类型 - 任务余额（视频/图文/数据分析）
int32 increaseVideoBalance = 4 [json_name = "increaseVideoBalance"]; // 增值类型视频余额
int32 increaseImageBalance = 5 [json_name = "increaseImageBalance"]; // 增值类型图文余额
int32 increaseDataAnalysisBalance = 6 [json_name = "increaseDataAnalysisBalance"]; // 增值类型数据分析余额
// 套餐类型 - 待发数量（视频/图文/数据分析）
int32 bundlePendingVideoCount = 7 [json_name = "bundlePendingVideoCount"]; // 套餐类型待发视频数量
int32 bundlePendingImageCount = 8 [json_name = "bundlePendingImageCount"]; // 套餐类型待发图文数量
int32 bundlePendingDataAnalysisCount = 9 [json_name = "bundlePendingDataAnalysisCount"]; // 套餐类型待发数据分析数量
// 增值类型 - 待发数量（视频/图文/数据分析）
int32 increasePendingVideoCount = 10 [json_name = "increasePendingVideoCount"]; // 增值类型待发视频数量
int32 increasePendingImageCount = 11 [json_name = "increasePendingImageCount"]; // 增值类型待发图文数量
int32 increasePendingDataAnalysisCount = 12 [json_name = "increasePendingDataAnalysisCount"]; // 增值类型待发数据分析数量
} }

2237
pb/bundle/bundle.pb.go
View File

File diff suppressed because it is too large Load Diff

2
pb/bundle/bundle_triple.pb.go
View File

@ -1,7 +1,7 @@
// Code generated by protoc-gen-go-triple. DO NOT EDIT. // Code generated by protoc-gen-go-triple. DO NOT EDIT.
// versions: // versions:
// - protoc-gen-go-triple v1.0.8 // - protoc-gen-go-triple v1.0.8
// - protoc v3.12.4 // - protoc v3.21.1
// source: pb/bundle.proto // source: pb/bundle.proto
package bundle package bundle