youngee_mc_api/app/service/youngee_task_service/project_info.go

package youngee_task_service

import (
	"fmt"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
	"math"
	"sort"
	"strings"
	"youngmini_server/app/dao"
	"youngmini_server/app/model/youngee_talent_model"
	"youngmini_server/app/service/youngee_talent_service"
	"youngmini_server/app/utils"

	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/net/ghttp"
)

type projectStatus int

const (
	projectStatusCreating = iota + 1
	projectStatusReviewing
	projectStatusReviewed
	projectStatusRecruiting
	projectStatusRecruited
	projectStatusPaying
	projectStatusPaid
	projectStatusInvalid
	projectStatusInProgress
	projectStatusClosed
)

// 获取项目信息列表service
func GetProjectInfoList(r *ghttp.Request) *TalentHttpResult {
	pageIndex := r.GetQueryInt("idx", -1)
	cntPerPage := r.GetQueryInt("cnt", -1)
	//组合筛选
	platform := r.Get("platform", nil)            //抖音、快手、红Book、B站、微博
	projectForm := r.Get("projectform", nil)      //1.商品寄拍、3.虚拟产品评测、2.素材分发
	contentType := r.Get("contenttype", nil)      //图文形式、视频形式
	createTime := r.Get("createTime", nil)        //任务上线时间
	categoryForm := r.Get("productCategory", nil) //商品类目 智能家居、食品饮料等20种

	//排根据浏览量排序
	viewOrder := r.GetQueryInt("pageViewOrder", -1) //根据哪个字段排序

	//仅稿费”+“稿费+赠品"。这个在recruit表中，得到列表之后进行排序
	feeForm := r.GetInt("feeform", 0)

	searchValue := r.Get("searchvalue", nil)
	if pageIndex == -1 || cntPerPage == -1 || cntPerPage == 0 {
		return &TalentHttpResult{Code: -1, Msg: "参数错误"}
	}

	// 构造查询的条件
	startId := pageIndex * cntPerPage
	// whereStr := fmt.Sprintf("(project_status >= %d and project_status <> %d and project_type = 1)", projectStatusRecruiting, projectStatusInvalid)
	whereStr := fmt.Sprintf("project_status >= %d and fail_reason <> 2 and project_type = 1", projectStatusRecruiting)
	// 处理 平台类型 project_platform
	if platform != nil {
		whereStr += " and project_platform = " + platform.(string)
	}
	//处理 内容类型
	if contentType != nil {
		whereStr += " and content_type = " + contentType.(string)
	}

	// 处理 创建时间
	if createTime != nil {
		switch createTime.(string) {
		case "1": // 近7天
			whereStr += " AND created_at >= (NOW() - INTERVAL 7 DAY)"
		case "2": // 近30天
			whereStr += " AND created_at >= (NOW() - INTERVAL 30 DAY)"
		case "3": // 近90天
			whereStr += " AND created_at >= (NOW() - INTERVAL 90 DAY)"
		default:
			// 无效的过滤条件，跳过
			return &TalentHttpResult{
				Code: -2,
				Msg:  "无效的创建时间过滤条件",
			}
		}
	}

	// 处理 项目形式
	if projectForm != nil {
		whereStr += " and project_form = " + projectForm.(string)
	}
	// 处理 商品类型
	if categoryForm != nil {
		whereStr += " and product_category = '" + categoryForm.(string) + "'"
	}

	// 处理搜索条件
	if searchValue != nil {
		whereStr += " and project_name like '%" + searchValue.(string) + "%'"
	}

	fmt.Println("query afterAll--->:", whereStr)

	// 判断请求页面是否超过最大页面
	c, err := g.DB().Model(dao.ProjectInfo.Table).Fields("project_id").Where(whereStr).Count()
	fmt.Println("c---->", c)
	if err != nil {
		return &TalentHttpResult{Code: -4, Msg: "查询数据库失败", Data: err.Error()}
	}

	maxPage := c / cntPerPage
	if c%cntPerPage > 0 {
		maxPage += 1
	}
	var projectInfoList = youngee_talent_model.ProjectInfoList{}
	// 查询数据库
	err = g.DB().Model("project_info").WithAll().Where(whereStr).
		Order("project_status ASC,recruit_ddl DESC").Limit(startId, cntPerPage).Scan(&projectInfoList.ProjectInfos)
	if err != nil {
		return &TalentHttpResult{Code: -6, Msg: "查询数据库失败"}
	}
	for _, project := range projectInfoList.ProjectInfos {
		fmt.Println("ids---->", project.ProjectId)
	}

	// 遍历projectList
	for i, project := range projectInfoList.ProjectInfos {
		fmt.Println("project.EnterpriseId---", project.EnterpriseId)
		//处理浏览量
		projectViewKey := "project:view:" + gconv.String(project.ProjectId)
		//redis中取浏览量 返回的是gvar.Var类型。 不存咋则为nil。经过viewCount.Int变成0
		viewCount, err := g.Redis().DoVar("GET", projectViewKey)
		if err != nil {
			glog.Error(err)
			return &TalentHttpResult{Code: 0, Msg: "Redis error"}
		}
		projectInfoList.ProjectInfos[i].WatchedNum = viewCount.Int()

		// 统计 RecruitStrategys 数组中的最低粉丝量和最高粉丝量
		var minFollowers, maxFollowers int
		// 初始值可以设为极大/极小值
		minFollowers = math.MaxInt32
		maxFollowers = math.MinInt32
		var totalRecruitNum int
		// 遍历 RecruitStrategys，找出最低粉丝量和最高粉丝量,以及总招募任务
		for _, strategy := range project.RecruitStrategys {
			totalRecruitNum += strategy.RecruitNumber
			if strategy.FollowersLow < minFollowers {
				minFollowers = strategy.FollowersLow
			}
			if strategy.FollowersUp > maxFollowers {
				maxFollowers = strategy.FollowersUp
			}
		}

		// 打印最低粉丝量和最高粉丝量
		fmt.Printf("ProjectId: %d, MinFollowers: %d, MaxFollowers: %d\n", project.ProjectId, minFollowers, maxFollowers)

		// 如果需要，可以将这些值保存到 ProjectInfo 中，供后续使用
		projectInfoList.ProjectInfos[i].MinFollowers = minFollowers
		projectInfoList.ProjectInfos[i].MaxFollowers = maxFollowers
		projectInfoList.ProjectInfos[i].AllRecruitNum = totalRecruitNum
		//稿费的展示情况
		allFeeFormNoFee := true // 假设都是无费置换
		var hasSelfPrice bool
		var minOffer, maxOffer float64

		for _, strategy := range project.RecruitStrategys {
			if strategy.FeeForm != 1 { // 如果存在非无费置换的策略
				allFeeFormNoFee = false
			}
			if strategy.FeeForm == 3 { // 存在自报价
				hasSelfPrice = true
			}
			if strategy.FeeForm == 2 { // 一口价策略
				if strategy.TOffer < minOffer || minOffer == 0 {
					minOffer = strategy.TOffer
				}
				if strategy.TOffer > maxOffer {
					maxOffer = strategy.TOffer
				}
			}
		}

		// 根据判断结果设置 IsShowOffer 和 HaveSelfPrice
		if allFeeFormNoFee {
			project.IsShowOffer = 2 // 不展示稿费
		} else {
			project.IsShowOffer = 1 // 展示稿费
			if hasSelfPrice {
				project.HaveSelfOffer = 1 //存在自报价
			} else {
				project.HaveSelfOffer = 2 //存在自报价
			}
			projectInfoList.ProjectInfos[i].MaxOffer = maxOffer
			projectInfoList.ProjectInfos[i].MinOffer = minOffer
		}
	}

	// 根据 WatchedNum 从高到低排序
	if viewOrder != -1 {
		sort.Slice(projectInfoList.ProjectInfos, func(i, j int) bool {
			return projectInfoList.ProjectInfos[i].WatchedNum > projectInfoList.ProjectInfos[j].WatchedNum
		})
	}

	projectInfoList.MaxPage = maxPage
	var filteredProjects []*youngee_talent_model.ProjectInfo
	//筛选出“仅稿费”+“稿费+赠品”任务，
	//只要策略中有 无费置换 之外的fee_form就是有稿费，projectform是 商品寄拍 和 虚拟产品测评 ，就是有赠品
	if feeForm != 0 {
		for _, project := range projectInfoList.ProjectInfos {
			// 条件1：筛选出所有 project_form 为 1 或 3 的项目
			if project.ProjectForm == 1 || project.ProjectForm == 3 {
				filteredProjects = append(filteredProjects, project)
				continue // 如果满足条件1，直接跳过后续条件判断
			}

			// 条件2：RecruitStrategy 中存在 fee_form 不等于 1 的数据
			for _, strategy := range project.RecruitStrategys {
				if strategy.FeeForm != 1 {
					filteredProjects = append(filteredProjects, project)
					break // 找到符合条件的策略，跳出当前循环，避免重复添加
				}
			}
		}
		projectInfoList.ProjectInfos = filteredProjects

	}

	return &TalentHttpResult{Code: 0, Msg: "success", Data: projectInfoList}
}

func getViewNum(projectViewKey string, userViewedKey string) int {
	// 在redis中增加浏览量
	viewed, err := g.Redis().DoVar("GET", userViewedKey)
	if err != nil {
		glog.Error(err)
		return 0
	}
	if viewed.IsNil() {
		_, err = g.Redis().Do("INCR", projectViewKey)
		if err != nil {
			glog.Error(err)
			return 0
		}
		_, err = g.Redis().Do("SET", userViewedKey, true)
		if err != nil {
			glog.Error(err)
			return 0
		}
	}
	viewNum, err := g.Redis().DoVar("GET", projectViewKey)
	if err != nil {
		fmt.Println("获取浏览量失败")
		return 0
	}
	return viewNum.Int()
}

//
//// 获取单个项目详情service
//func GetProjectDetail(r *ghttp.Request) *TalentHttpResult {
//	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
//	//列表页面进入
//	pid := r.GetQueryString("project_id", "")
//
//	//扫码进入：1. 商家端的码 2. 服务商的码
//	s_project_id := r.GetQueryInt("s_project_id", 0)
//	var projectViewKey = ""
//	var userViewedKey = ""
//	//达人类型转string
//	var talentCategory []*youngee_talent_model.YounggeeTalentCategory
//	err := g.DB().Model("younggee_talent_category").Scan(&talentCategory)
//	if err != nil {
//		return &TalentHttpResult{Code: -1, Msg: err.Error()}
//	}
//	// 创建一个数字到汉字的映射
//	categoryMap := make(map[string]string)
//	for _, category := range talentCategory {
//		categoryMap[fmt.Sprint(category.Id)] = category.Category
//	}
//
//	if s_project_id != 0 { //服务商
//		var SProjectDetail *youngee_talent_model.ProjectInfoSupplier
//		err := g.DB().Model("younggee_s_project_info").WithAll().Where("s_project_id", s_project_id).Scan(&SProjectDetail)
//		if err != nil {
//			return &TalentHttpResult{Code: -3, Msg: err.Error()}
//		}
//
//		//浏览量统计
//		projectViewKey = "project:view:s_" + gconv.String(s_project_id)
//		userViewedKey = "user:viewed:" + gconv.String(tid) + ":s_" + gconv.String(s_project_id)
//		viewNum := getViewNum(projectViewKey, userViewedKey)
//		SProjectDetail.ProjectDetail.ViewNum = viewNum
//		//浏览历史
//		currentDate := gtime.Now().Format("Ymd")
//		redisBrowseKey := fmt.Sprintf("browseProject:%s:%s", currentDate, tid)
//		fmt.Println("redis浏览记录的key为——————————", redisBrowseKey)
//		// 将 project_id:s_project_id  添加到 Redis 中的 SET 中,因为project_id可以对应多个s_project_id(被多个服务商接手)
//		// 组合 pid 和 s_project_id
//		browseItem := fmt.Sprintf("%s:%s", pid, s_project_id)
//		_, err = g.Redis().Do("SADD", redisBrowseKey, browseItem)
//		if err != nil {
//			return &TalentHttpResult{Code: 0, Msg: "Redis 存浏览历史数据失败"}
//		}
//		_, err = g.Redis().Do("EXPIRE", redisBrowseKey, 7*24*60*60) // 7 天的秒数
//		if err != nil {
//			return &TalentHttpResult{Code: 0, Msg: "Redis 设置过期时间失败"}
//		}
//
//		//达人类型转化
//		talentTypes := strings.Split(SProjectDetail.ProjectDetail.TalentType, ",")
//		var result []string
//		for _, t := range talentTypes {
//			if name, ok := categoryMap[t]; ok {
//				result = append(result, name)
//			}
//		}
//		resultStr := strings.Join(result, ",")
//		SProjectDetail.ProjectDetail.TalentType = resultStr
//
//		//违约
//		if SProjectDetail.ProjectType == 1 { //公开任务
//			one, err := g.DB().Model("info_auto_default_handle").Where("auto_default_id=?", SProjectDetail.ProjectDetail.AutoDefaultId).One()
//			if err != nil {
//				return &TalentHttpResult{Code: 0, Msg: err.Error()}
//			} else {
//				SProjectDetail.ProjectDetail.DraftBreakPercent = one["sketch_replace_not_upload"].Int()
//				SProjectDetail.ProjectDetail.LinkBreakPercent = one["link_replace_not_upload"].Int()
//				SProjectDetail.ProjectDetail.DataBreakPercent = one["data_replace_not_upload"].Int()
//			}
//			one2, err2 := g.DB().Model("info_auto_task").Where("auto_task_id=?", SProjectDetail.ProjectDetail.AutoTaskId).One()
//			if err2 != nil {
//				return &TalentHttpResult{Code: 0, Msg: "one2 is nil"}
//			} else {
//				SProjectDetail.ProjectDetail.DraftBreakTime = one2["draft_default"].Int()
//				SProjectDetail.ProjectDetail.LinkBreakTime = one2["link_breach"].Int()
//				SProjectDetail.ProjectDetail.DataBreakTime = one2["case_close_default"].Int()
//			}
//		}
//
//		//填充收藏信息
//		collectionInfo := []youngee_talent_model.ProjectCollection{}
//		err = g.DB().Model("younggee_project_collect_info").Where("project_id=? and talent_id = ?", SProjectDetail.ProjectID, tid).Scan(&collectionInfo)
//		if err != nil {
//			return &TalentHttpResult{Code: -1, Msg: err.Error()}
//		}
//		if len(collectionInfo) != 0 && collectionInfo[0].Deleted == 0 {
//			SProjectDetail.ProjectDetail.IsCollected = 1
//		} else {
//			SProjectDetail.ProjectDetail.IsCollected = 0
//		}
//		return &TalentHttpResult{Code: 0, Msg: "success", Data: SProjectDetail}
//
//	} else { //商家
//		var ProjectDetail *youngee_talent_model.ProjectDetail
//		err := g.DB().Model("project_info").WithAll().Where("project_id", pid).Scan(&ProjectDetail)
//		if err != nil {
//			return &TalentHttpResult{Code: -3, Msg: err.Error()}
//		}
//
//		//浏览量统计
//		projectViewKey = "project:view:" + pid
//		userViewedKey = "user:viewed:" + gconv.String(tid) + ":" + pid
//		viewNum := getViewNum(projectViewKey, userViewedKey)
//		ProjectDetail.ViewNum = viewNum
//		//浏览历史
//		currentDate := gtime.Now().Format("Ymd")
//		redisBrowseKey := fmt.Sprintf("browseProject:%s:%s", currentDate, tid)
//		fmt.Println("redis浏览记录的key为——————————", redisBrowseKey)
//		// 将 project_id:s_project_id  添加到 Redis 中的 SET 中,因为project_id可以对应多个s_project_id(被多个服务商接手)
//		// 组合 pid 和 s_project_id
//		browseItem := fmt.Sprintf("%s:%s", pid, s_project_id)
//		_, err = g.Redis().Do("SADD", redisBrowseKey, browseItem)
//		if err != nil {
//			return &TalentHttpResult{Code: 0, Msg: "Redis 存浏览历史数据失败"}
//		}
//		_, err = g.Redis().Do("EXPIRE", redisBrowseKey, 7*24*60*60) // 7 天的秒数
//		if err != nil {
//			return &TalentHttpResult{Code: 0, Msg: "Redis 设置过期时间失败"}
//		}
//
//		//达人类型转化
//		talentTypes := strings.Split(ProjectDetail.TalentType, ",")
//		var result []string
//		for _, t := range talentTypes {
//			if name, ok := categoryMap[t]; ok {
//				result = append(result, name)
//			}
//		}
//		resultStr := strings.Join(result, ",")
//		ProjectDetail.TalentType = resultStr
//
//		//违约
//		if ProjectDetail.ProjectType == 1 { //公开任务
//			one, err := g.DB().Model("info_auto_default_handle").Where("auto_default_id=?", ProjectDetail.AutoDefaultId).One()
//			if err != nil {
//				return &TalentHttpResult{Code: 0, Msg: err.Error()}
//			} else {
//				ProjectDetail.DraftBreakPercent = one["sketch_replace_not_upload"].Int()
//				ProjectDetail.LinkBreakPercent = one["link_replace_not_upload"].Int()
//				ProjectDetail.DataBreakPercent = one["data_replace_not_upload"].Int()
//			}
//			one2, err2 := g.DB().Model("info_auto_task").Where("auto_task_id=?", ProjectDetail.AutoTaskId).One()
//			if err2 != nil {
//				return &TalentHttpResult{Code: 0, Msg: "one2 is nil"}
//			} else {
//				ProjectDetail.DraftBreakTime = one2["draft_default"].Int()
//				ProjectDetail.LinkBreakTime = one2["link_breach"].Int()
//				ProjectDetail.DataBreakTime = one2["case_close_default"].Int()
//			}
//		}
//
//		//填充收藏信息
//		collectionInfo := []youngee_talent_model.ProjectCollection{}
//		err = g.DB().Model("younggee_project_collect_info").Where("project_id=? and talent_id = ?", pid, tid).Scan(&collectionInfo)
//		if err != nil {
//			return &TalentHttpResult{Code: -1, Msg: err.Error()}
//		}
//		if len(collectionInfo) != 0 && collectionInfo[0].Deleted == 0 { //有数据  且   没取消收藏
//			ProjectDetail.IsCollected = 1
//		} else {
//			ProjectDetail.IsCollected = 0 //没数据  或  有数据但取消了收藏
//		}
//		return &TalentHttpResult{Code: 0, Msg: "success", Data: ProjectDetail}
//	}
//
//}

// 获取单个项目详情service
func GetProjectDetail(r *ghttp.Request) *TalentHttpResult {
	g.Log().Info("This is an GetProjectDetail message")
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	//列表页面进入
	pid := r.GetQueryString("project_id", "")

	//扫码进入：1. 商家端的码 2. 服务商的码
	s_project_id := r.GetQueryInt("s_project_id", 0)

	// Redis key
	projectViewKey := "project:view:" + pid
	userViewedKey := "user:viewed:" + tid + ":" + pid

	//在redis中增加浏览量
	// Check if the user has already viewed the product
	//DoVar方便进行类型转化
	viewed, err := g.Redis().DoVar("GET", userViewedKey)
	if err != nil {
		glog.Error(err)
		return &TalentHttpResult{Code: 0, Msg: "Redis error"}
	}
	var ProjectDetail *youngee_talent_model.ProjectDetail
	//TalentType转成String
	var talentCategory []*youngee_talent_model.YounggeeTalentCategory
	err = g.DB().Model("younggee_talent_category").Scan(&talentCategory)
	if err != nil {
		// 处理查询错误
		return &TalentHttpResult{Code: -1, Msg: err.Error()}
	}
	// 创建一个数字到汉字的映射
	categoryMap := make(map[string]string)
	for _, category := range talentCategory {
		categoryMap[fmt.Sprint(category.Id)] = category.Category
	}
	if s_project_id != 0 { //服务商
		var SProjectDetail *youngee_talent_model.ProjectInfoSupplier
		err = g.DB().Model("younggee_s_project_info").WithAll().Where("s_project_id", s_project_id).Scan(&SProjectDetail)
		if err != nil {
			return &TalentHttpResult{Code: -3, Msg: err.Error()}
		}
		pid = SProjectDetail.ProjectID //获取商家端的pid
	}
	err = g.DB().Model("project_info").WithAll().Where("project_id", pid).Scan(&ProjectDetail)
	if err != nil {
		return &TalentHttpResult{Code: -3, Msg: err.Error()}
	}

	// 将 TalentType 转换为逗号隔开的汉字字符串
	talentTypes := strings.Split(ProjectDetail.TalentType, ",")
	var result []string
	for _, t := range talentTypes {
		if name, ok := categoryMap[t]; ok {
			result = append(result, name)
		}
	}
	// 将结果拼接成逗号隔开的字符串
	resultStr := strings.Join(result, ",")
	ProjectDetail.TalentType = resultStr

	if ProjectDetail.ProjectType == 1 { //公开任务才有违约信息
		//各阶段扣款比例
		one, err := g.DB().Model("info_auto_default_handle").Where("auto_default_id=?", ProjectDetail.AutoDefaultId).One()
		if err != nil {
			return &TalentHttpResult{Code: 0, Msg: err.Error()}
		} else {
			ProjectDetail.DraftBreakPercent = one["sketch_replace_not_upload"].Int()
			ProjectDetail.LinkBreakPercent = one["link_replace_not_upload"].Int()
			ProjectDetail.DataBreakPercent = one["data_replace_not_upload"].Int()
		}
		//各阶段扣款时间
		one2, err2 := g.DB().Model("info_auto_task").Where("auto_task_id=?", ProjectDetail.AutoTaskId).One()
		if err2 != nil {
			return &TalentHttpResult{Code: 0, Msg: "one2 is nil"}
		} else {
			ProjectDetail.DraftBreakTime = one2["draft_default"].Int()
			ProjectDetail.LinkBreakTime = one2["link_breach"].Int()
			ProjectDetail.DataBreakTime = one2["case_close_default"].Int()
		}
	}

	if viewed.IsNil() {
		// User hasn't viewed this product yet, increase the view count
		_, err = g.Redis().Do("INCR", projectViewKey)

		if err != nil {
			glog.Error(err)
			return &TalentHttpResult{Code: 0, Msg: "Redis error"}
		}
		// Mark the product as viewed by this user
		_, err = g.Redis().Do("SET", userViewedKey, true)
		if err != nil {
			glog.Error(err)
			return &TalentHttpResult{Code: 0, Msg: "Redis error"}
		}
	}
	viewNum, err := g.Redis().DoVar("GET", projectViewKey)
	if err != nil {
		fmt.Println("获取浏览量失败")
	}
	ProjectDetail.ViewNum = viewNum.Int()
	var totalRecruitNum int
	for _, strategy := range ProjectDetail.RecruitStrategy {
		totalRecruitNum += strategy.RecruitNumber
	}
	ProjectDetail.AllRecruitNum = totalRecruitNum

	//浏览历史
	currentDate := gtime.Now().Format("Ymd")
	// 设计 Redis Key
	redisBrowseKey := fmt.Sprintf("browseProject:%s:%s", currentDate, tid)
	fmt.Println("redis浏览记录的key为——————————", redisBrowseKey)
	// 将 project_id:s_project_id  添加到 Redis 中的 SET 中,因为project_id可以对应多个s_project_id(被多个服务商接手)
	// 组合 pid 和 s_project_id
	browseItem := fmt.Sprintf("%s:%s", pid, s_project_id)
	_, err = g.Redis().Do("SADD", redisBrowseKey, browseItem)
	if err != nil {
		return &TalentHttpResult{Code: 0, Msg: "Redis 存浏览历史数据失败"}
	}
	// 设置 Key 的过期时间为 7 天
	_, err = g.Redis().Do("EXPIRE", redisBrowseKey, 7*24*60*60) // 7 天的秒数
	if err != nil {
		return &TalentHttpResult{Code: 0, Msg: "Redis 设置过期时间失败"}
	}

	//填充收藏信息
	collectionInfo := []youngee_talent_model.ProjectCollection{}
	err = g.DB().Model("younggee_project_collect_info").Where("project_id=? and talent_id = ?", pid, tid).Scan(&collectionInfo)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: err.Error()}
	}
	//已被收藏
	if len(collectionInfo) != 0 && collectionInfo[0].Deleted == 0 { //有数据  且   没取消收藏
		ProjectDetail.IsCollected = 1
	} else {
		ProjectDetail.IsCollected = 0 //没数据  或  有数据但取消了收藏
	}
	//返回的data作为收藏接口的is_collect字段传入
	if err != nil {
		return &TalentHttpResult{Code: -3, Msg: err.Error()}
	}
	//奖励形式
	ProjectDetail.IsShowDraft = 0 // 默认不展示稿费
	ProjectDetail.HaveGift = 0    // 默认没有赠品

	for _, strategy := range ProjectDetail.RecruitStrategy {
		if strategy.FeeForm != 1 { // 如果存在非无费置换的策略
			ProjectDetail.IsShowDraft = 1
			break // 找到一个非无费置换的策略就可以了
		}
	}
	if ProjectDetail.ProjectForm != 2 { // 商品寄拍 或 虚拟产品测评【有赠品】 素材分发没有
		ProjectDetail.HaveGift = 1 // 有赠品
	}

	// 来自服务商
	if s_project_id != 0 {
		projectInfoSupplier := youngee_talent_model.ProjectInfoSupplier{}
		err := g.DB().Model("younggee_s_project_info").Where("s_project_id=?", s_project_id).Scan(&projectInfoSupplier)
		if err != nil {
			fmt.Println("projectInfoSupplier err:", err.Error())
		}
		var younggeeSupplier *youngee_talent_model.YounggeeSupplier
		err = g.DB().Model("younggee_supplier").WithAll().Where("supplier_id", projectInfoSupplier.SupplierID).Scan(&younggeeSupplier)
		if err != nil {
			return &TalentHttpResult{Code: -3, Msg: err.Error()}
		}
		ProjectDetail.YounggeeSupplier = younggeeSupplier
		ProjectDetail.ProjectInfoSupplier = &projectInfoSupplier
	} else {
		//商家发布的
		var enterprise *youngee_talent_model.Enterprise
		err = g.DB().Model("enterprise").Where("enterprise_id", ProjectDetail.EnterpriseId).Scan(&enterprise)
		if err != nil {
			return &TalentHttpResult{Code: -3, Msg: err.Error()}
		}
		ProjectDetail.Enterprise = enterprise
	}

	return &TalentHttpResult{Code: 0, Msg: "success", Data: ProjectDetail}
}

//func GetProjectDetailFromBrowse(r *ghttp.Request) *TalentHttpResult {
//	//从redis的 key--》browseProject:currentDate:tid中获取对应的  project_id:s_project_id
//
//	pid := r.GetQueryInt("project_id", 0)
//	enterprise_id := r.GetQueryString("enterprise_id", "") //来自商家
//	s_project_id := r.GetQueryString("s_project_id", "")
//	projectInfoSupplier := youngee_talent_model.ProjectInfoSupplier{}
//	if s_project_id != "" {
//		// 来自服务商
//		err := g.DB().Model("younggee_s_project_info").Where("s_project_id=?", s_project_id).Scan(&projectInfoSupplier)
//		if err != nil {
//			fmt.Println("projectInfoSupplier err:", err.Error())
//		}
//	}
//
//	if pid == 0 {
//		return &TalentHttpResult{Code: -2, Msg: "parse param error"}
//	}
//
//	var ProjectDetail *youngee_talent_model.ProjectDetail
//	err := g.DB().Model("project_info").WithAll().Where("project_id", pid).Scan(&ProjectDetail)
//	if err != nil {
//		return &TalentHttpResult{Code: -3, Msg: err.Error()}
//	}
//	//违约
//	one, err := g.DB().Model("info_auto_default_handle").Where("auto_default_id=?", ProjectDetail.AutoDefaultId).One()
//	one2, err := g.DB().Model("info_auto_task").Where("auto_task_id=?", ProjectDetail.AutoTaskId).One()
//	ProjectDetail.DraftBreakPercent = one["sketch_replace_not_upload"].Int()
//	ProjectDetail.LinkBreakPercent = one["link_replace_not_upload"].Int()
//	ProjectDetail.DataBreakPercent = one["data_replace_not_upload"].Int()
//	ProjectDetail.DraftBreakTime = one2["draft_default"].Int()
//	ProjectDetail.DraftBreakTime = one2["link_breach"].Int()
//	ProjectDetail.DraftBreakTime = one2["case_close_default"].Int()
//
//	if s_project_id != "" { // 来自服务商
//		var younggeeSupplier *youngee_talent_model.YounggeeSupplier
//		err = g.DB().Model("younggee_supplier").WithAll().Where("supplier_id", projectInfoSupplier.SupplierID).Scan(&younggeeSupplier)
//		if err != nil {
//			return &TalentHttpResult{Code: -3, Msg: err.Error()}
//		}
//		ProjectDetail.YounggeeSupplier = younggeeSupplier
//		ProjectDetail.ProjectInfoSupplier = &projectInfoSupplier
//	} else { //project来自商家
//		var enterprise *youngee_talent_model.Enterprise
//		err = g.DB().Model("enterprise").WithAll().Where("enterprise_id", enterprise_id).Scan(&enterprise)
//		if err != nil {
//			return &TalentHttpResult{Code: -3, Msg: err.Error()}
//		}
//		ProjectDetail.Enterprise = enterprise
//	}
//
//	return &TalentHttpResult{Code: 0, Msg: "success", Data: ProjectDetail}
//}

func SignUpProjKuaishouList(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	pid := r.GetQueryString("project_id", 0)
	// 定义用于存储查询结果的结构体切片
	var results []*youngee_talent_model.KuaishouUserInfo
	// 查询此达人下，platform_id 为 8 或 4 的所有数据，并将结果扫描到结构体切片中
	err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
		Where("talent_id = ?", tid).
		Where("platform_id IN (?, ?)", 4, 8).
		Order("open_id ASC, platform_id DESC"). // 按 open_id 排序，确保每组的数据连续，并且 platform_id=4 的数据排在前面
		Scan(&results)
	if err != nil {
		return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
	}

	// 创建一个 map，用于记录每个 open_id 对应的记录
	//key是openid，value是数组，从而实现一对多
	openIdMap := make(map[string][]*youngee_talent_model.KuaishouUserInfo)

	// 将查询结果按 open_id 分组
	for _, record := range results {
		openIdMap[record.OpenId] = append(openIdMap[record.OpenId], record)
	}

	// 筛选出 open_id 对应两条数据且 platform_id = 4 的记录
	var resInfo []*youngee_talent_model.KuaishouUserInfo
	for _, records := range openIdMap {
		if len(records) == 2 { // 确保有两条数据，排除只有一个 platform_id 的情况
			for _, record := range records {
				if record.PlatformId == 4 { // 选取 platform_id = 4（电商） 的记录,含有粉丝数就好，因为需要加入橱窗
					resInfo = append(resInfo, record)
					break
				}
			}
		}
	}
	// 遍历 resInfo 检查过期和是否报名
	for _, record := range resInfo {
		// 调用 CheckKuaishouTokenExp 函数，检查 openId 是否过期
		expired := youngee_talent_service.CheckKuaishouTokenExp(record.OpenId)
		// 将过期检查结果赋值给 expired 属性 ，过期则不能被选中用于加入橱窗
		record.Expired = expired
		//是否报名
		isSignResult, err := g.DB().Model("youngee_task_info").Where("project_id=? AND open_id=? talent_id=?", pid, record.OpenId, tid).One()
		// 根据查询结果设置 IsSign 属性
		if err != nil || isSignResult.IsEmpty() {
			record.IsSign = 0 // 没有查到数据，设置为 0
		} else {
			record.IsSign = 1 // 查到数据，设置为 1
		}

	}

	return &TalentHttpResult{Code: 0, Msg: "success", Data: resInfo}
}

// 根据project的平台出现对应的社媒账号列表
func SignUpProjAccountList(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	pid := r.GetQueryString("project_id", "")
	platformId := r.GetInt("platform_id", 0)
	if pid == "" || platformId == 0 {
		return &TalentHttpResult{Code: -1, Msg: "参数有误", Data: nil}
	}
	//快手平台
	if platformId == 4 {
		// 定义用于存储查询结果的结构体切片
		var results []*youngee_talent_model.KuaishouUserInfo
		// 查询此达人下，platform_id 为 8 或 4 的所有数据，并将结果扫描到结构体切片中
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id IN (?, ?)", 4, 8).
			Order("open_id ASC, platform_id DESC"). // 按 open_id 排序，确保每组的数据连续，并且 platform_id=4 的数据排在前面
			Scan(&results)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}

		// 创建一个 map，用于记录每个 open_id 对应的记录
		//key是openid，value是数组，从而实现一对多
		openIdMap := make(map[string][]*youngee_talent_model.KuaishouUserInfo)

		// 将查询结果按 open_id 分组
		for _, record := range results {
			openIdMap[record.OpenId] = append(openIdMap[record.OpenId], record)
		}

		// 筛选出 open_id 对应两条数据且 platform_id = 4 的记录
		var resInfo []*youngee_talent_model.KuaishouUserInfo
		for _, records := range openIdMap {
			if len(records) == 2 { // 确保有两条数据，排除只有一个 platform_id 的情况
				for _, record := range records {
					if record.PlatformId == 4 { // 选取 platform_id = 4（电商） 的记录,含有粉丝数就好，因为需要加入橱窗
						resInfo = append(resInfo, record)
						break
					}
				}
			}
		}
		// 遍历 resInfo 检查过期和是否报名
		for _, record := range resInfo {
			// 调用 CheckKuaishouTokenExp 函数，检查 openId 是否过期
			expired := youngee_talent_service.CheckKuaishouTokenExp(record.OpenId)
			// 将过期检查结果赋值给 expired 属性 ，过期则不能被选中用于加入橱窗
			record.Expired = expired
			//是否报名

			isSignResult, err := g.DB().Model("youngee_task_info").Where("project_id=? AND open_id=? AND talent_id=?", pid, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: resInfo}
	} else if platformId == 2 { //抖音
		//获取列表
		var results2 []*youngee_talent_model.KuaishouUserInfo
		//获取达人在此平台的全部账号
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id = ? ", 2).
			Scan(&results2)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}
		// 遍历 resInfo 检查过期和是否报名
		for _, record := range results2 {
			// 调用 CheckKuaishouTokenExp 函数，检查 openId 是否过期
			expired := youngee_talent_service.CheckDouyinTokenExp(record.OpenId)
			// 将过期检查结果赋值给 expired 属性 ，过期则不能被选中用于加入橱窗
			record.Expired = expired
			//是否报名
			isSignResult, err := g.DB().Model("youngee_task_info").Where("project_id=? AND open_id=? AND talent_id=?", pid, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: results2}

	} else { //小红书 、 b站  、 微博
		//获取列表
		var results2 []*youngee_talent_model.KuaishouUserInfo
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id = ? ", platformId).
			Scan(&results2)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}
		// 遍历 resInfo 是否报名
		for _, record := range results2 {
			//是否报名
			isSignResult, err := g.DB().Model("youngee_task_info").Where("project_id=? AND open_id=? AND talent_id=?", pid, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: results2}
	}

}

func SignUpLocalAccountList(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	localId := r.GetQueryString("local_id", "")
	platformId := r.GetInt("platform_id", 0)
	if localId == "" || platformId == 0 {
		return &TalentHttpResult{Code: -1, Msg: "参数有误", Data: nil}
	}
	//快手平台
	if platformId == 4 {
		// 定义用于存储查询结果的结构体切片
		var results []*youngee_talent_model.KuaishouUserInfo
		// 查询此达人下，platform_id 为 8 或 4 的所有数据，并将结果扫描到结构体切片中
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id IN (?, ?)", 4, 8).
			Order("open_id ASC, platform_id DESC"). // 按 open_id 排序，确保每组的数据连续，并且 platform_id=4 的数据排在前面
			Scan(&results)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}

		// 创建一个 map，用于记录每个 open_id 对应的记录
		//key是openid，value是数组，从而实现一对多
		openIdMap := make(map[string][]*youngee_talent_model.KuaishouUserInfo)

		// 将查询结果按 open_id 分组
		for _, record := range results {
			openIdMap[record.OpenId] = append(openIdMap[record.OpenId], record)
		}

		// 筛选出 open_id 对应两条数据且 platform_id = 4 的记录
		var resInfo []*youngee_talent_model.KuaishouUserInfo
		for _, records := range openIdMap {
			if len(records) == 2 { // 确保有两条数据，排除只有一个 platform_id 的情况
				for _, record := range records {
					if record.PlatformId == 4 { // 选取 platform_id = 4（电商） 的记录,含有粉丝数就好，因为需要加入橱窗
						resInfo = append(resInfo, record)
						break
					}
				}
			}
		}
		// 遍历 resInfo 检查过期和是否报名
		for _, record := range resInfo {
			// 调用 CheckKuaishouTokenExp 函数，检查 openId 是否过期
			expired := youngee_talent_service.CheckKuaishouTokenExp(record.OpenId)
			// 将过期检查结果赋值给 expired 属性 ，过期则不能被选中用于加入橱窗
			record.Expired = expired
			//是否报名
			isSignResult, err := g.DB().Model("youngee_local_task_info").Where("local_id=? AND open_id=? AND talent_id=?", localId, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: resInfo}
	} else if platformId == 2 { //抖音
		//获取列表
		var results2 []*youngee_talent_model.KuaishouUserInfo
		//获取达人在此平台的全部账号
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id = ? ", 2).
			Scan(&results2)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}
		// 遍历 resInfo 检查过期和是否报名
		for _, record := range results2 {
			// 调用 CheckKuaishouTokenExp 函数，检查 openId 是否过期
			expired := youngee_talent_service.CheckDouyinTokenExp(record.OpenId)
			// 将过期检查结果赋值给 expired 属性 ，过期则不能被选中用于加入橱窗
			record.Expired = expired
			//是否报名
			isSignResult, err := g.DB().Model("youngee_local_task_info").Where("local_id=? AND open_id=? AND talent_id=?", localId, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: results2}

	} else { //小红书 、 b站  、 微博
		//获取列表
		var results2 []*youngee_talent_model.KuaishouUserInfo
		err := g.DB().Model(&youngee_talent_model.KuaishouUserInfo{}).
			Where("talent_id = ?", tid).
			Where("platform_id = ? ", platformId).
			Scan(&results2)
		if err != nil {
			return &TalentHttpResult{Code: 1, Msg: "查询失败", Data: nil}
		}
		// 遍历 resInfo 是否报名
		for _, record := range results2 {
			//是否报名
			isSignResult, err := g.DB().Model("youngee_local_task_info").Where("local_id=? AND open_id=? AND talent_id=?", localId, record.OpenId, tid).One()
			if err != nil {
				return &TalentHttpResult{Code: -1, Msg: err.Error()}
			}
			// 根据查询结果设置 IsSign 属性
			if isSignResult.IsEmpty() {
				record.IsSign = 0 // 没有查到数据，设置为 0
			} else {
				record.IsSign = 1 // 查到数据，设置为 1
			}

		}
		return &TalentHttpResult{Code: 0, Msg: "success", Data: results2}
	}

}