youngee_b_api/app/service/project_service.go

package service

import (
	"encoding/json"
	"errors"
	"github.com/sirupsen/logrus"
	"reflect"
	"strings"
	"time"
	"youngee_b_api/app/dao"
	"youngee_b_api/app/entity"
	"youngee_b_api/app/service/review_service"
	"youngee_b_api/app/util"
	"youngee_b_api/app/vo"
)

type ProjectService struct{}

// 创建种草任务
func (s ProjectService) CreateProject(projectCreateParam *vo.ProjectCreateParam) (*string, error) {
	// a) 生成种草项目id
	projectId := strings.ReplaceAll(util.GenerateUUID(11), "-", "")
	// b) 查找关联商品信息
	product, err := dao.ProductDAO{}.GetProductByID(projectCreateParam.ProductId)
	if err != nil {
		return nil, err
	}
	if product == nil {
		return nil, errors.New("未找到关联商品")
	}
	productPhotos, err := dao.ProductPhotoDAO{}.GetProductPhotoByProductID(projectCreateParam.ProductId)
	productInfoToJson, _ := json.Marshal(product)
	productPhotosToJson, _ := json.Marshal(productPhotos)
	// d) 任务截止时间
	recruitDdl, err1 := time.ParseInLocation("2006-01-02 15:04:05", projectCreateParam.RecruitDdl, time.Local)
	if err1 != nil {
		return nil, errors.New("failed to parse recruitDdl")
	}
	// d)创建种草任务
	var operatorType int64
	if projectCreateParam.SubAccountId == 0 {
		operatorType = 1
	} else {
		operatorType = 2
	}

	// 获取定时任务配置id
	infoAutoTask := entity.InfoAutoTask{}
	infoAutoTask = dao.InfoAutoTaskDao{}.GetAutoTaskLast(projectCreateParam.EnterpriseId)
	infoAutoDefault := entity.InfoAutoDefault{}
	infoAutoDefault = dao.InfoAutoDefaultDao{}.GetAutoDefaultLast(projectCreateParam.EnterpriseId)
	t := time.Now()
	if recruitDdl.Before(t) {
		return nil, errors.New("请修改截止时间")
	}
	newProject := entity.Project{
		ProjectStatus:    1,
		ProjectType:      projectCreateParam.ProjectType,
		ProjectId:        projectId,
		ProductID:        projectCreateParam.ProductId,
		ProductCategory:  product.ProductCategory,
		EnterpriseID:     projectCreateParam.EnterpriseId,
		SubAccountId:     projectCreateParam.SubAccountId,
		ProjectPlatform:  projectCreateParam.Platform,
		OperatorType:     operatorType,
		ProductSnap:      string(productInfoToJson),
		ProductPhotoSnap: string(productPhotosToJson),
		CreatedAt:        t,
		AutoTaskID:       infoAutoTask.AutoTaskID,
		AutoDefaultID:    infoAutoDefault.AutoDefaultID,
		ProjectName:      projectCreateParam.ProjectName,
		TalentType:       projectCreateParam.TalentType,
		RecruitDdl:       recruitDdl,
		ProjectForm:      projectCreateParam.ProjectForm,
		ContentType:      projectCreateParam.ContentType,
		ProjectDetail:    projectCreateParam.ProjectDetail,
		Tools:            projectCreateParam.Tools,
	}
	if projectCreateParam.ProjectType == 1 {
		newProject.ServiceChargeRate = projectCreateParam.ServiceChargeRate
	}
	err = dao.ProjectDAO{}.CreateProject(newProject)
	if err != nil {
		return nil, err
	}

	// 4. 更新选品brief和示例（种草任务补充信息）
	if projectCreateParam.ProjectBrief != nil {
		// 插入新的brief
		for _, v := range projectCreateParam.ProjectBrief {
			brief := entity.ProjectBrief{
				ProjectID: projectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectBriefDao{}.CreateProjectBrief(brief)
			if err != nil {
				return nil, err
			}
		}
	}
	if projectCreateParam.ProjectMaterial != nil {
		// 插入新的示例
		for _, v := range projectCreateParam.ProjectMaterial {
			projectMaterial := entity.ProjectMaterial{
				ProjectID: projectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectMaterialDao{}.CreateProjectMaterial(projectMaterial)
			if err != nil {
				return nil, err
			}
		}
	}
	// 更新公开种草任务的招募策略
	var totalRecruitNum int64
	var estimatedCost float64
	if projectCreateParam.RecruitStrategys != nil {
		// 2. 接收并创建新的招募策略
		if len(projectCreateParam.RecruitStrategys) != 0 {
			var recruits []entity.RecruitStrategy
			for _, strategy := range projectCreateParam.RecruitStrategys {
				if strategy.FeeForm == 2 {
					estimatedCost += float64(strategy.RecruitNumber) * strategy.Offer
				}
				recruitStrategy := entity.RecruitStrategy{
					FeeForm:       strategy.FeeForm,
					StrategyID:    strategy.StrategyID,
					FollowersLow:  strategy.FollowersLow,
					FollowersUp:   strategy.FollowersUp,
					RecruitNumber: strategy.RecruitNumber,
					ProjectID:     projectId,
					StrategyType:  1,
					ServiceRate:   projectCreateParam.ServiceChargeRate,
				}
				totalRecruitNum += strategy.RecruitNumber
				if strategy.FeeForm == 2 {
					recruitStrategy.Offer = strategy.Offer
					recruitStrategy.ServiceCharge = strategy.Offer * projectCreateParam.ServiceChargeRate
					recruitStrategy.TOffer = strategy.Offer * (1 - projectCreateParam.ServiceChargeRate)
				}
				recruits = append(recruits, recruitStrategy)
			}
			err = dao.RecruitStrategyDao{}.CreateRecruitStrategy(recruits)
			if err != nil {
				return nil, err
			}
		}
	}
	_ = dao.ProjectDAO{}.UpdateProject(entity.Project{
		ProjectId:     projectId,
		EstimatedCost: estimatedCost,
	})

	return &projectId, nil
}

// 更新公开种草任务（招募要求、执行要求）
func (s ProjectService) UpdateProject(projectUpdateParam *vo.ProjectUpdateParam) (*string, error) {
	// 1. 检查该项目id有无种草任务
	projectID := projectUpdateParam.ProjectID
	project, err := dao.ProjectDAO{}.GetProjectById(projectID)
	if err != nil {
		return nil, err
	}
	if project == nil {
		return nil, errors.New("种草项目不存在")
	}
	recruitDdl := time.Time{} //赋零值
	recruitDdl, _ = time.ParseInLocation("2006-01-02 15:04:05", projectUpdateParam.RecruitDdl, time.Local)
	if recruitDdl.Before(project.CreatedAt) {
		return nil, errors.New("请修改截止时间")
	}
	// 更新公开种草任务的招募策略
	var totalRecruitNum int64
	var estimatedCost float64
	if projectUpdateParam.RecruitStrategys != nil {
		// 1. 删除已有的招募策略
		err = dao.RecruitStrategyDao{}.DeleteRecruitStrategyByProjectID(projectUpdateParam.ProjectID)
		if err != nil {
			return nil, err
		}
		// 2. 接收并创建新的招募策略
		if len(projectUpdateParam.RecruitStrategys) != 0 {
			var recruits []entity.RecruitStrategy
			for _, strategy := range projectUpdateParam.RecruitStrategys {
				if strategy.FeeForm == 2 {
					estimatedCost += float64(strategy.RecruitNumber) * strategy.Offer
				}
				recruitStrategy := entity.RecruitStrategy{
					FeeForm:       strategy.FeeForm,
					StrategyID:    strategy.StrategyID,
					FollowersLow:  strategy.FollowersLow,
					FollowersUp:   strategy.FollowersUp,
					RecruitNumber: strategy.RecruitNumber,
					ProjectID:     project.ProjectId,
					StrategyType:  1,
					ServiceRate:   project.ServiceChargeRate,
				}
				totalRecruitNum += strategy.RecruitNumber
				if strategy.FeeForm == 2 {
					recruitStrategy.Offer = strategy.Offer
					recruitStrategy.ServiceCharge = strategy.Offer * projectUpdateParam.ServiceChargeRate
					recruitStrategy.TOffer = strategy.Offer * (1 - projectUpdateParam.ServiceChargeRate)
				}
				recruits = append(recruits, recruitStrategy)
			}
			err = dao.RecruitStrategyDao{}.CreateRecruitStrategy(recruits)
			if err != nil {
				return nil, err
			}
		}
	}
	// 2. 数据准备
	// a) 查找关联商品信息
	product, err := dao.ProductDAO{}.GetProductByID(project.ProductID)
	if err != nil {
		return nil, err
	}
	productPhotos, err := dao.ProductPhotoDAO{}.GetProductPhotoByProductID(project.ProductID)
	productInfoToJson, _ := json.Marshal(product)
	productPhotosToJson, _ := json.Marshal(productPhotos)
	// d) 任务截止时间
	//// f) 更新选品状态
	//if projectUpdateParam.ProjectStatus != 2 && projectUpdateParam.ProjectStatus != 8 {
	//	projectUpdateParam.ProjectStatus = 1
	//}
	t := time.Now()
	updateProject := entity.Project{
		//ProjectStatus:     projectUpdateParam.ProjectStatus,
		ServiceChargeRate: projectUpdateParam.ServiceChargeRate,
		ProjectName:       projectUpdateParam.ProjectName,
		ProductID:         projectUpdateParam.ProductId,
		TalentType:        projectUpdateParam.TalentType,
		RecruitDdl:        recruitDdl,
		ProductSnap:       string(productInfoToJson),
		ProductPhotoSnap:  string(productPhotosToJson),
		UpdatedAt:         t,
		ProjectForm:       projectUpdateParam.ProjectForm,
		ContentType:       projectUpdateParam.ContentType,
		ProjectDetail:     projectUpdateParam.ProjectDetail,
		EstimatedCost:     estimatedCost,
	}
	//if projectUpdateParam.ProjectStatus == 2 {
	//	updateProject.SubmitAt = t
	//}
	// 合并传入参数和数据表中原记录，若传入参数字段值为空，则将字段赋值为原记录中值
	result := util.MergeStructValue(&updateProject, project)
	// 利用反射机制将interface类型转换为结构体类型
	v := reflect.ValueOf(&result).Elem()
	if v.Kind() == reflect.Struct {
		updateProject = v.Interface().(entity.Project)
		//fmt.Println(p)
	}
	// c) 计算预估成本（如果有）
	/*
		var estimatedCost float64
		if conv.MustInt(updateSelection.TaskMode, 0) == 1 {
			estimatedCost = conv.MustFloat64(updateSelection.TaskReward, 0) * conv.MustFloat64(updateSelection.SampleNum, 0)
		}
		estimatedCostToString, _ := conv.String(estimatedCost)
		updateSelection.EstimatedCost = estimatedCostToString
	*/
	// 3. 更新选品
	err = dao.ProjectDAO{}.UpdateProject(updateProject)
	if err != nil {
		return nil, err
	}
	// 4. 更新选品brief和示例（种草任务补充信息）
	if projectUpdateParam.ProjectBrief != nil {
		// 删除已有brief
		err = dao.ProjectBriefDao{}.DeleteSecBriefBySelectionId(project.ProjectId)
		if err != nil {
			return nil, err
		}
		// 插入新的brief
		for _, v := range projectUpdateParam.ProjectBrief {
			brief := entity.ProjectBrief{
				ProjectID: project.ProjectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectBriefDao{}.CreateProjectBrief(brief)
			if err != nil {
				return nil, err
			}
		}
	}

	if projectUpdateParam.ProjectMaterial != nil {
		// 删除已有示例
		err = dao.ProjectMaterialDao{}.DeleteProjectMaterialByProjectId(project.ProjectId)
		if err != nil {
			return nil, err
		}
		// 插入新的示例
		for _, v := range projectUpdateParam.ProjectMaterial {
			projectMaterial := entity.ProjectMaterial{
				ProjectID: project.ProjectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectMaterialDao{}.CreateProjectMaterial(projectMaterial)
			if err != nil {
				return nil, err
			}
		}
	}

	return &updateProject.ProjectId, nil
}

// 更新定向种草任务（招募要求、执行要求）
func (s ProjectService) UpdateProjectTarget(projectUpdateParam *vo.ProjectUpdateParam) (*string, error) {
	// 1. 检查该项目id有无种草任务
	projectID := projectUpdateParam.ProjectID
	project, err := dao.ProjectDAO{}.GetProjectById(projectID)
	if err != nil {
		return nil, err
	}
	if project == nil {
		return nil, errors.New("种草项目不存在")
	}
	println("更新定向种草任务的招募策略")
	// 更新定向种草任务的招募策略
	var totalRecruitNum int64
	var estimatedCost float64
	if projectUpdateParam.RecruitStrategys != nil {
		// 1. 删除已有的招募策略
		err = dao.RecruitStrategyDao{}.DeleteRecruitStrategyByProjectID(projectUpdateParam.ProjectID)
		if err != nil {
			return nil, err
		}
		// 2. 接收并创建新的招募策略
		if len(projectUpdateParam.RecruitStrategys) != 0 {
			var recruits []entity.RecruitStrategy
			for _, strategy := range projectUpdateParam.RecruitStrategys {
				if strategy.FeeForm == 2 {
					estimatedCost += float64(strategy.RecruitNumber) * strategy.Offer
				}
				recruitStrategy := entity.RecruitStrategy{
					FeeForm:       strategy.FeeForm,
					StrategyID:    strategy.StrategyID,
					FollowersLow:  strategy.FollowersLow,
					FollowersUp:   strategy.FollowersUp,
					RecruitNumber: strategy.RecruitNumber,
					ProjectID:     project.ProjectId,
					StrategyType:  1,
					ServiceRate:   project.ServiceChargeRate,
				}
				totalRecruitNum += strategy.RecruitNumber
				if strategy.FeeForm == 2 {
					recruitStrategy.Offer = strategy.Offer // 报价
				}
				recruits = append(recruits, recruitStrategy)
			}
			err = dao.RecruitStrategyDao{}.CreateRecruitStrategy(recruits)
			if err != nil {
				return nil, err
			}
		}
	}
	// 2. 数据准备
	// a) 查找关联商品信息
	product, err := dao.ProductDAO{}.GetProductByID(project.ProductID)
	if err != nil {
		return nil, err
	}
	productPhotos, err := dao.ProductPhotoDAO{}.GetProductPhotoByProductID(project.ProductID)
	productInfoToJson, _ := json.Marshal(product)
	productPhotosToJson, _ := json.Marshal(productPhotos)
	// d) 任务截止时间
	recruitDdl := time.Time{} //赋零值
	recruitDdl, _ = time.ParseInLocation("2006-01-02 15:04:05", projectUpdateParam.RecruitDdl, time.Local)
	//// f) 更新选品状态
	//if projectUpdateParam.ProjectStatus != 2 && projectUpdateParam.ProjectStatus != 8 {
	//	projectUpdateParam.ProjectStatus = 1
	//}
	t := time.Now()
	updateProject := entity.Project{
		//ProjectStatus:    projectUpdateParam.ProjectStatus,
		ProjectName:      projectUpdateParam.ProjectName,
		ProductID:        projectUpdateParam.ProductId,
		TalentType:       projectUpdateParam.TalentType,
		RecruitDdl:       recruitDdl,
		ProductSnap:      string(productInfoToJson),
		ProductPhotoSnap: string(productPhotosToJson),
		CreatedAt:        project.CreatedAt,
		UpdatedAt:        t,
		ProjectForm:      projectUpdateParam.ProjectForm,
		ContentType:      projectUpdateParam.ContentType,
		ProjectDetail:    projectUpdateParam.ProjectDetail,
		Tools:            projectUpdateParam.Tools,
	}
	//if projectUpdateParam.ProjectStatus == 2 {
	//	updateProject.SubmitAt = t
	//}
	// 合并传入参数和数据表中原记录，若传入参数字段值为空，则将字段赋值为原记录中值
	result := util.MergeStructValue(&updateProject, project)
	// 利用反射机制将interface类型转换为结构体类型
	v := reflect.ValueOf(&result).Elem()
	if v.Kind() == reflect.Struct {
		updateProject = v.Interface().(entity.Project)
		//fmt.Println(p)
	}
	// c) 计算预估成本（如果有）
	/*
		var estimatedCost float64
		if conv.MustInt(updateSelection.TaskMode, 0) == 1 {
			estimatedCost = conv.MustFloat64(updateSelection.TaskReward, 0) * conv.MustFloat64(updateSelection.SampleNum, 0)
		}
		estimatedCostToString, _ := conv.String(estimatedCost)
		updateSelection.EstimatedCost = estimatedCostToString
	*/
	// 3. 更新选品
	err = dao.ProjectDAO{}.UpdateProject(updateProject)
	if err != nil {
		return nil, err
	}
	// 4. 更新选品brief和示例（种草任务补充信息）
	if projectUpdateParam.ProjectBrief != nil {
		// 删除已有brief
		err = dao.ProjectBriefDao{}.DeleteSecBriefBySelectionId(project.ProjectId)
		if err != nil {
			return nil, err
		}
		// 插入新的brief
		for _, v := range projectUpdateParam.ProjectBrief {
			brief := entity.ProjectBrief{
				ProjectID: project.ProjectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectBriefDao{}.CreateProjectBrief(brief)
			if err != nil {
				return nil, err
			}
		}
	}
	if projectUpdateParam.ProjectMaterial != nil {
		// 删除已有示例
		err = dao.ProjectMaterialDao{}.DeleteProjectMaterialByProjectId(project.ProjectId)
		if err != nil {
			return nil, err
		}
		// 插入新的示例
		for _, v := range projectUpdateParam.ProjectMaterial {
			projectMaterial := entity.ProjectMaterial{
				ProjectID: project.ProjectId,
				FileUid:   v.FileUid,
				FileName:  v.Name,
				FileUrl:   v.FileUrl,
				CreatedAt: time.Now(),
				Type:      v.Type,
			}
			err = dao.ProjectMaterialDao{}.CreateProjectMaterial(projectMaterial)
			if err != nil {
				return nil, err
			}
		}
	}

	return &updateProject.ProjectId, nil
}

// 种草任务预览
func (s ProjectService) GetProjectDetail(projectId string) (*vo.ReProjectDetail, error) {
	reProjectDetail := vo.ReProjectDetail{}
	project, err := dao.ProjectDAO{}.GetProjectById(projectId)
	if err != nil {
		logrus.Errorf("[projectDB service] call GetProject error,err:%+v", err)
		return nil, err
	}
	// 系统信息
	reProjectDetail.ProjectId = projectId
	reProjectDetail.ProjectStatus = project.ProjectStatus
	reProjectDetail.ProjectPlatform = project.ProjectPlatform
	reProjectDetail.CreatedAt = project.CreatedAt.Format("2006-01-02 15:04:05")
	reProjectDetail.EstimatedCost = project.EstimatedCost
	reProjectDetail.ServiceChargeRate = project.ServiceChargeRate
	var creatorName, phone string
	if project.SubAccountId == 0 {
		enterprise, err := dao.EnterpriseDao{}.GetEnterprise(project.EnterpriseID)
		if err == nil && enterprise != nil {
			creatorName = enterprise.BusinessName
			phone, err = dao.UserDao{}.GetPhoneByUserId(enterprise.UserId)
		}
	} else {
		subAccount, err := dao.SubAccountDao{}.GetSubAccount(project.SubAccountId)
		if err == nil && subAccount != nil {
			creatorName = subAccount.SubAccountName
			phone, err = dao.UserDao{}.GetPhoneByUserId(subAccount.UserId)
		}
	}
	reProjectDetail.CreatorName = creatorName
	reProjectDetail.Phone = phone
	// 关联商品
	var reProduct vo.ReProductPreview
	product, err := dao.ProductDAO{}.GetProductByID(project.ProductID)
	if err == nil {
		photoUrl, e := dao.ProductPhotoDAO{}.GetMainPhotoByProductID(product.ProductID)
		if e != nil {
			photoUrl = ""
		}
		reProduct = vo.ReProductPreview{
			ProductID:       product.ProductID,
			ProductName:     product.ProductName,
			ProductType:     product.ProductType,
			ProductCategory: product.ProductCategory,
			ProductPrice:    product.ProductPrice,
			ProductDetail:   product.ProductDetail,
			CreatedAt:       product.CreatedAt.Format("2006-01-02 15:04:05"),
			PhotoUrl:        photoUrl,
		}
	}
	reProjectDetail.ProductInfo = &reProduct
	// 招募要求
	reProjectDetail.TalentType = project.TalentType
	reProjectDetail.RecruitDdl = project.RecruitDdl.Format("2006-01-02 15:04:05")
	reProjectDetail.ProjectForm = project.ProjectForm
	reProjectDetail.ContentType = project.ContentType
	reProjectDetail.ProjectDetail = project.ProjectDetail
	var recruitStrategysPreviews []*vo.RecruitStrategyPreview
	recruitStrategys, err := dao.RecruitStrategyDao{}.GetRecruitStrategyByProjectId(projectId)
	if err != nil {
		logrus.Errorf("[projectDB service] call GetRecruitStrategy error,err:%+v", err)
		return nil, err
	}
	for _, recruitStrategy := range recruitStrategys {
		recruitStrategysPreview := &vo.RecruitStrategyPreview{
			StrategyId:     recruitStrategy.StrategyID,
			FeeForm:        recruitStrategy.FeeForm,
			FollowersLow:   recruitStrategy.FollowersLow,
			FollowersUp:    recruitStrategy.FollowersUp,
			RecruitNumber:  recruitStrategy.RecruitNumber,
			Offer:          recruitStrategy.Offer,
			TOffer:         recruitStrategy.TOffer,
			ServiceCharge:  recruitStrategy.ServiceCharge,
			SelectedNumber: recruitStrategy.SelectedNumber,
			TotalOffer:     recruitStrategy.TotalOffer,
		}
		recruitStrategysPreviews = append(recruitStrategysPreviews, recruitStrategysPreview)
	}
	reProjectDetail.RecruitStrategys = recruitStrategysPreviews
	// 执行要求
	projectBriefInfos, err := dao.ProjectBriefDao{}.GetProjectBriefInfo(projectId)
	if err != nil {
		logrus.Errorf("[projectDB service] call GetProjectBriefInfo error,err:%+v", err)
		return nil, err
	}
	projectMaterials, err := dao.ProjectMaterialDao{}.GetProjectMaterialInfo(projectId)
	if err != nil {
		logrus.Errorf("[projectDB service] call GetprojectMaterialInfo error,err:%+v", err)
		return nil, err
	}
	reProjectDetail.ProjectBriefs = projectBriefInfos
	reProjectDetail.ProjectMaterials = projectMaterials
	reProjectDetail.Tools = project.Tools

	return &reProjectDetail, nil
}

// 种草提交审核
func (s ProjectService) ProjectToReview(projectUpdateParam *vo.ProjectUpdateParam) (*string, error) {
	projectId := projectUpdateParam.ProjectID

	project, err := dao.ProjectDAO{}.GetProjectById(projectId)
	if err != nil {
		logrus.Errorf("[projectInfoDB service] call GetProject error,err:%+v", err)
		return nil, err
	}

	projectName := project.ProjectName     // 任务标题
	projectDetail := project.ProjectDetail // 任务详情
	product, err := dao.ProductDAO{}.GetProductByID(project.ProductID)
	if err != nil {
		return nil, err
	}
	productName := product.ProductName     // 商品标题
	productDetail := product.ProductDetail // 卖点总结
	mainPhoto, err1 := dao.ProductPhotoDAO{}.GetMainPhotoByProductID(project.ProductID)
	if err1 != nil {
		return nil, err1
	}
	var images []string
	var videos []string
	var videoJobIds []string
	var documents []string
	var documentJobIds []string
	reviewService := review_service.GetConfig()

	productPhotos, err2 := dao.ProductPhotoDAO{}.GetProductPhotoByProductID(project.ProductID)
	if err2 != nil {
		return nil, err2
	}
	for _, productPhoto := range productPhotos {
		if productPhoto.Symbol == 2 || productPhoto.Symbol == 4 {
			images = append(images, productPhoto.PhotoUrl)
		} else if productPhoto.Symbol == 3 || productPhoto.Symbol == 5 {
			var videoJobId *string
			var reviewErr error
			i := 10
			for {
				videoJobId, reviewErr = reviewService.CheckVideo(productPhoto.PhotoUrl)
				if reviewErr == nil || i == 0 {
					break
				}
				i -= 1
			}
			if reviewErr != nil {
				return nil, reviewErr
			}
			videos = append(videos, productPhoto.PhotoUrl)
			videoJobIds = append(videoJobIds, *videoJobId)
		}
	}

	projectBriefInfos, err := dao.ProjectBriefDao{}.GetProjectBriefInfo(projectId)
	if err != nil {
		return nil, err
	}
	for _, projectBriefInfo := range projectBriefInfos {
		if projectBriefInfo.Type == 1 {
			images = append(images, projectBriefInfo.FileUrl)
		} else if projectBriefInfo.Type == 2 {
			var documentJobId *string
			var reviewErr error
			i := 10
			fileType := "pdf"
			parts := strings.Split(projectBriefInfo.FileName, ".")
			if len(parts) > 1 {
				fileType = parts[len(parts)-1]
			}
			for {
				documentJobId, reviewErr = reviewService.CheckDocument(projectBriefInfo.FileUrl, fileType)
				if reviewErr == nil || i == 0 {
					break
				}
				i -= 1
			}
			if reviewErr != nil {
				return nil, reviewErr
			}
			documents = append(documents, projectBriefInfo.FileUrl)
			documentJobIds = append(documentJobIds, *documentJobId)
		}
	}
	projectMaterials, err := dao.ProjectMaterialDao{}.GetProjectMaterialInfo(projectId)
	if err != nil {
		return nil, err
	}
	for _, projectMaterial := range projectMaterials {
		if projectMaterial.Type == 1 {
			images = append(images, projectMaterial.FileUrl)
		} else if projectMaterial.Type == 2 {
			var videoJobId *string
			var reviewErr error
			i := 10
			for {
				videoJobId, reviewErr = reviewService.CheckVideo(projectMaterial.FileUrl)
				if reviewErr == nil || i == 0 {
					break
				}
				i -= 1
			}
			if reviewErr != nil {
				return nil, reviewErr
			}
			videos = append(videos, projectMaterial.FileUrl)
			videoJobIds = append(videoJobIds, *videoJobId)
		}
	}

	newReviewProject := &entity.ReviewProject{
		ProjectID:      projectId,
		TaskName:       projectName,
		TaskDetail:     projectDetail,
		ProductName:    productName,
		ProductDetail:  productDetail,
		MainPhoto:      mainPhoto,
		Images:         strings.Join(images, ","),
		Videos:         strings.Join(videos, ","),
		Documents:      strings.Join(documents, ","),
		VideoJobIds:    strings.Join(videoJobIds, ","),
		DocumentJobIds: strings.Join(documentJobIds, ","),
		Status:         1,
	}
	err5 := dao.ProjectReviewDao{}.Create(newReviewProject)
	if err5 != nil {
		return nil, err5
	}

	t := time.Now()
	updateProject := entity.Project{
		ProjectId:     projectId,
		ProjectStatus: 2,
		UpdatedAt:     t,
	}
	err6 := dao.ProjectDAO{}.UpdateProject(updateProject)
	if err6 != nil {
		return nil, err
	}
	return &projectId, nil
}

// 种草任务列表
func (s ProjectService) GetProjectTaskList(param *vo.ProjectSearchParam) (vo.ResultVO, error) {
	if param.Page == 0 {
		param.Page = 1
	}
	if param.PageSize == 0 {
		param.PageSize = 10
	}
	var result vo.ResultVO
	reProjectTaskPreviews, total, err := (&dao.ProjectDAO{}).GetProjectPreviews(param)
	if err != nil {
		return result, err
	}
	for i := range reProjectTaskPreviews {
		var creatorName string
		var productName string
		var productPrice float64
		var mainImage string
		if reProjectTaskPreviews[i].SubAccountId == 0 {
			enterprise, err := dao.EnterpriseDao{}.GetEnterprise(reProjectTaskPreviews[i].EnterpriseId)
			if err == nil && enterprise != nil {
				creatorName = enterprise.BusinessName
			}
		} else {
			subAccount, err := dao.SubAccountDao{}.GetSubAccount(reProjectTaskPreviews[i].SubAccountId)
			if err == nil && subAccount != nil {
				creatorName = subAccount.SubAccountName
			}
		}
		product, err := dao.ProductDAO{}.GetProductByID(reProjectTaskPreviews[i].ProductId)
		if err == nil && product != nil {
			productName = product.ProductName
			productPrice = product.ProductPrice
		}
		mainImage, err = dao.ProductPhotoDAO{}.GetMainPhotoByProductID(reProjectTaskPreviews[i].ProductId)
		reProjectTaskPreviews[i].CreatorName = creatorName
		reProjectTaskPreviews[i].ProductName = productName
		reProjectTaskPreviews[i].ProductPrice = productPrice
		reProjectTaskPreviews[i].MainImage = mainImage
	}
	result = vo.ResultVO{
		Page:     param.Page,
		PageSize: param.PageSize,
		Total:    total,
		Data:     reProjectTaskPreviews,
	}
	return result, nil
}

// 删除种草任务
func (s ProjectService) DeleteProject(projectId string) (*string, error) {
	res, err := dao.ProjectDAO{}.DeleteProject(projectId)
	if err != nil {
		logrus.Errorf("[projectDB service] call DeleteProject error,err:%+v", err)
		return res, err
	}
	return res, nil
}

// 草稿箱——品牌种草
func (s ProjectService) GetProjectDraftList(param *vo.ProjectDraftParam) (vo.ResultVO, error) {
	if param.Page == 0 {
		param.Page = 1
	}
	if param.PageSize == 0 {
		param.PageSize = 10
	}
	var result vo.ResultVO
	reProjectTaskPreviews, total, err := (&dao.ProjectDAO{}).GetProjectDraftList(param)
	if err != nil {
		return result, err
	}
	for i := range reProjectTaskPreviews {
		var creatorName string
		var productName string
		var productPrice float64
		var mainImage string
		if reProjectTaskPreviews[i].SubAccountId == 0 {
			enterprise, err := dao.EnterpriseDao{}.GetEnterprise(reProjectTaskPreviews[i].EnterpriseId)
			if err == nil && enterprise != nil {
				creatorName = enterprise.BusinessName
			}
		} else {
			subAccount, err := dao.SubAccountDao{}.GetSubAccount(reProjectTaskPreviews[i].SubAccountId)
			if err == nil && subAccount != nil {
				creatorName = subAccount.SubAccountName
			}
		}
		product, err := dao.ProductDAO{}.GetProductByID(reProjectTaskPreviews[i].ProductId)
		if err == nil && product != nil {
			productName = product.ProductName
			productPrice = product.ProductPrice
		}
		mainImage, err = dao.ProductPhotoDAO{}.GetMainPhotoByProductID(reProjectTaskPreviews[i].ProductId)
		reProjectTaskPreviews[i].CreatorName = creatorName
		reProjectTaskPreviews[i].ProductName = productName
		reProjectTaskPreviews[i].ProductPrice = productPrice
		reProjectTaskPreviews[i].MainImage = mainImage
	}
	result = vo.ResultVO{
		Page:     param.Page,
		PageSize: param.PageSize,
		Total:    total,
		Data:     reProjectTaskPreviews,
	}
	return result, nil
}