youngee_b_api/db/task.go

package db

import (
	"context"
	"fmt"
	"github.com/tidwall/gjson"
	"reflect"
	"strconv"
	"strings"
	"time"
	"youngee_m_api/model/common_model"
	"youngee_m_api/model/gorm_model"
	"youngee_m_api/model/http_model"
	"youngee_m_api/pack"
	"youngee_m_api/util"

	"github.com/caixw/lib.go/conv"
	"gorm.io/gorm"

	"github.com/sirupsen/logrus"
)

func GetTaskList(ctx context.Context, projectID string) ([]gorm_model.YoungeeTaskInfo, error) {
	db := GetReadDB(ctx)
	var tasks []gorm_model.YoungeeTaskInfo
	err := db.Where("project_id = ? AND task_status = 2", projectID).Find(&tasks).Error
	if err != nil {
		return nil, err
	}
	return tasks, nil
}

func UpdateLogisticsStatus(ctx context.Context, taskID string, status int64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Update("logistics_status", status).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsStatus error,err:%+v", err)
		return err
	}
	return nil
}

func UpdateLogisticsDate(ctx context.Context, taskID string) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Update("delivery_date", time.Now()).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsDate error,err:%+v", err)
		return err
	}
	return nil
}

func GetProjectIdByTaskId(ctx context.Context, taskID string) (*string, error) {
	db := GetReadDB(ctx)
	task := &gorm_model.YoungeeTaskInfo{}
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Scan(task).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsStatus error,err:%+v", err)
		return nil, err
	}
	return &task.ProjectId, nil
}

func ChangeTaskStatus(ctx context.Context, taskIds []string, taskStatus string) ([]int64, error) {
	db := GetReadDB(ctx)

	taskSta := conv.MustInt(taskStatus, 0)
	if err := db.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).
		Updates(gorm_model.YoungeeTaskInfo{TaskStatus: taskSta}).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]2 error query mysql total, err:%+v", err)
		return nil, err
	}

	var taskInfos []gorm_model.YoungeeTaskInfo
	err := db.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).Find(&taskInfos).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]3 error query mysql total, err:%+v", err)
		return nil, err
	}
	var recruitStrategysIDs []int64
	recruitStrategys := gorm_model.RecruitStrategy{}
	for _, taskInfo := range taskInfos {
		err2 := db.Debug().Model(gorm_model.RecruitStrategy{}).Where("project_id=? AND strategy_id=?", taskInfo.ProjectId, taskInfo.StrategyId).Scan(&recruitStrategys).Error
		if err2 != nil {
			logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]4 error query mysql total, err:%+v", err2)
			return nil, err2
		}
		recruitStrategysIDs = append(recruitStrategysIDs, recruitStrategys.RecruitStrategyID)
	}
	return recruitStrategysIDs, nil
}

func ChangeSpecialTaskStatus(ctx context.Context, taskIds []string, taskStatus string, taskStage string) error {
	db := GetReadDB(ctx)
	status, err := strconv.Atoi(taskStatus)
	stage, err := strconv.Atoi(taskStage)
	if err != nil {
		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]1 error query mysql total, err:%+v", err)
		return err
	}
	err = db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).
			Updates(gorm_model.YoungeeTaskInfo{TaskStatus: status, TaskStage: stage, SelectDate: time.Now()}).Error; err != nil {
			logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]2 error query mysql total, err:%+v", err)
			return err
		}
		return nil
	})
	if err != nil {
		return err
	}
	//if err := db.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).
	//	Updates(gorm_model.YoungeeTaskInfo{TaskStatus: status, TaskStage: stage, SelectDate: time.Now()}).Error; err != nil {
	//	logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]2 error query mysql total, err:%+v", err)
	//	return err
	//}
	return nil
}

func UpdateTaskStage(ctx context.Context, projectID string, taskStatus int64, taskStage int64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id=? and task_status = ?", projectID, taskStatus).Update("task_stage", taskStage).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateTaskStatusPaying]2 error query mysql total, err:%+v", err)
		return err
	}
	return nil
}

func UpdateTaskSelectAtByProjectId(ctx context.Context, projectID string, taskStatus int64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id=? and task_status = ?", projectID, taskStatus).Update("select_date", time.Now()).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateTaskStage]2 error query mysql total, err:%+v", err)
		return err
	}
	return nil
}

func UpdateTaskStageByProjectId(ctx context.Context, projectID string, taskStatus int64, taskStage int64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id=? and task_status = ?", projectID, taskStatus).Update("task_stage", taskStage).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateTaskStage]2 error query mysql total, err:%+v", err)
		return err
	}
	return nil
}

func GetSpecialTaskInviteList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.SpecialTaskInviteInfo, int64, error) {
	db := GetReadDB(ctx)
	// 查询task表信息
	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_stage != 3")
	// 根据Project条件过滤
	conditionType := reflect.TypeOf(conditions).Elem()
	conditionValue := reflect.ValueOf(conditions).Elem()
	var platform_nickname string = ""
	for i := 0; i < conditionType.NumField(); i++ {
		field := conditionType.Field(i)
		tag := field.Tag.Get("condition")
		value := conditionValue.FieldByName(field.Name)
		if tag == "task_status" {
			fmt.Printf("link %+v", value.Interface() == int64(0))
			if value.Interface() == int64(0) {
				db = db.Where("task_status <> 2")
			} else {
				db = db.Where("task_status = 2")
			}
			continue
		} else if !util.IsBlank(value) {
			if tag == "platform_nickname" {
				platform_nickname = fmt.Sprintf("%v", value.Interface())
				continue
			} else if tag == "project_id" {
				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
			}
		}
	}
	var taskInfos []gorm_model.YoungeeTaskInfo
	db = db.Model(gorm_model.YoungeeTaskInfo{})
	// 查询总数
	var totalTask int64
	if err := db.Count(&totalTask).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	db.Order("task_id").Find(&taskInfos)

	// 查询该页数据
	limit := pageSize
	offset := pageSize * pageNum // assert pageNum start with 0
	err := db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
		return nil, 0, err
	}

	var taskDatas []*http_model.SpecialTaskInviteInfo
	var newTaskDatas []*http_model.SpecialTaskInviteInfo

	taskDatas = pack.YoungeeTaskInfoToSpecialTaskInviteInfo(taskInfos)

	for _, v := range taskDatas {
		if platform_nickname == "" {
			newTaskDatas = append(newTaskDatas, v)
		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
			newTaskDatas = append(newTaskDatas, v)
		} else if strings.Contains(conv.MustString(v.TaskID, ""), platform_nickname) {
			newTaskDatas = append(newTaskDatas, v)
		} else {
			totalTask--
		}
	}
	return newTaskDatas, totalTask, nil
}

//// SetTaskFinish 任务结案
//func SetTaskFinish(ctx context.Context, TaskIDs []string) error {
//	db := GetReadDB(ctx)
//	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
//	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).
//		Updates(gorm_model.YoungeeTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now()}).Error
//	if err != nil {
//		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
//		return err
//	}
//
//	// 2. 修改招募策略表，更新粉丝量、播放量、点赞数、收藏数、评论数、总支付、结案数量
//	for _, v := range TaskIDs {
//		// 查询task_info
//		db = GetReadDB(ctx)
//		taskInfo := gorm_model.YoungeeTaskInfo{}
//		err1 := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", v).Scan(&taskInfo).Error
//		if err1 != nil {
//			logrus.WithContext(ctx).Errorf("[Task db] Find YoungeeTaskInfo error,err:%+v", err)
//			return err1
//		}
//		//查询project_info
//		projectInfo := gorm_model.ProjectInfo{}
//		err1 = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectId).Scan(&projectInfo).Error
//		if err1 != nil {
//			logrus.WithContext(ctx).Errorf("[Task db] Find ProjectInfo error,err:%+v", err)
//			return err1
//		}
//		// 查询data_info
//		db = GetReadDB(ctx)
//		dataInfo := gorm_model.YounggeeDataInfo{}
//		err1 = db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_ok = 1", v).Scan(&dataInfo).Error
//		if err1 != nil {
//			logrus.WithContext(ctx).Errorf("[Task db] Find YounggeeDataInfo error,err:%+v", err)
//			return err1
//		}
//
//		// 2. 创建任务收益
//		var productStruct gorm_model.YounggeeProduct
//		if err = json.Unmarshal([]byte(projectInfo.ProductSnap), &productStruct); err != nil {
//			fmt.Println("Error:", err)
//			return err
//		}
//		t := time.Now()
//		income := gorm_model.YounggeeTalentIncome{
//			TalentID:       taskInfo.TalentId,
//			ProjectID:      taskInfo.ProjectId,
//			SectaskID:      taskInfo.TaskId,
//			BrandName:      productStruct.BrandName,
//			TaskName:       projectInfo.ProjectName,
//			Income:         strconv.FormatFloat(taskInfo.SettleAmount, 'f', 10, 32),
//			IncomeType:     1,
//			WithdrawStatus: 1,
//			IncomeAt:       &t,
//			WithdrawAt:     nil,
//		}
//		err = CreateIncome(ctx, income, nil)
//		if err != nil {
//			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
//			return err
//		}
//
//		// 更新招募策略
//		db = GetReadDB(ctx)
//		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.ProjectId, taskInfo.StrategyId)
//		fansCount, _ := strconv.Atoi(conv.MustString(gjson.Get(taskInfo.TalentPlatformInfoSnap, "fans_count"), ""))
//		err = db.Updates(map[string]interface{}{
//			"fan_number":     gorm.Expr("fan_number + ?", fansCount),
//			"play_number":    gorm.Expr("play_number + ?", dataInfo.PlayNumber),
//			"like_number":    gorm.Expr("like_number + ?", dataInfo.LikeNumber),
//			"collect_number": gorm.Expr("collect_number + ?", dataInfo.CollectNumber),
//			"comment_number": gorm.Expr("comment_number + ?", dataInfo.CommentNumber),
//			"finish_number":  gorm.Expr("finish_number + 1"),
//			"total_offer":    gorm.Expr("total_offer + ?", taskInfo.RealPayment)}).Error
//		if err != nil {
//			logrus.WithContext(ctx).Errorf("[Task db] Update YounggeeDataInfo error,err:%+v", err)
//			return err
//		}
//	}
//	return nil
//}

// SetTaskFinish 任务结案
func SetTaskFinish(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now(), SettleStatus: 2}).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
		return err
	}

	for _, v := range TaskIDs {
		// 查询task_info
		db = GetReadDB(ctx)
		taskInfo := gorm_model.YoungeeTaskInfo{}
		err1 := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", v).Scan(&taskInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find YoungeeTaskInfo error,err:%+v", err)
			return err1
		}
		//查询project_info
		projectInfo := gorm_model.ProjectInfo{}
		err1 = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectId).Scan(&projectInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find ProjectInfo error,err:%+v", err)
			return err1
		}
		// 查询data_info
		db = GetReadDB(ctx)
		dataInfo := gorm_model.YounggeeDataInfo{}
		err1 = db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_ok = 1", v).Scan(&dataInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find YounggeeDataInfo error,err:%+v", err)
			return err1
		}

		t := time.Now()
		income := gorm_model.YounggeeTalentIncome{
			TalentID:  taskInfo.TalentId,
			ProjectID: taskInfo.ProjectId,
			TaskID:    taskInfo.TaskId,
			Type:      1,
			//BrandName:      productStruct.BrandName,
			TaskName: projectInfo.ProjectName,
			//PhotoUrl:       mainPhoto,
			Income:         strconv.FormatFloat(taskInfo.SettleAmount, 'f', 10, 32),
			IncomeType:     1,
			WithdrawStatus: 1,
			IncomeAt:       &t,
			WithdrawAt:     nil,
		}
		err = CreateIncome(ctx, income, nil)
		if err != nil {
			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
			return err
		}

		// 3. 修改招募策略表，更新粉丝量、播放量、点赞数、收藏数、评论数、总支付、结案数量
		// 更新招募策略
		db = GetReadDB(ctx)
		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.ProjectId, taskInfo.StrategyId)
		fansCount, _ := strconv.Atoi(conv.MustString(gjson.Get(taskInfo.TalentPlatformInfoSnap, "fans_count"), ""))
		err = db.Updates(map[string]interface{}{
			"fan_number":     gorm.Expr("fan_number + ?", fansCount),
			"play_number":    gorm.Expr("play_number + ?", dataInfo.PlayNumber),
			"like_number":    gorm.Expr("like_number + ?", dataInfo.LikeNumber),
			"collect_number": gorm.Expr("collect_number + ?", dataInfo.CollectNumber),
			"comment_number": gorm.Expr("comment_number + ?", dataInfo.CommentNumber),
			"finish_number":  gorm.Expr("finish_number + 1"),
			"total_offer":    gorm.Expr("total_offer + ?", taskInfo.RealPayment)}).Error
		if err != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Update YounggeeDataInfo error,err:%+v", err)
			return err
		}
	}
	return nil
}

// SetTaskFinish 专项任务结案
func SetSpecialTaskFinish(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now()}).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
		return err
	}
	return nil
}

// SetTaskFinish 专项任务结案
func SetSpecialLocalTaskFinish(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now()}).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
		return err
	}
	return nil
}

// SetSpecialTaskSettleNum 结案人数+1
func SetSpecialLocalTaskSettleNum(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	//4.根据达人来源改变状态、阶段、数目
	var tasks []gorm_model.YoungeeLocalTaskInfo
	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? ", TaskIDs).Find(&tasks).Error
	if err != nil {
		return err
	}
	for _, taskInfo := range tasks {
		if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 {
			//project招募数+1,预估成本+服务商价格
			var projectinfo gorm_model.YounggeeLocalLifeInfo
			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", taskInfo.LocalId).Find(&projectinfo).Error
			if err != nil {
				return err
			}
			projectinfo.SettleNum += 1
			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", taskInfo.LocalId).Updates(projectinfo).Error
			if err != nil {
				return err
			}
			//服务商s_project已招募人数+1
			var sprojectinfo gorm_model.YounggeeSLocalLifeInfo
			err = db.Model(gorm_model.YounggeeSLocalLifeInfo{}).Where(" s_local_life_id =?", taskInfo.SLocalLifeId).Find(&sprojectinfo).Error
			if err != nil {
				return err
			}
			sprojectinfo.RecruitNum += 1
			fmt.Println("......", projectinfo.RecruitNum)
			err = db.Model(gorm_model.YounggeeSLocalLifeInfo{}).Where(" s_local_life_id =?", taskInfo.SLocalLifeId).Updates(sprojectinfo).Error
			if err != nil {
				return err
			}
		}
		if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 {
			//project招募数+1
			var projectinfo gorm_model.YounggeeLocalLifeInfo
			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", taskInfo.LocalId).Find(&projectinfo).Error
			if err != nil {
				return err
			}
			projectinfo.SettleNum += 1
			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", taskInfo.LocalId).Updates(projectinfo).Error
			if err != nil {
				return err
			}
		}
	}
	return nil
}

func SetTalentIncome(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	var TaskInfoList []gorm_model.YoungeeTaskInfo
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Scan(&TaskInfoList).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
		return err
	}
	for _, taskInfo := range TaskInfoList {
		err := db.Model(gorm_model.YoungeeTalentInfo{}).Where("id = ?", taskInfo.TalentId).Updates(map[string]interface{}{
			"income":      gorm.Expr("income + ?", taskInfo.SettleAmount),
			"canwithdraw": gorm.Expr("canwithdraw + ?", taskInfo.SettleAmount)}).Error
		if err != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
			return err
		}
	}
	return nil
}

// SetTaskFinish 任务结案
func SetLocalTaskFinish(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now(), SettleStatus: 2}).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
		return err
	}

	for _, v := range TaskIDs {
		// 查询task_info
		db = GetReadDB(ctx)
		taskInfo := gorm_model.YoungeeLocalTaskInfo{}
		err1 := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", v).Scan(&taskInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find YoungeeTaskInfo error,err:%+v", err)
			return err1
		}
		//查询project_info
		projectInfo := gorm_model.YounggeeLocalLifeInfo{}
		err1 = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("project_id = ?", taskInfo.LocalId).Scan(&projectInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find ProjectInfo error,err:%+v", err)
			return err1
		}
		// 查询data_info
		db = GetReadDB(ctx)
		dataInfo := gorm_model.YounggeeDataInfo{}
		err1 = db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_ok = 1", v).Scan(&dataInfo).Error
		if err1 != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Find YounggeeDataInfo error,err:%+v", err)
			return err1
		}

		// 2. 创建任务收益
		//var productStruct gorm_model.YounggeeProduct
		//if err = json.Unmarshal([]byte(projectInfo.ProductSnap), &productStruct); err != nil {
		//	fmt.Println("Error:", err)
		//	return err
		//}
		//var productPhotoStruct []gorm_model.YounggeeProductPhoto
		//if err = json.Unmarshal([]byte(projectInfo.ProductPhotoSnap), &productPhotoStruct); err != nil {
		//	fmt.Println("Error:", err)
		//	return err
		//}
		//var mainPhoto = ""
		//for _, w := range productPhotoStruct {
		//	if w.Symbol == 1 {
		//		mainPhoto = w.PhotoUrl
		//	}
		//}

		t := time.Now()
		income := gorm_model.YounggeeTalentIncome{
			TalentID:  taskInfo.TalentId,
			ProjectID: taskInfo.LocalId,
			TaskID:    taskInfo.TaskId,
			Type:      1,
			//BrandName:      productStruct.BrandName,
			TaskName: projectInfo.LocalName,
			//PhotoUrl:       mainPhoto,
			Income:         strconv.FormatFloat(taskInfo.SettleAmount, 'f', 10, 32),
			IncomeType:     1,
			WithdrawStatus: 1,
			IncomeAt:       &t,
			WithdrawAt:     nil,
		}
		err = CreateIncome(ctx, income, nil)
		if err != nil {
			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
			return err
		}

		// 3. 修改招募策略表，更新粉丝量、播放量、点赞数、收藏数、评论数、总支付、结案数量
		// 更新招募策略
		db = GetReadDB(ctx)
		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.LocalId, taskInfo.StrategyId)
		fansCount, _ := strconv.Atoi(conv.MustString(gjson.Get(taskInfo.TalentPlatformInfoSnap, "fans_count"), ""))
		err = db.Updates(map[string]interface{}{
			"fan_number":     gorm.Expr("fan_number + ?", fansCount),
			"play_number":    gorm.Expr("play_number + ?", dataInfo.PlayNumber),
			"like_number":    gorm.Expr("like_number + ?", dataInfo.LikeNumber),
			"collect_number": gorm.Expr("collect_number + ?", dataInfo.CollectNumber),
			"comment_number": gorm.Expr("comment_number + ?", dataInfo.CommentNumber),
			"finish_number":  gorm.Expr("finish_number + 1"),
			"total_offer":    gorm.Expr("total_offer + ?", taskInfo.RealPayment)}).Error
		if err != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Update YounggeeDataInfo error,err:%+v", err)
			return err
		}
	}
	return nil
}

func SetLocalTalentIncome(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	var TaskInfoList []gorm_model.YoungeeLocalTaskInfo
	fmt.Println("收入", TaskIDs)
	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Scan(&TaskInfoList).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
		return err
	}
	for _, taskInfo := range TaskInfoList {
		err := db.Model(gorm_model.YoungeeTalentInfo{}).Where("id = ?", taskInfo.TalentId).Updates(map[string]interface{}{
			"income":      gorm.Expr("income + ?", taskInfo.SettleAmount),
			"canwithdraw": gorm.Expr("canwithdraw + ?", taskInfo.SettleAmount)}).Error
		if err != nil {
			logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
			return err
		}
	}
	return nil
}
func GetUnfinishedTaskNumber(ctx context.Context, projectID string) (*int64, error) {
	var unFinishedTaskNumber int64
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and task_status = 2 and task_stage < 15", projectID).Count(&unFinishedTaskNumber).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[Data db] Find YounggeeTaskInfo error,err:%+v", err)
		return nil, err
	}
	return &unFinishedTaskNumber, nil
}

func UpdateTaskStageByTaskId(ctx context.Context, taskID string, taskStatus int64, taskStage int64) error {
	db := GetReadDB(ctx)
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id=? and task_status = ?", taskID, taskStatus).Update("task_stage", taskStage).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateTaskStageByTaskId]2 error query mysql total, err:%+v", err)
		return err
	}
	return nil
}

// 获取任务ids
func GetTaskIds(ctx context.Context, projectId string) ([]string, error) {
	db := GetReadDB(ctx)
	var taskIds []string
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Select("task_id").Where("project_id = ? and task_status = 2", projectId).Find(&taskIds).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[CreateMessageByTask] error read mysql, err:%+v", err)
		return nil, err
	}

	return taskIds, nil
}

func UpdateTask(ctx context.Context, updateData gorm_model.YoungeeTaskInfo, tx *gorm.DB) (bool, error) {
	db := GetWriteDB(ctx)
	whereCondition := gorm_model.YoungeeTaskInfo{
		TaskId: updateData.TaskId,
	}
	if tx != nil {
		err := tx.Where(whereCondition).Updates(&updateData).Error
		if err != nil {
			return false, err
		}
	} else {
		err := db.Where(whereCondition).Updates(&updateData).Error
		if err != nil {
			return false, err
		}
	}

	return true, nil
}

// SetSpecialTaskSettleNum 结案人数+1
func SetSpecialTaskSettleNum(ctx context.Context, TaskIDs []string) error {
	db := GetReadDB(ctx)
	//4.根据达人来源改变状态、阶段、数目
	var tasks []gorm_model.YoungeeTaskInfo
	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? ", TaskIDs).Find(&tasks).Error
	if err != nil {
		return err
	}
	for _, taskInfo := range tasks {
		if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 {
			//project招募数+1,预估成本+服务商价格
			var projectinfo gorm_model.ProjectInfo
			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectId).Find(&projectinfo).Error
			if err != nil {
				return err
			}
			projectinfo.SettleNum += 1
			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", taskInfo.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 =?", taskInfo.SProjectId).Find(&sprojectinfo).Error
			if err != nil {
				return err
			}
			sprojectinfo.RecruitNum += 1
			fmt.Println("......", projectinfo.RecruitNum)
			err = db.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", taskInfo.SProjectId).Updates(sprojectinfo).Error
			if err != nil {
				return err
			}
		}
		if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 {
			//project招募数+1
			var projectinfo gorm_model.ProjectInfo
			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectId).Find(&projectinfo).Error
			if err != nil {
				return err
			}
			projectinfo.SettleNum += 1
			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", taskInfo.ProjectId).Updates(projectinfo).Error
			if err != nil {
				return err
			}
		}
	}
	return nil
}