feat: 更新pb

This reverts commit ae78bf8e0b.

pkg/cron/task.go

@@ -20,6 +20,9 @@ func InitTasks() error {
 	cm := GetCronManager()
 	err := cm.AddTask("refreshWorkApprovalStatus", "0 */1 * * * *", RefreshWorkApprovalStatusTask)
 	err = cm.AddTask("artistAutoConfirm", "0 */1 * * * *", ArtistAutoConfirmTask)
+
+	err = cm.AddTask("artistAutoConfirmAnalysis", "0 */1 * * * *", ArtistAutoConfirmAnalysisTask)
+	err = cm.AddTask("refreshWorkAnalysisApprovalStatus", "0 */1 * * * *", RefreshWorkAnalysisApprovalStatusTask)
 	if err != nil {
 		log.Printf("添加测试任务失败: %v", err)
 	}
@@ -43,6 +46,22 @@ func RefreshWorkApprovalStatusTask() {
 	serverCast.RefreshWorkApproval(nil, resp.Data)
 }
 
+func RefreshWorkAnalysisApprovalStatusTask() {
+	resp, err := service.CastProvider.ListWorkAnalysis(context.Background(), &cast.ListWorkAnalysisReq{
+		Page:       1,
+		StatusList: []uint32{2}, // 状态为2表示待审批
+		PageSize:   999999,
+	})
+	if err != nil {
+		log.Printf("获取数据分析列表失败: %v", err)
+		return
+	}
+	if resp.Data == nil || len(resp.Data) == 0 {
+		return
+	}
+	serverCast.RefreshWorkAnalysisApproval(nil, resp.Data)
+}
+
 func ArtistAutoConfirmTask() {
 	now := float64(time.Now().Unix())
 	opt := redis.ZRangeBy{
@@ -63,3 +82,24 @@ func ArtistAutoConfirmTask() {
 		serverCast.ProcessTask(context.Background(), workUuid)
 	}
 }
+
+func ArtistAutoConfirmAnalysisTask() {
+	now := float64(time.Now().Unix())
+	opt := redis.ZRangeBy{
+		Min: fmt.Sprintf("%d", 0),
+		Max: fmt.Sprintf("%f", now),
+	}
+	analysisUuids, err := cache.RedisClient.ZRangeByScore(modelCast.AutoConfirmAnalysisQueueKey, opt).Result()
+	if err != nil {
+		zap.L().Error("获取到期数据分析任务失败", zap.Error(err))
+		return
+	}
+	if len(analysisUuids) == 0 {
+		zap.L().Debug("没有到期的数据分析任务")
+		return
+	}
+	zap.L().Info("发现到期数据分析任务", zap.Int("count", len(analysisUuids)))
+	for _, analysisUuid := range analysisUuids {
+		serverCast.ProcessAnalysisTask(context.Background(), analysisUuid)
+	}
+}

pkg/model/bundle/bundle.go

@@ -6,6 +6,12 @@ type UserWorkConfirmReq struct {
 	ConfirmStatus int    `json:"confirmStatus"` // 1确认 2 驳回
 }
 
+type UserWorkAnalysisConfirmReq struct {
+	Uuid          string `json:"uuid"`          // 分析UUID
+	ConfirmRemark string `json:"confirmRemark"` // 确认备注
+	ConfirmStatus int    `json:"confirmStatus"` // 1确认 2 驳回
+}
+
 type GetBundleBalanceListResp struct {
 
 	Total int64                `protobuf:"varint,1,opt,name=total,proto3" json:"total"`

pkg/model/cast/media.go

@@ -7,4 +7,5 @@ const (
 	BalanceTypeAccountValue BalanceTypeEnum = 1
 	BalanceTypeImageValue   BalanceTypeEnum = 2
 	BalanceTypeVideoValue   BalanceTypeEnum = 3
+	BalanceTypeDataValue    BalanceTypeEnum = 4
 )

pkg/model/cast/work.go

@@ -13,6 +13,9 @@ const (
 const (
 	AutoConfirmQueueKey = "auto_confirm:queue"
 	AutoConfirmLockKey  = "auto_confirm:lock:%s"
+
+	AutoConfirmAnalysisQueueKey = "auto_confirm:analysis:queue"
+	AutoConfirmAnalysisLockKey  = "auto_confirm:analysis:lock:%s"
 )
 
 var WorkCategoryMM = map[int]string{

pkg/router/analysis.go

@@ -0,0 +1,46 @@
+package router
+
+import (
+	"fonchain-fiee/pkg/middleware"
+	"fonchain-fiee/pkg/service"
+	"fonchain-fiee/pkg/service/bundle"
+	serviceCast "fonchain-fiee/pkg/service/cast"
+
+	"github.com/gin-gonic/gin"
+)
+
+func AnalysisRouter(r *gin.RouterGroup) {
+	analysis := r.Group("analysis")
+	analysis.Use(middleware.CheckWebLogin(service.AccountProvider))
+	{
+		analysis.POST("create", serviceCast.CreateWorkAnalysis)
+		analysis.POST("update", serviceCast.UpdateWorkAnalysis)
+		analysis.POST("update-status", serviceCast.UpdateWorkAnalysisStatus)
+		analysis.POST("detail", serviceCast.GetWorkAnalysis)
+		analysis.POST("latest", serviceCast.GetLatestWorkAnalysis)
+		analysis.POST("list", serviceCast.ListWorkAnalysis)
+		analysis.POST("delete", serviceCast.DeleteWorkAnalysis)
+		analysis.POST("export-list", serviceCast.ListWorkAnalysisExport)              // 数据分析分析列表导出
+		analysis.POST("export-single-list", serviceCast.ListWorkAnalysisSingleExport) // 数据分析分析单个列表导出
+		analysis.POST("artist-data-list", serviceCast.ArtistDataList)                 // 艺人数据列表
+		analysis.POST("media-data-list", serviceCast.MediaDataList)                   // 自媒体数据列表
+		analysis.POST("data-overview", serviceCast.DataOverview)                      // 数据概览
+		analysis.POST("artist-metrics", serviceCast.ArtistMetricsSeries)              // 艺人指标系列
+		analysis.POST("artist-metrics-single", serviceCast.ArtistMetricsDailyWindow)  // 艺人指标日窗口
+		analysis.POST("tobe-confirmed-list", serviceCast.TobeConfirmedList)           // 待确认数据列表
+		analysis.POST("update-approval-id", serviceCast.UpdateWorkAnalysisApprovalID) // 更新作品分析审批ID
+
+	}
+
+	// 员工任务相关路由（需要App登录验证
+	analysisAppRoute := r.Group("app/analysis")
+	analysisAppRoute.Use(middleware.CheckLogin(service.AccountFieeProvider))
+	{
+		analysisAppRoute.POST("list", serviceCast.ListWorkAnalysis)                  // 作品列表
+		analysisAppRoute.POST("detail", serviceCast.GetWorkAnalysis)                 // 作品分析详情
+		analysisAppRoute.POST("update-status", serviceCast.UpdateWorkAnalysisStatus) // 用户确认
+		analysisAppRoute.POST("check-balance", serviceCast.CheckBundleBalance)       // 检查套餐余量
+		analysisAppRoute.POST("tobe-confirmed-list", serviceCast.TobeConfirmedList)  // 待确认数据列表
+		analysisAppRoute.POST("work-analysis-confirm", bundle.WorkAnalysisConfirm)
+	}
+}

pkg/router/router.go

@@ -53,6 +53,7 @@ func NewRouter() *gin.Engine {
 	ValueAddBundleRouter(privateGroup)
 	TaskBenchRouter(privateGroup) // 新增任务台路由
 	MediaRouter(privateGroup)
+	AnalysisRouter(privateGroup)
 	SecFilingRouter(privateGroup)
 	app.MediaAppRouter(privateGroup)
 	{

pkg/service/bundle/bundleBalance.go

@@ -245,6 +245,86 @@ func WorkConfirm(c *gin.Context) { // 确认作品并扣除余量
 	service.Success(c, res)
 }
 
+func WorkAnalysisConfirm(c *gin.Context) { // 确认数据分析并扣除余量
+	var req bundleModel.UserWorkAnalysisConfirmReq
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		service.Error(c, err)
+		return
+	}
+
+	if req.ConfirmStatus == 2 { // 驳回完直接结束
+		res, err := service.CastProvider.UpdateWorkAnalysisStatus(c, &cast.UpdateWorkAnalysisStatusReq{
+			WorkAction:    cast.WorkActionENUM_CONFIRM,
+			Uuid:          req.Uuid,
+			ConfirmRemark: req.ConfirmRemark,
+			ConfirmStatus: 2,
+		})
+		if err != nil {
+			service.Error(c, errors.New(common.UpdateWorkStatusFailed))
+			return
+		}
+		service.Success(c, res)
+		return
+	}
+	userInfo := login.GetUserInfoFromC(c)
+	balanceInfoRes, err := service.BundleProvider.GetBundleBalanceByUserId(context.Background(), &bundle.GetBundleBalanceByUserIdReq{
+		UserId: int32(userInfo.ID),
+	})
+	if err != nil {
+		service.Error(c, errors.New(common.GetUserBalanceFailed))
+		return
+	}
+
+	analysisInfoRes, err := service.CastProvider.GetWorkAnalysis(c, &cast.GetWorkAnalysisDetailReq{
+		Uuid: req.Uuid,
+	})
+	if err != nil {
+		service.Error(c, errors.New(common.GetWorkDetailFailed))
+		return
+	}
+	if analysisInfoRes.WorkAnalysisStatus != 4 {
+		service.Error(c, errors.New("数据分析不是待确认状态"))
+		return
+	}
+
+	var addBalanceReq bundle.AddBundleBalanceReq
+	addBalanceReq.UserId = int32(userInfo.ID)
+	// 检查数据分析余量
+	if balanceInfoRes.DataAnalysisConsumptionNumber >= balanceInfoRes.DataAnalysisNumber {
+		service.Error(c, errors.New("数据分析余量不足"))
+		return
+	}
+	addBalanceReq.DataAnalysisConsumptionNumber = 1
+
+	resp, err := service.BundleProvider.AddBundleBalance(c, &addBalanceReq)
+	if err != nil {
+		service.Error(c, errors.New(common.AddBundleBalanceFailed))
+		return
+	}
+	res, err := service.CastProvider.UpdateWorkAnalysisStatus(c, &cast.UpdateWorkAnalysisStatusReq{
+		WorkAction:    cast.WorkActionENUM_CONFIRM,
+		Uuid:          req.Uuid,
+		ConfirmRemark: req.ConfirmRemark,
+		CostType:      resp.UsedType,
+		ConfirmStatus: 1,
+	})
+	if err != nil {
+		service.Error(c, errors.New(common.UpdateWorkStatusFailed))
+		return
+	}
+	// 如果是艺人手动确认，确认操作后，自动标记为待阅读状态
+	_, err = service.CastProvider.UpdateWorkAnalysisStatus(c, &cast.UpdateWorkAnalysisStatusReq{
+		WorkAction: cast.WorkActionENUM_READ,
+		Uuid:       req.Uuid,
+	})
+	if err != nil {
+		service.Error(c, errors.New(common.UpdateWorkStatusFailed))
+		return
+	}
+	service.Success(c, res)
+}
+
 func CastLogConfirm(ctx *gin.Context) {
 	var req bundle.ConfirmWorkReq
 	if err := ctx.ShouldBindJSON(&req); err != nil {

pkg/service/cast/analysis.go

@@ -0,0 +1,639 @@
+package cast
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"fonchain-fiee/api/bundle"
+	"fonchain-fiee/api/cast"
+	"fonchain-fiee/pkg/cache"
+	"fonchain-fiee/pkg/e"
+	modelCast "fonchain-fiee/pkg/model/cast"
+	"fonchain-fiee/pkg/model/login"
+	"fonchain-fiee/pkg/service"
+	"fonchain-fiee/pkg/utils"
+	"strconv"
+	"time"
+
+	"dubbo.apache.org/dubbo-go/v3/common/constant"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// CreateWorkAnalysis 创建作品分析
+func CreateWorkAnalysis(ctx *gin.Context) {
+	var req *cast.CreateWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	artistID, _ := strconv.ParseUint(req.ArtistID, 10, 64)
+	if err = CheckUserBundleBalance(int32(artistID), modelCast.BalanceTypeDataValue); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	resp, err := service.CastProvider.CreateWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// UpdateWorkAnalysis 更新作品分析
+func UpdateWorkAnalysis(ctx *gin.Context) {
+	var req *cast.UpdateWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	_, err = service.CastProvider.UpdateWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, nil)
+	return
+}
+
+// UpdateWorkAnalysisStatus 更新作品分析状态
+func UpdateWorkAnalysisStatus(ctx *gin.Context) {
+	var req *cast.UpdateWorkAnalysisStatusReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	_, err = service.CastProvider.UpdateWorkAnalysisStatus(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, nil)
+	return
+}
+
+// GetWorkAnalysis 获取作品分析详情
+func GetWorkAnalysis(ctx *gin.Context) {
+	var req *cast.GetWorkAnalysisDetailReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.GetWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// GetLatestWorkAnalysis 获取最新作品分析
+func GetLatestWorkAnalysis(ctx *gin.Context) {
+	var req *cast.GetLatestWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.GetLatestWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// ListWorkAnalysis 获取作品分析列表
+func ListWorkAnalysis(ctx *gin.Context) {
+	var req *cast.ListWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ListWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	RefreshWorkAnalysisApproval(ctx, resp.Data)
+	service.Success(ctx, resp)
+	return
+}
+
+// RefreshWorkAnalysisApproval 刷新作品分析审批状态
+func RefreshWorkAnalysisApproval(ctx *gin.Context, data []*cast.WorkAnalysisInfo) {
+	if len(data) > 0 {
+		var analysisUuidApprovalIDMap = make(map[int]string)
+		for _, v := range data {
+			// 状态为2表示待审批，需要获取详情来获取ApprovalID
+			if v.WorkAnalysisStatus == 2 && v.ApprovalID != "" {
+				zap.L().Info("RefreshWorkAnalysisApproval", zap.Any("approvalID", v.ApprovalID))
+				approvalID, _ := strconv.ParseUint(v.ApprovalID, 10, 64)
+				analysisUuidApprovalIDMap[int(approvalID)] = v.Uuid
+			}
+		}
+		if len(analysisUuidApprovalIDMap) > 0 {
+			_ = RefreshWorkAnalysisApprovalStatus(ctx, analysisUuidApprovalIDMap)
+		}
+	}
+}
+
+// RefreshWorkAnalysisApprovalStatus 刷新作品分析审批状态详情
+func RefreshWorkAnalysisApprovalStatus(ctx *gin.Context, approvalIDAnalysisUuidMap map[int]string) (err error) {
+	var castS = new(CastService)
+	var data = make(map[int]modelCast.Item)
+	var approvalIDs []int
+	for approvalId := range approvalIDAnalysisUuidMap {
+		approvalIDs = append(approvalIDs, approvalId)
+	}
+	if len(approvalIDs) == 0 {
+		return
+	}
+	data, err = castS.ApprovalDetail(approvalIDs)
+	if err != nil {
+		return
+	}
+	// status: 1待审批 2审批通过 3审批不通过 6撤销发其中 7撤销完成
+	var newData = make(map[int]modelCast.Item, len(approvalIDs))
+	for _, v := range approvalIDs {
+		newData[v] = data[v]
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	if len(newData) > 0 {
+		for approvalId, v := range newData {
+			if v.ID == 0 {
+				_, _ = service.CastProvider.UpdateWorkAnalysisStatus(newCtx, &cast.UpdateWorkAnalysisStatusReq{
+					WorkAction:    cast.WorkActionENUM_APPROVAL_DELETE,
+					Uuid:          approvalIDAnalysisUuidMap[approvalId],
+					ApprovalID:    fmt.Sprint(approvalId),
+					ApprovalReply: "",
+				})
+				continue
+			}
+			var workAction cast.WorkActionENUM
+			if v.Status == 2 {
+				workAction = cast.WorkActionENUM_APPROVAL_PASS
+			} else if v.Status == 3 {
+				workAction = cast.WorkActionENUM_APPROVAL_REJECT
+			} else {
+				continue
+			}
+			_, _ = service.CastProvider.UpdateWorkAnalysisStatus(newCtx, &cast.UpdateWorkAnalysisStatusReq{
+				WorkAction:    workAction,
+				Uuid:          approvalIDAnalysisUuidMap[approvalId],
+				ApprovalID:    fmt.Sprint(approvalId),
+				ApprovalReply: v.Reply,
+			})
+		}
+	}
+	return
+}
+
+// DeleteWorkAnalysis 删除作品分析
+func DeleteWorkAnalysis(ctx *gin.Context) {
+	var req *cast.DeleteWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+
+	newCtx := NewCtxWithUserInfo(ctx)
+	_, err = service.CastProvider.DeleteWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, nil)
+	return
+}
+
+// getWorkAnalysisStatusText 获取作品分析状态文本
+func getWorkAnalysisStatusText(status uint32) string {
+	switch status {
+	case 1:
+		return "待提交"
+	case 2:
+		return "审批中"
+	case 3:
+		return "审批驳回"
+	case 4:
+		return "待艺人验收"
+	case 5:
+		return "验收失败"
+	case 6:
+		return "待阅读"
+	case 7:
+		return "已阅读"
+	default:
+		return ""
+	}
+}
+
+// getComfirmTypeText 获取确认类型文本
+func getComfirmTypeText(comfirmType int32) string {
+	switch comfirmType {
+	case 1:
+		return "艺人确认"
+	case 2:
+		return "系统确认"
+	default:
+		return ""
+	}
+}
+
+// ListWorkAnalysisExport 获取作品分析列表并导出Excel
+func ListWorkAnalysisExport(ctx *gin.Context) {
+	var req *cast.ListWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	req.Page = 1
+	req.PageSize = 999999999
+
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ListWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+
+	titleList := []string{
+		"艺人", "用户编号", "手机号", "状态", "验收确认类型", "原因", "状态变更时间", "提交时间", "操作人", "pdf链接",
+	}
+
+	var dataList []interface{}
+	for _, i := range resp.Data {
+		data := []any{
+			i.ArtistName,
+			i.SubNum,
+			i.ArtistPhone,
+			getWorkAnalysisStatusText(i.WorkAnalysisStatus),
+			getComfirmTypeText(i.ComfirmType),
+			i.Reason,
+			i.StatusUpdateTime,
+			i.SubmitTime,
+			i.OperatorName,
+			i.PdfUrl,
+		}
+		dataList = append(dataList, &data)
+	}
+
+	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	utils.ResponseXls(ctx, content, "数据分析列表")
+	return
+}
+
+// ListWorkAnalysisSingleExport 获取作品分析列表并导出Excel
+func ListWorkAnalysisSingleExport(ctx *gin.Context) {
+	var req *cast.ListWorkAnalysisReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	req.Page = 1
+	req.PageSize = 999999999
+
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ListWorkAnalysis(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+
+	titleList := []string{
+		"状态", "验收确认类型", "原因", "状态变更时间", "操作人", "提交时间", "pdf链接",
+	}
+
+	var dataList []interface{}
+	for _, i := range resp.Data {
+		data := []any{
+			getWorkAnalysisStatusText(i.WorkAnalysisStatus),
+			getComfirmTypeText(i.ComfirmType),
+			i.Reason,
+			i.StatusUpdateTime,
+			i.OperatorName,
+			i.SubmitTime,
+			i.PdfUrl,
+		}
+		dataList = append(dataList, &data)
+	}
+
+	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	utils.ResponseXls(ctx, content, "数据分析列表")
+	return
+}
+
+// ArtistDataList 艺人数据列表
+func ArtistDataList(ctx *gin.Context) {
+	var req *cast.ArtistDataListReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ArtistDataList(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// MediaDataList 自媒体数据列表
+func MediaDataList(ctx *gin.Context) {
+	var req *cast.MediaDataListReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.MediaDataList(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// DataOverview 数据概览
+func DataOverview(ctx *gin.Context) {
+	var req *cast.DataOverviewReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.DataOverview(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// ArtistMetricsSeries 艺人指标系列
+func ArtistMetricsSeries(ctx *gin.Context) {
+	var req *cast.ArtistMetricsSeriesReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ArtistMetricsSeries(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// ArtistMetricsDailyWindow 艺人指标日窗口
+func ArtistMetricsDailyWindow(ctx *gin.Context) {
+	var req *cast.ArtistMetricsDailyWindowReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.ArtistMetricsDailyWindow(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// TobeConfirmedList 待确认数据列表
+func TobeConfirmedList(ctx *gin.Context) {
+	var req *cast.TobeConfirmedListReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	userInfo := login.GetUserInfoFromC(ctx)
+	req.ArtistUuid = strconv.Itoa(int(userInfo.ID))
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.CastProvider.TobeConfirmedList(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, resp)
+	return
+}
+
+// UpdateWorkAnalysisApprovalID 更新作品分析审批ID
+func UpdateWorkAnalysisApprovalID(ctx *gin.Context) {
+	var req *cast.UpdateWorkAnalysisApprovalIDReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	newCtx := NewCtxWithUserInfo(ctx)
+	_, err = service.CastProvider.UpdateWorkAnalysisApprovalID(newCtx, req)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	service.Success(ctx, nil)
+	return
+}
+
+type CheckBundleBalanceReq struct {
+	ArtistID    string                    `protobuf:"bytes,4,opt,name=artistID,proto3" json:"artistID"` // 艺人ID
+	BalanceType modelCast.BalanceTypeEnum `json:"balanceType"`                                          // 套餐类型
+}
+
+// CheckBundleBalance 检查套餐余量
+func CheckBundleBalance(ctx *gin.Context) {
+	var req *CheckBundleBalanceReq
+	var err error
+	if err = ctx.ShouldBind(&req); err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	artistID, err := strconv.ParseUint(req.ArtistID, 10, 64)
+	if err != nil {
+		service.Error(ctx, err)
+		return
+	}
+	zap.L().Info("CheckUserBundleBalance", zap.Any("userID", artistID), zap.Any("balanceType", req.BalanceType))
+	newCtx := NewCtxWithUserInfo(ctx)
+	resp, err := service.BundleProvider.GetBundleBalanceByUserId(newCtx, &bundle.GetBundleBalanceByUserIdReq{UserId: int32(artistID)})
+	if err != nil {
+		zap.L().Error("CheckUserBundleBalance", zap.Any("err", err))
+		service.Error(ctx, err)
+		return
+	}
+	zap.L().Info("CheckUserBundleBalance", zap.Any("resp", resp))
+	switch req.BalanceType {
+	case modelCast.BalanceTypeAccountValue:
+		if resp.AccountNumber-resp.AccountConsumptionNumber <= 0 {
+			err = errors.New(e.ErrorBalanceInsufficient)
+			service.Error(ctx, err)
+			return
+		}
+	case modelCast.BalanceTypeImageValue:
+		if resp.ImageNumber-resp.ImageConsumptionNumber <= 0 {
+			err = errors.New(e.ErrorBalanceInsufficient)
+			service.Error(ctx, err)
+			return
+		}
+	case modelCast.BalanceTypeVideoValue:
+		if resp.VideoNumber-resp.VideoConsumptionNumber <= 0 {
+			err = errors.New(e.ErrorBalanceInsufficient)
+			service.Error(ctx, err)
+			return
+		}
+	case modelCast.BalanceTypeDataValue:
+		if resp.DataAnalysisNumber-resp.DataAnalysisConsumptionNumber <= 0 {
+			err = errors.New(e.ErrorBalanceInsufficient)
+			service.Error(ctx, err)
+			return
+		}
+	}
+
+	service.Success(ctx, resp)
+	return
+}
+
+// ProcessAnalysisTask 处理数据分析自动确认任务
+func ProcessAnalysisTask(ctx context.Context, analysisUuid string) {
+	lockKey := fmt.Sprintf(modelCast.AutoConfirmAnalysisLockKey, analysisUuid)
+	reply := cache.RedisClient.SetNX(lockKey, "1", 5*time.Minute)
+	if !reply.Val() {
+		zap.L().Warn("数据分析任务正在被其他实例处理", zap.String("analysisUuid", analysisUuid))
+		return
+	}
+	defer func() {
+		cache.RedisClient.Del(lockKey)
+	}()
+	err := autoConfirmAnalysis(ctx, analysisUuid)
+	if err != nil {
+		zap.L().Error("数据分析自动确认失败",
+			zap.String("analysisUuid", analysisUuid),
+			zap.Error(err))
+		return
+	}
+	// 从队列中移除
+	args := make([]interface{}, len(analysisUuid))
+	for i, m := range analysisUuid {
+		args[i] = m
+	}
+	err = cache.RedisClient.ZRem(modelCast.AutoConfirmAnalysisQueueKey, args...).Err()
+	if err != nil {
+		zap.L().Error("从队列移除数据分析任务失败",
+			zap.String("analysisUuid", analysisUuid),
+			zap.Error(err))
+	}
+	zap.L().Info("数据分析自动确认成功", zap.String("analysisUuid", analysisUuid))
+}
+
+// autoConfirmAnalysis 自动确认数据分析
+func autoConfirmAnalysis(ctx context.Context, analysisUuid string) (err error) {
+	var confirmRemark string
+	var isFailed bool
+	var usedType uint32
+	infoResp, err := service.CastProvider.GetWorkAnalysis(context.Background(), &cast.GetWorkAnalysisDetailReq{
+		Uuid: analysisUuid,
+	})
+	if err != nil {
+		zap.L().Error("autoConfirmAnalysis GetWorkAnalysis", zap.Any("err", err))
+		return
+	}
+
+	if infoResp.WorkAnalysisStatus != 4 { // 4是待确认状态，需要根据实际情况调整
+		return
+	}
+	userID, _ := strconv.ParseInt(infoResp.ArtistID, 10, 64)
+	balanceInfoRes, err := service.BundleProvider.GetBundleBalanceByUserId(context.Background(), &bundle.GetBundleBalanceByUserIdReq{
+		UserId: int32(userID),
+	})
+	if err != nil {
+		zap.L().Error("autoConfirmAnalysis GetBundleBalanceByUserId", zap.Any("err", err))
+		confirmRemark = "获取余额失败:" + err.Error()
+		isFailed = true
+	}
+
+	var addBalanceReq bundle.AddBundleBalanceReq
+	addBalanceReq.UserId = int32(userID)
+	// 检查数据分析余量
+	if balanceInfoRes.DataAnalysisConsumptionNumber >= balanceInfoRes.DataAnalysisNumber {
+		confirmRemark = "数据分析余量不足"
+		isFailed = true
+	}
+	addBalanceReq.DataAnalysisConsumptionNumber = 1
+
+	zap.L().Info("autoConfirmAnalysis AddBundleBalanceReq", zap.Any("addBalanceReq", &addBalanceReq))
+	resp, err := service.BundleProvider.AddBundleBalance(context.Background(), &addBalanceReq)
+	if err != nil {
+		zap.L().Error("autoConfirmAnalysis AddBundleBalance", zap.Any("err", err))
+		confirmRemark = "扣除失败:" + err.Error()
+		isFailed = true
+	}
+	zap.L().Info("autoConfirmAnalysis AddBundleBalanceResp", zap.Any("resp", resp))
+	var confirmStatus uint32 = 1
+	if isFailed {
+		usedType = 0
+		confirmStatus = 3
+	} else {
+		usedType = resp.UsedType
+		confirmRemark = "系统自动确认"
+		confirmStatus = 1
+	}
+	var mm = make(map[string]interface{}, 3)
+	mm["userid"] = 0
+	mm["name"] = "系统自动确定"
+	mm["phone"] = ""
+	newCtx := context.WithValue(context.Background(), constant.DubboCtxKey("attachment"), mm)
+	_, err = service.CastProvider.UpdateWorkAnalysisStatus(newCtx, &cast.UpdateWorkAnalysisStatusReq{
+		WorkAction:    cast.WorkActionENUM_CONFIRM,
+		Uuid:          analysisUuid,
+		ConfirmRemark: confirmRemark,
+		CostType:      usedType,
+		ConfirmStatus: confirmStatus,
+	})
+	if err != nil {
+		return
+	}
+	return
+}

pkg/service/cast/work.go

@@ -261,6 +261,11 @@ func CheckUserBundleBalance(userID int32, balanceType modelCast.BalanceTypeEnum)
 			err = errors.New(e.ErrorBalanceInsufficient)
 			return
 		}
+	case modelCast.BalanceTypeDataValue:
+		if resp.DataAnalysisNumber-resp.DataAnalysisConsumptionNumber <= 0 {
+			err = errors.New(e.ErrorBalanceInsufficient)
+			return
+		}
 	}
 	return
 }