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"
	"reflect"
	"sort"
	"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("categoryform", 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: "参数错误"}
	}

	// 如果有稿费形式的过滤条件，则将过滤条件保存于taskModeList
	//var feeFormList []interface{}
	//if feeForm != nil {
	//	if reflect.TypeOf(feeForm).Kind() != reflect.Slice {
	//		return &TalentHttpResult{Code: -2, Msg: "搜索条件稿费形式错误"}
	//	}
	//
	//	feeFormList = make([]interface{}, 0)
	//	feeFormList = feeForm.([]interface{})
	//}

	// 如果有任务形式的过滤条件，则将过滤条件保存于taskModeList
	var projectFormList []interface{}
	if projectForm != nil {
		if reflect.TypeOf(projectForm).Kind() != reflect.Slice {
			return &TalentHttpResult{Code: -2, Msg: "搜索条件任务形式错误"}
		}

		projectFormList = make([]interface{}, 0)
		projectFormList = projectForm.([]interface{})
	}

	// 如果有平台的过滤条件，则将平台列表保存于platformList
	var platformList []interface{}
	if platform != nil {
		if reflect.TypeOf(platform).Kind() != reflect.Slice {
			return &TalentHttpResult{Code: -2, Msg: "搜索条件平台类型错误"}
		}

		platformList = make([]interface{}, 0)
		platformList = platform.([]interface{})
	}

	// 如果有内容形式的过滤条件，则将过滤条件保存于taskModeList
	var contentTypeList []interface{}
	if contentType != nil {
		if reflect.TypeOf(projectForm).Kind() != reflect.Slice {
			return &TalentHttpResult{Code: -2, Msg: "搜索条件任务形式错误"}
		}

		contentTypeList = make([]interface{}, 0)
		contentTypeList = contentType.([]interface{})
	}

	// 上线时间
	var createTimeList []interface{}
	if createTime != nil {
		if reflect.TypeOf(createTime).Kind() != reflect.Slice {
			return &TalentHttpResult{Code: -2, Msg: "搜索条件任务形式错误"}
		}
		createTimeList = make([]interface{}, 0)
		createTimeList = createTime.([]interface{})
	}

	// 如果有商品类目的过滤条件，则将过滤条件保存于categoryFormList
	var categoryFormList []interface{}
	if categoryForm != nil {
		if reflect.TypeOf(categoryForm).Kind() != reflect.Slice {
			return &TalentHttpResult{Code: -2, Msg: "搜索条件任务形式错误"}
		}

		categoryFormList = make([]interface{}, 0)
		categoryFormList = categoryForm.([]interface{})
	}
	if len(categoryFormList) > 0 {
		// 使用 categoryFormList 进行某些操作
		fmt.Println("Filtered categoryFormList:", categoryFormList)
	}

	// 构造查询的条件
	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)
	if platformList != nil {
		whereStr = whereStr + " and project_platform in ("
		for _, v := range platformList {
			whereStr += v.(string) + ", "
		}

		whereStr = whereStr[0 : len(whereStr)-2]
		whereStr += ")"
	}

	if contentTypeList != nil {
		whereStr = whereStr + " and content_type in ("
		for _, v := range contentTypeList {
			whereStr += v.(string) + ", "
		}

		whereStr = whereStr[0 : len(whereStr)-2]
		whereStr += ")"
	}

	// 处理 selectionFormList (创建时间的过滤条件)
	if createTimeList != nil {
		whereStr += " AND created_at >= (NOW() - INTERVAL "
		for _, v := range createTimeList {
			switch v.(string) {
			case "1": // 近7天
				whereStr += "7 DAY"
			case "2": // 近30天
				whereStr += "30 DAY"
			case "3": // 近90天
				whereStr += "90 DAY"
			default:
				continue // 无效的过滤条件，跳过
			}
		}
		whereStr += ")"
	}

	if platformList != nil {
		whereStr = whereStr + " and project_platform in ("
		for _, v := range platformList {
			whereStr += v.(string) + ", "
		}

		whereStr = whereStr[0 : len(whereStr)-2]
		whereStr += ")"
	}

	if projectFormList != nil {
		whereStr += " and project_form in ("
		for _, v := range projectFormList {
			whereStr += v.(string) + ", "
		}

		whereStr = whereStr[0 : len(whereStr)-2]
		whereStr += ")"
	}
	if searchValue != nil {
		whereStr += " and project_name like '%" + searchValue.(string) + "%'"
	}

	fmt.Println("whereStr:-----》 ", whereStr)

	// 查询所有project
	//var projectList = []model.ProjectInfo{}
	//err := g.Model(dao.ProjectInfo.Table).Where(whereStr).Scan(&projectList)
	//if err != nil {
	//	return &TalentHttpResult{Code: -3, Msg: "查询数据库失败"}
	//}

	// 判断请求页面是否超过最大页面
	c, err := g.DB().Model(dao.ProjectInfo.Table).Fields("project_id").Where(whereStr).Count()

	if c <= 0 {
		return &TalentHttpResult{Code: -4, Msg: "has no fullproject", Data: nil}
	}

	maxPage := c / cntPerPage
	if c%cntPerPage > 0 {
		maxPage += 1
	}

	if pageIndex+1 > maxPage {
		return &TalentHttpResult{Code: -5, Msg: "over max page"}
	}

	var projectInfoList = youngee_talent_model.ProjectInfoList{}

	fmt.Println("test")
	err = g.DB().Model("project_info").WithAll().Where(whereStr).
		Order("project_status ASC,recruit_ddl DESC").Limit(startId, cntPerPage).Scan(&projectInfoList.ProjectInfos)
	fmt.Println("test over")
	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()
		// 根据 WatchedNum 从高到低排序
		if viewOrder != -1 {
			sort.Slice(projectInfoList.ProjectInfos, func(i, j int) bool {
				return projectInfoList.ProjectInfos[i].WatchedNum > projectInfoList.ProjectInfos[j].WatchedNum
			})
		}

		// 统计 RecruitStrategys 数组中的最低粉丝量和最高粉丝量
		var minFollowers, maxFollowers int
		// 初始值可以设为极大/极小值
		minFollowers = math.MaxInt32
		maxFollowers = math.MinInt32

		// 遍历 RecruitStrategys，找出最低粉丝量和最高粉丝量
		for _, strategy := range project.RecruitStrategys {
			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

		//稿费的展示情况
		allFeeFormNoFee := true // 假设都是无费置换
		var hasSelfPrice bool
		var minOffer, maxOffer int

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

		// 根据判断结果设置 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
		}
	}
	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}
}

// 获取单个项目详情service
func GetProjectDetail(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	//pid := r.GetQueryInt("project_id", 0)
	pid := r.GetQueryString("project_id", "")
	fmt.Println("project id----", pid)
	//通过首页进入的详情页，获取服务商id，younggee_supplier表
	enterprise_id := r.GetQueryString("enterprise_id", "")
	fmt.Println("enterprise_id:----》", enterprise_id)
	//通过扫服务商码进入的详情页，获取服务商id，younggee_supplier表
	s_project_id := r.GetQueryInt("s_project_id", 0)

	// Redis key
	//projectViewKey := "project:view:" + strconv.Itoa(pid)
	projectViewKey := "project:view:" + pid
	//userViewedKey := "user:viewed:" + tid + ":" + strconv.Itoa(pid)
	userViewedKey := "user:viewed:" + tid + ":" + pid
	if pid == "" {
		return &TalentHttpResult{Code: -2, Msg: "parse param error"}
	}
	//在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
	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()
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: err.Error()}
	}
	//各阶段扣款时间
	one2, err := g.DB().Model("info_auto_task").Where("auto_task_id=?", ProjectDetail.AutoTaskId).One()
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: err.Error()}
	}

	if one != nil {
		ProjectDetail.DraftBreakPercent = one["sketch_replace_not_upload"].Int()
		ProjectDetail.LinkBreakPercent = one["link_replace_not_upload"].Int()
		ProjectDetail.DataBreakPercent = one["data_replace_not_upload"].Int()
	} else {
		return &TalentHttpResult{Code: 0, Msg: "one is nil"}
	}

	if one2 != nil {
		ProjectDetail.DraftBreakTime = one2["draft_default"].Int()
		ProjectDetail.LinkBreakTime = one2["link_breach"].Int()
		ProjectDetail.DataBreakTime = one2["case_close_default"].Int()
	} else {
		return &TalentHttpResult{Code: 0, Msg: "one2 is nil"}
	}

	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()

	//浏览历史
	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()}
	}

	// 来自服务商
	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", 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 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("younggee_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("younggee_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}
	} 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("younggee_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: 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("younggee_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: results2}
	}

}