youngee_b_api/db/project_task.go

package db

import (
	"context"
	"errors"
	"fmt"
	"github.com/issue9/conv"
	"gorm.io/gorm"
	"strconv"
	"strings"
	"time"
	"youngee_b_api/model/gorm_model"
	"youngee_b_api/model/http_model"
)

func GetProjecttaskList(ctx context.Context, request http_model.GetTaskListRequest) (*http_model.GetTaskListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_status = ?", request.ProjectId, request.CoopType)

	// 构建查询条件
	if request.FeeFrom != nil {
		query = query.Where("fee_form = ?", request.FeeFrom)
	}
	if request.Type != nil {
		switch *request.Type {
		case 1:
			query = query.Where("supplier_id = 0 AND supplier_status = 0")
		case 2:
			query = query.Where("supplier_id !=0 AND supplier_status = 2")
		}
	}

	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize

	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}

	taskInfoPointers := make([]*http_model.TaskInfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		var Time time.Time
		switch request.CoopType {
		case 1:
			Time = task.CreateDate
		case 2:
			Time = task.SelectDate //2 signedtime
		case 3:
			Time = task.CompleteDate
		}
		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterPriseId)
		response := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			Boperator:          boperator,
			CreateAt:           Time,
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			Sprojectid:         task.SprojectId,
			City:               task.City,
		}
		taskInfoPointers = append(taskInfoPointers, response)
	}

	return &http_model.GetTaskListData{
		TaskList: taskInfoPointers,
		Total:    conv.MustString(total, ""),
	}, nil
}

func getBOperator(db *gorm.DB, bOperatorID string, bOperatorType int) string {
	if bOperatorID == "" {
		return ""
	}
	if bOperatorType == 1 {
		var boperatorinfo gorm_model.Enterprise
		if err := db.Where(gorm_model.Enterprise{EnterpriseID: bOperatorID}).First(&boperatorinfo).Error; err != nil {
			return ""
		}
		return boperatorinfo.BusinessName
	}
	if bOperatorType == 2 {
		var bsubaccount gorm_model.YounggeeSubAccount
		if err := db.Where(gorm_model.YounggeeSubAccount{SubAccountId: conv.MustInt(bOperatorID)}).First(&bsubaccount).Error; err != nil {
			return ""
		}
		return bsubaccount.SubAccountName
	}
	if bOperatorType == 3 {
		return "管理后台"
	}
	return ""
}

func getTalentinfo(db *gorm.DB, talentID string) (string, string) {
	var talentinfo gorm_model.PlatformKuaishouUserInfo
	if err := db.Where(gorm_model.PlatformKuaishouUserInfo{TalentId: talentID}).First(&talentinfo).Error; err != nil {
		return "", ""
	}
	return talentinfo.NickName, talentinfo.HeadUri
}

func getIscoop(db *gorm.DB, talentid string, enterpriseid string) int {
	var etcoop gorm_model.EnterpriseTalentCooperate
	if err := db.Where(gorm_model.EnterpriseTalentCooperate{TalentId: talentid, EnterpriseId: enterpriseid}).First(&etcoop).Error; err != nil {
		return 0
	}
	return 1
}

func determineFrom(supplierID, supplierStatus int) int {
	if supplierID != 0 && supplierStatus == 2 {
		return 2
	}
	return 1
}

func stype(db *gorm.DB, supplierID, supplierStatus int) int {
	if supplierID != 0 && supplierStatus == 2 {
		var supplierinfo gorm_model.Supplier
		err := db.Model(gorm_model.Supplier{}).Where("supplier_id = ?", supplierID).First(&supplierinfo).Error
		if err != nil {
			return 0
		}
		return supplierinfo.SupplierType
	}
	return 0
}
func PassProTaskCoop(ctx context.Context, projectId string, taskIds []string, operatorid string, operatetype int, Isspecial int, req http_model.PassproTaskCoopRequest) (bool, error) {
	db := GetReadDB(ctx)
	var count int64
	fmt.Println("task_ids: ", taskIds)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 1", taskIds).Count(&count).Error

	fmt.Println("count: ", count)
	if err != nil {
		return false, err
	}
	if int64(len(taskIds)) == 0 || count != int64(len(taskIds)) {
		return false, errors.New("任务id有误")
	}

	// 2. 查询任务对应达人id（用于生成达人消息）
	var talentIds []string
	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).Select("talent_id").Find(&talentIds).Error
	if err != nil {
		return false, err
	}

	// 3. 查询任务对应project名称（用于生成达人消息）
	var project gorm_model.ProjectInfo
	err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Find(&project).Error
	if err != nil {
		return false, err
	}

	var taskstages int
	if project.ProjectForm == 1 {
		taskstages = 4
	} else {
		taskstages = 9
	}
	nextstage := [6]int{0, 0, 0, 0, 0, 0} // 数组长度为6，表示6种工具 4,9,11,13
	if Isspecial == 1 {
		toolList := strings.Split(project.Tools, ",")
		for _, tool := range toolList {
			// 将 tool 转换为整数
			if t, err := strconv.Atoi(tool); err == nil && t >= 0 && t <= len(nextstage) {
				nextstage[t-1] = 1
			}
		}
		fmt.Println(nextstage)
		for i := 1; i < len(nextstage); i++ { // 从位置1开始
			if nextstage[i] == 1 {
				switch i {
				case 1:
					taskstages = 4
				case 2:
					taskstages = 9
				case 3:
					taskstages = 11
				case 4:
					taskstages = 13
				case 5:
					taskstages = 15
				}
				break
			}
		}
	}

	//4.根据达人来源改变状态、阶段、数目
	var tasks []gorm_model.YoungeeTaskInfo
	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 1", taskIds).Find(&tasks).Error
	if err != nil {
		return false, err
	}
	err = db.Transaction(func(tx *gorm.DB) error {
		// 2. 修改任务状态和任务阶段
		for _, taskInfo := range tasks {
			if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 { //服务商招募数量+1
				updateData := gorm_model.YoungeeTaskInfo{
					TaskStage:     taskstages,
					TaskStatus:    2,
					UpdateAt:      time.Now(),
					BOperator:     operatorid,
					BOperatorType: operatetype,
					SelectDate:    time.Now(),
				}
				err = tx.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskID).Updates(updateData).Error
				if err != nil {
					return err
				}

				//project招募数+1,预估成本+服务商价格
				var projectinfo gorm_model.ProjectInfo
				err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Find(&projectinfo).Error
				if err != nil {
					return err
				}
				projectinfo.RecruitNum += 1
				projectinfo.EstimatedCost += taskInfo.SupportFee
				err = tx.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", projectId).Updates(projectinfo).Error
				if err != nil {
					return err
				}
				//服务商s_project已招募人数+1
				var sprojectinfo gorm_model.YounggeeSProjectInfo
				err = db.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", req.SProjectId).Find(&sprojectinfo).Error
				if err != nil {
					return err
				}
				sprojectinfo.RecruitNum += 1
				fmt.Println("......", projectinfo.RecruitNum)
				err = tx.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", req.SProjectId).Updates(sprojectinfo).Error
				if err != nil {
					return err
				}

			}

			if project.ProjectForm != 1 { //非签收截止时间
				var draft_default gorm_model.InfoAutoTask
				err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskID).Find(&draft_default).Error
				if err != nil {
					return err
				}
				duration := time.Duration(draft_default.DraftDefault) * time.Hour
				upbreakdate := gorm_model.YoungeeTaskInfo{
					CurBreakAt: time.Now().Add(duration),
				}
				err = tx.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ? ", taskInfo.TaskID).Updates(upbreakdate).Error
				if err != nil {
					return err
				}
			}

			if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 { //来源于公海
				updateData := gorm_model.YoungeeTaskInfo{
					TaskStage:     taskstages,
					TaskStatus:    2,
					UpdateAt:      time.Now(),
					BOperator:     operatorid,
					BOperatorType: operatetype,
					SelectDate:    time.Now(),
				}
				err = tx.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskID).Updates(updateData).Error
				if err != nil {
					return err
				}

				//project招募数+1
				var projectinfo gorm_model.ProjectInfo
				err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Find(&projectinfo).Error
				if err != nil {
					return err
				}
				projectinfo.RecruitNum += 1
				err = tx.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", projectId).Updates(projectinfo).Error
				if err != nil {
					return err
				}
			}

		}
		// 4. 生成达人消息
		for _, talendId := range talentIds {
			err = CreateMessage(ctx, 1, 1, talendId, project.ProjectName)
			if err != nil {
				return err
			}
		}
		// 返回 nil 提交事务
		return nil
	})
	if err != nil {
		return false, err
	}
	return true, nil
}

func RefuseproTaskCoop(ctx context.Context, taskIds []string, operatorid string, operatetype int) (bool, error) {
	db := GetWriteDB(ctx)
	// 1. 校验
	var count int64
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 1", taskIds).Count(&count).Error
	if err != nil {
		return false, err
	}
	if count != int64(len(taskIds)) {
		return false, errors.New("任务id有误")
	}

	// 2. 查询任务对应达人id（用于生成达人消息）
	var talentIds []string
	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).Select("talent_id").Find(&talentIds).Error
	if err != nil {
		return false, err
	}

	var tasks []gorm_model.YoungeeTaskInfo
	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 1", taskIds).Find(&tasks).Error

	err = db.Transaction(func(tx *gorm.DB) error {
		// 2. 修改任务状态和任务阶段
		for _, taskInfo := range tasks {
			updateData := gorm_model.YoungeeTaskInfo{
				TaskStage:     3,
				TaskStatus:    3,
				UpdateAt:      time.Now(),
				BOperator:     operatorid,
				BOperatorType: operatetype,
				CompleteDate:  time.Now(),
			}
			err = tx.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskID).Updates(updateData).Error
		}
		if err != nil {
			return err
		}

		// 返回 nil 提交事务
		return nil
	})
	if err != nil {
		return false, err
	}
	return true, nil
}

func GetPreSketchList(ctx context.Context, request http_model.PreSketchListRequest) (*http_model.GetSketchTaskListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.ScriptStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.TasksketchInfo, 0, len(projecrtaskinfo))

	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterpriseId)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			City:               task.City,
		}
		response := &http_model.TasksketchInfo{
			Task: taskinfo,
			DDl:  task.CurBreakAt,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GetSketchTaskListData{
		TasksketchList: taskInfoPointers,
		Total:          conv.MustString(total, ""),
	}, nil
}

func GetSketchList(ctx context.Context, request http_model.TasksketchlistRequest) (*http_model.GetsketchtaskListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.ScriptStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.Tasksketchinfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			City:               task.City,
		}
		var sketchinfo gorm_model.YounggeeSketchInfo
		err := db.Model(&gorm_model.YounggeeSketchInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&sketchinfo).Error
		if err != nil {
			return nil, err
		}
		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
		response := &http_model.Tasksketchinfo{
			Task:     taskinfo,
			SketchId: sketchinfo.SketchID,
			SubmitAt: sketchinfo.SubmitAt,
			AgreeAt:  sketchinfo.AgreeAt,
			Operator: boperator,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GetsketchtaskListData{
		TasksketchList: taskInfoPointers,
		Total:          conv.MustString(total, ""),
	}, nil
}

func GetPreLinkList(ctx context.Context, request http_model.PreLinkListRequest) (*http_model.GetprelinkListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.LinkStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.Tasklinkinfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterpriseId)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			City:               task.City,
		}
		response := &http_model.Tasklinkinfo{
			Task: taskinfo,
			DDl:  task.CurBreakAt,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GetprelinkListData{
		TasklinkList: taskInfoPointers,
		Total:        conv.MustString(total, ""),
	}, nil
}

func GetLinkList(ctx context.Context, request http_model.TaskLinklistRequest) (*http_model.GettasklinkListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.LinkStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.TaskLinkinfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterpriseId)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			City:               task.City,
		}
		var linkinfo gorm_model.YounggeeLinkInfo
		err := db.Model(&gorm_model.YounggeeLinkInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&linkinfo).Error
		if err != nil {
			return nil, err
		}
		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
		response := &http_model.TaskLinkinfo{
			Task:     taskinfo,
			LinkId:   linkinfo.LinkID,
			SubmitAt: linkinfo.SubmitAt,
			AgreeAt:  linkinfo.AgreeAt,
			LinkUrl:  linkinfo.LinkUrl,
			PhotoUrl: linkinfo.PhotoUrl,
			Operator: boperator,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GettasklinkListData{
		TaskLinklist: taskInfoPointers,
		Total:        conv.MustString(total, ""),
	}, nil
}

func GetPreDataList(ctx context.Context, request http_model.PreDataListRequest) (*http_model.GetPreDataListData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.DataStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.Taskdatainfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterpriseId)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			City:               task.City,
		}
		response := &http_model.Taskdatainfo{
			Task: taskinfo,
			DDl:  task.CurBreakAt,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GetPreDataListData{
		TaskdataList: taskInfoPointers,
		Total:        conv.MustString(total, ""),
	}, nil
}

func GetDataList(ctx context.Context, request http_model.TaskDatalistRequest) (*http_model.GetTaskDatalistData, error) {
	db := GetReadDB(ctx)
	var projecrtaskinfo []gorm_model.YoungeeTaskInfo
	query := db.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_stage = ?", request.ProjectId, request.DataStatus)
	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	// 添加分页逻辑
	pageSize := request.PageSize
	if pageSize == 0 {
		pageSize = 10
	}
	pageNum := request.PageNum
	if pageNum == 0 {
		pageNum = 1
	}
	offset := (pageNum - 1) * pageSize
	// 执行分页查询
	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
		return nil, err
	}
	taskInfoPointers := make([]*http_model.TaskDatainfo, 0, len(projecrtaskinfo))
	for _, task := range projecrtaskinfo {
		nickname, headurl := getTalentinfo(db, task.TalentID)
		Iscoop := getIscoop(db, task.TalentID, request.EnterpriseId)
		taskinfo := &http_model.TaskInfo{
			TaskId:             task.TaskID,
			ProjectId:          task.ProjectID,
			TalentId:           task.TalentID,
			FansNum:            task.FansNum,
			DraftFee:           task.DraftFee,
			Voteavg:            task.VoteAvg,
			FeeFrom:            task.FeeForm,
			TaskStage:          task.TaskStage,
			Commentavg:         task.CommitAvg,
			CurrentDefaultType: task.CurDefaultType,
			From:               determineFrom(task.SupplierId, task.SupplierStatus),
			SType:              stype(db, task.SupplierId, task.SupplierStatus),
			NickName:           nickname,
			HeadUrl:            headurl,
			ISCoop:             Iscoop,
			City:               task.City,
		}
		var datainfo gorm_model.YounggeeDataInfo
		err := db.Model(&gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&datainfo).Error
		if err != nil {
			return nil, err
		}
		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
		response := &http_model.TaskDatainfo{
			Task:          taskinfo,
			DataId:        datainfo.DataID,
			SubmitAt:      datainfo.SubmitAt,
			AgreeAt:       datainfo.AgreeAt,
			PhotoUrl:      datainfo.PhotoUrl,
			PlayNumber:    datainfo.PlayNumber,
			LikeNumber:    datainfo.LikeNumber,
			CollectNumber: datainfo.CollectNumber,
			CommentNumber: datainfo.CommentNumber,
			SettleAmount:  task.SettleAmount,
			Breakrate:     task.SketchBreakRate + task.LinkBreakRate + task.DataBreakRate,
			Operator:      boperator,
		}
		taskInfoPointers = append(taskInfoPointers, response)

	}
	return &http_model.GetTaskDatalistData{
		TaskDatalist: taskInfoPointers,
		Total:        conv.MustString(total, ""),
	}, nil
}