youngee_mc_api/app/service/youngee_talent_service/talent_ks_auth.go

package youngee_talent_service

import (
	"context"
	"fmt"
	"github.com/chromedp/chromedp"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/net/ghttp"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
	"github.com/lin-jim-leon/kuaishou/open/merchant"
	"github.com/lin-jim-leon/kuaishou/open/user"
	"log"
	"time"
	"youngmini_server/app/model/youngee_talent_model"
	"youngmini_server/app/utils"
)

const (
	//快手电商
	ClientKey    = "ks651333097154138217"
	ClientSecret = "dBt0rVRhTpUqcrOYGGpv0A"
	SignSecret   = "bf6393dce0a2b669ee348bebb837b0da"
	//快手平台
	ClientKey1    = "ks671599294546520767"
	ClientSecret1 = "8VSrp3O09nunjLMXR1uotg"
	//SignSecret1   = "bf6393dce0a2b669ee348bebb837b0da"
	//抖音平台
	ClientKey2    = "awi77xl5kpl16hmi"
	ClientSecret2 = "7ce6d2531bd4489122d89658063fd76e"
	//SignSecret1   = "bf6393dce0a2b669ee348bebb837b0da"
)

func GetQrcode(r *ghttp.Request) *TalentHttpResult {
	//达人id获取
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	println("here")
	// 记录开始时间
	startTime := time.Now()
	// 创建一个新的上下文
	ctx, cancel := chromedp.NewContext(context.Background())
	// 构建包含 tid 的 urlstr
	var urlstr string
	typePlatform := r.GetInt("platform_id")
	if typePlatform == 4 { //快手电商
		urlstr = fmt.Sprintf("https://open.kuaishou.com/oauth2/connect?state=%s&app_id=ks651333097154138217&redirect_uri=https://younggee.com/kuaishouauth&scope=merchant_distribution,merchant_refund,merchant_item,merchant_order,user_info,merchant_servicemarket,merchant_user,merchant_logistics&response_type=code", tid)
	} else if typePlatform == 8 { //快手平台
		urlstr = fmt.Sprintf("https://open.kuaishou.com/oauth2/connect?state=%s&app_id=ks671599294546520767&redirect_uri=https://younggee.com/kuaishouauthVideo&scope=user_video_info,user_info&response_type=code", tid)
	} else if typePlatform == 2 { //抖音平台
		urlstr = fmt.Sprintf("https://open.kuaishou.com/oauth2/connect?state=%s&app_id=ks671599294546520767&redirect_uri=https://younggee.com/kuaishouauthVideo&scope=user_video_info,user_info&response_type=code", tid)
	} else {
		urlstr = "unknow"
	}
	// 执行任务
	//var buf []byte
	var text string
	var ok bool
	var tasks chromedp.Tasks

	if typePlatform == 2 { //抖音
		tasks = chromedp.Tasks{
			chromedp.Navigate(urlstr),
			// chromedp.WaitVisible(`#semiTabPanelqr > div > div > div.qr-container > img`, chromedp.ByQuery),
			chromedp.AttributeValue(`#semiTabPanelqr > div > div > div.qr-container > img`, "src", &text, &ok),
		}
	} else { //快手
		tasks = chromedp.Tasks{
			chromedp.Navigate(urlstr),
			// chromedp.WaitVisible(`body > div > div > div > div.qr-code-main > img:nth-child(1)`, chromedp.ByQuery),
			chromedp.AttributeValue(`body > div > div > div > div.qr-code-main > img:nth-child(1)`, "src", &text, &ok),
		}
	}

	//浏览器启动！
	err = chromedp.Run(ctx, tasks)
	if err != nil {
		log.Fatal(err)
	}
	println("text----->", text)
	println("ok----->", ok)
	println("url----->", urlstr)
	fmt.Println("代码运行时间:", time.Since(startTime))
	//r.Response.WriteJson(text)

	// 在300秒后取消上下文
	time.AfterFunc(300*time.Second, func() {
		cancel()
	})

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

// 检查数据库表中是否有达人对应的数据 且 token未过期
func CheckAccount(r *ghttp.Request) *TalentHttpResult {
	fmt.Println("into check")
	//达人id获取
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	userInfo := &youngee_talent_model.KuaishouUserInfo{}
	err = g.DB().Model(userInfo).Where("talent_id", tid).Scan(&userInfo)
	fmt.Println("userInfo*********", userInfo)
	if err != nil {
		// 查询失败(未找到结果)，返回失败结果
		return &TalentHttpResult{Code: -1, Msg: "Query failed", Data: nil}
	}
	//有查询结果，看是否accessToken是否有效
	key, err1 := g.DB().Model("platform_kuaishou_user_info").Fields("access_token").Where("talent_id = ?", tid).Value()
	if err1 != nil {
		return &TalentHttpResult{Code: -1, Msg: "query database fail"}
	}
	AccessToken := key.String()
	_, err2 := user.GetUserinfo(ClientKey, AccessToken)
	if err2 != nil {
		//前端接收code=-2表示token过期
		return &TalentHttpResult{Code: -2, Msg: "accessToken过期", Data: nil}
	}
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "success", Data: userInfo}
}

// 检查数据库表中是否有达人对应的数据，有就删掉，/kuaishouath中会插入。
func CheckNewAccount(r *ghttp.Request) *TalentHttpResult {
	//check到了更新时间在两秒内的插入的数据。则说明已绑定。弹窗消失。
	//达人id获取
	fmt.Println("***********into checknewaccount")
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	// 获取当前时间
	currentTime := gtime.Now()
	// 查询数据库中是否有符合条件的数据
	userInfo := &youngee_talent_model.KuaishouUserInfo{}
	err = g.DB().Model("platform_kuaishou_user_info").
		Where("talent_id = ?", tid).
		Scan(&userInfo)
	if err != nil {
		return &TalentHttpResult{Code: -2, Msg: "platform_kuaishou_user_info query failed"}
	}
	//找到数据，判断时间差
	if userInfo != nil {
		// 计算创建时间与当前时间的差值
		timeDiff := currentTime.Sub(userInfo.CreateTime)
		fmt.Println("***********kifasfa", timeDiff)
		if timeDiff <= 3*time.Second {
			return &TalentHttpResult{Code: 0, Msg: "success", Data: nil}
		}
	}
	// 如果没有符合条件的数据，返回失败
	return &TalentHttpResult{Code: -20, Msg: "No valid data found", Data: nil}
}
func CheckTokenExp(r *ghttp.Request) *TalentHttpResult {
	//达人id获取
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	key, err1 := g.DB().Model("platform_kuaishou_user_info").Fields("access_token").Where("talent_id = ?", tid).Value()
	if err1 != nil {
		return &TalentHttpResult{Code: -1, Msg: "query database fail"}
	}
	AccessToken := key.String()
	res_info, err2 := user.GetUserinfo(ClientKey, AccessToken)
	if err2 != nil {
		//前端接收code=-2表示token过期
		return &TalentHttpResult{Code: -2, Msg: "accessToken过期", Data: nil}
	}
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "success", Data: res_info}
}

func AddWindow(r *ghttp.Request) *TalentHttpResult {
	pId := r.GetString("product_id")

	//通过pId获取kuaishou_product_id
	pIdSlice := []string{pId}
	//达人id获取
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	//加入橱窗-条件不满足的快手账号不能被选中
	//条件1. 没有开通橱窗

	//判断此快手账号是否绑定了两
	openId := r.GetString("open_id")
	// 执行数据库查询
	count, err := g.DB().Model("platform_kuaishou_user_info").
		Where("talent_id = ? AND open_id = ?", tid, openId).
		Count()
	if err != nil {
		// 处理错误
		return &TalentHttpResult{Code: -4, Msg: "出错了"}
	}
	if count != 2 {
		return &TalentHttpResult{Code: -5, Msg: "达人需要授权两个码"}
	}
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	key, err := g.DB().Model("platform_kuaishou_user_info").Fields("access_token").Where("talent_id = ?", tid).Value()
	if err != nil {
		return &TalentHttpResult{Code: -2, Msg: "query database fail"}
	}
	AccessToken := key.String()
	res_info, err := merchant.AddItemsToShelf(ClientKey, SignSecret, AccessToken, pIdSlice)
	if err != nil {
		//前端接收code=-3表示添加失敗，沒有開通
		return &TalentHttpResult{Code: -3, Msg: "未開通、商品不存在或已下线", Data: nil}
	}
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "加入橱窗成功", Data: res_info}
}
func GetKuaishouFansNum(r *ghttp.Request) *TalentHttpResult {
	//达人id获取
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	fmt.Println("********&&&&&&&&&&，tid", tid)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent id failed"}
	}
	key, err1 := g.DB().Model("platform_kuaishou_user_info").Fields("access_token").Where("talent_id = ? ", tid).Value()
	if err1 != nil {
		return &TalentHttpResult{Code: -2, Msg: "query database fail"}
	}
	AccessToken := key.String()
	res_user, err2 := user.GetUserinfo(ClientKey, AccessToken)
	if err2 != nil {
		//前端接收code=-3表示添加失敗，沒有開通
		return &TalentHttpResult{Code: -3, Msg: "获取快手用户信息出错", Data: nil}
	}
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "获取快手用户信息成功", Data: res_user.Data}
}

func QuerySalesFor30Days(r *ghttp.Request) *TalentHttpResult {
	fmt.Println("into querySalesFor30Days")
	ClientKey := "ks651333097154138217"
	//ClientSecret := "dBt0rVRhTpUqcrOYGGpv0A"
	SignSecret := "bf6393dce0a2b669ee348bebb837b0da"
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ?", tid).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	// 输出查询到的 access_token 值
	fmt.Println("Access Token:", AccessToken)
	// 获取当前时间的时间戳（毫秒）
	currentTime := time.Now().UnixNano() / int64(time.Millisecond)
	// 30天前的时间戳（毫秒）
	beginTime30DaysAgo := currentTime - 30*24*60*60*1000
	// 定义每段查询的天数
	intervalDays := 7
	intervalMillis := int64(intervalDays * 24 * 60 * 60 * 1000)

	// 初始化 beginTime 和 endTime
	beginTime := beginTime30DaysAgo
	endTime := beginTime + intervalMillis
	saleNum := 0 //30天总销量
	// 循环查询，先处理四个7天的时间段
	for i := 0; i < 4; i++ {
		// 调整 endTime，确保不会超过当前时间
		if endTime > currentTime {
			endTime = currentTime
		}
		saleNum += GetSaleNumByDayInterval(ClientKey, SignSecret, AccessToken, beginTime, endTime)
		// 更新时间段
		beginTime = endTime
		endTime = beginTime + intervalMillis
	}

	// 最后处理剩余的2天时间段
	endTime = currentTime
	saleNum += GetSaleNumByDayInterval(ClientKey, SignSecret, AccessToken, beginTime, endTime)
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "获取30天销售量成功", Data: saleNum}
}

func QueryOkSaleNum(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ?", tid).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}
	//循环使用接口
	//
	// 获取当前时间的时间戳（毫秒）
	currentTime := time.Now().UnixNano() / int64(time.Millisecond)
	// 90天前的时间戳（毫秒）
	beginTime90DaysAgo := currentTime - 90*24*60*60*1000
	// 定义每段查询的天数
	intervalDays := 7
	intervalMillis := int64(intervalDays * 24 * 60 * 60 * 1000)

	// 初始化 beginTime 和 endTime
	beginTime := beginTime90DaysAgo
	endTime := beginTime + intervalMillis
	saleNum := 0 //90天总销量
	// 循环查询，先处理四个7天的时间段
	for i := 0; i < 12; i++ {
		// 调整 endTime，确保不会超过当前时间
		if endTime > currentTime {
			endTime = currentTime
		}
		saleNum += GetSaleNumByDayInterval_Ok(ClientKey, SignSecret, AccessToken, beginTime, endTime)
		// 更新时间段
		beginTime = endTime
		endTime = beginTime + intervalMillis
	}

	// 最后处理剩余的6天时间段
	endTime = currentTime
	saleNum += GetSaleNumByDayInterval_Ok(ClientKey, SignSecret, AccessToken, beginTime, endTime)
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "获取30天销售量成功", Data: saleNum}
}

func DyLikeCount(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ? AND platform_id = ?", tid, 2).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}
	//todo : API
	count, err := GetLikeCount(ClientKey1, AccessToken)
	return &TalentHttpResult{Code: 0, Msg: "获取总点赞数成功", Data: count}
}

func DyVideoCount(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ? AND platform_id = ?", tid, 2).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}
	//todo : API
	count, err := GetLikeCount(ClientKey1, AccessToken)
	return &TalentHttpResult{Code: 0, Msg: "获取总点赞数成功", Data: count}
}

func VideoCount(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ? AND platform_id = ?", tid, 8).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}

	count, err := GetVideoCount(ClientKey1, AccessToken)
	return &TalentHttpResult{Code: 0, Msg: "获取总作品数成功", Data: count}
}

func LikeCount(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ? AND platform_id = ?", tid, 8).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}
	count, err := GetLikeCount(ClientKey1, AccessToken)
	return &TalentHttpResult{Code: 0, Msg: "获取总点赞数成功", Data: count}
}

// 获取用户快手平台账号列表
func GetKuaishouList(r *ghttp.Request) *TalentHttpResult {
	// 从 session 中获取 talent_id
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询 platformId 为 8 或 4 的所有数据
	results, err := g.DB().Model(userInfo).Where("talent_id = ?", tid).
		Where("platform_Id IN (?, ?)", 4, 8).
		Order("platform_Id DESC").
		All()
	if err != nil {
		fmt.Println("Error querying access_token:", err)
		return &TalentHttpResult{Code: -1, Msg: "查询出错", Data: nil}
	}

	// 检查查询结果是否为空
	if results.IsEmpty() {
		return &TalentHttpResult{Code: -2, Msg: "此达人无快手账号绑定", Data: nil}
	}

	// 使用集合来存储唯一的 open_id，并计算不同的 open_id 的个数
	openIDSet := make(map[string]struct{})
	userInfoMap := make(map[string]*youngee_talent_model.KuaishouUserInfo)

	for _, record := range results.List() {
		openID := gconv.String(record["open_id"])
		platformID := record["platform_id"] //int类型
		status := 0                         //初始化
		// 检查 userInfoMap 中是否已经存在 openID
		//肯定会先处理8,所以遇到重复情况肯定是两个都授权了
		_, exists := userInfoMap[openID]
		if exists {
			status = 1 //同时授权了两个码
			userInfoMap[openID] = &youngee_talent_model.KuaishouUserInfo{
				OpenId:   openID,
				HeadUri:  gconv.String(record["head_uri"]),
				NickName: gconv.String(record["nick_name"]),
				// 添加其他需要的字段
				Fan: gconv.Int(record["fan"]),
				//这两个值默认为0
				LikeNum:  gconv.Int(record["like_num"]),
				VideoNum: gconv.Int(record["video_num"]),
				Status:   status,
			}
		}
		//若同时有8和4的平台。处理了8就不会处理4了
		if !exists {
			//只有一个且为4
			if platformID == 4 {
				status = 2 //仅授权了电商
			} else {
				status = 3 //仅授权了平台
			}
			openIDSet[openID] = struct{}{}
			// 根据 platformID 赋值
			userInfoMap[openID] = &youngee_talent_model.KuaishouUserInfo{
				OpenId:   openID,
				HeadUri:  gconv.String(record["head_uri"]),
				NickName: gconv.String(record["nick_name"]),
				// 添加其他需要的字段
				Fan: gconv.Int(record["fan"]),
				//这两个值默认为0
				LikeNum:  gconv.Int(record["like_num"]),
				VideoNum: gconv.Int(record["video_num"]),
				Status:   status,
			}
		}
	}

	// 构建 UserInfo 列表  参数分别表示初始长度和容量
	userInfoList := make([]*youngee_talent_model.KuaishouUserInfo, 0, len(userInfoMap))
	for _, info := range userInfoMap {
		//将 info 添加到 userInfoList 列表的末尾。
		userInfoList = append(userInfoList, info)
	}

	// 计算不同的 open_id 的个数
	uniqueOpenIDCount := len(openIDSet)

	// 创建 KSListResult 变量并赋值
	ksListResult := &youngee_talent_model.KSListResult{
		Count:    uniqueOpenIDCount,
		UserInfo: userInfoList,
	}

	// 返回结果
	return &TalentHttpResult{Code: 1, Msg: "返回快手列表成功", Data: ksListResult}
}

// 获取用户快手平台账号列表
func GetKuaishouListWithCondition(r *ghttp.Request) *TalentHttpResult {
	// 从 session 中获取 talent_id
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	userInfo := &youngee_talent_model.KuaishouUserInfo{}
	//1.获取该tid下的所有账户信息

	//2.openid去重，遍历userInfoMap<openid,userInfo>openid对应了两个accesstokn就都去验证是否过期

	//3.openId对应的accessToken调用是否过期接口，过期则use_code=1

	//4.调用是否已领取接口 ，领取则use_code=2

	//5.领样条件(粉丝数+橱窗销量)不满足  use_code=3

	// 创建 KSListResult 变量并赋值
	ksListResult := &youngee_talent_model.KSListResult{
		Count:    uniqueOpenIDCount,
		UserInfo: userInfoList,
	}
	// 返回结果
	return &TalentHttpResult{Code: 1, Msg: "返回快手列表成功", Data: ksListResult}
}

func QuerySalesFor90Days(r *ghttp.Request) *TalentHttpResult {
	tid, _ := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	// 创建一个 KuaishouUserInfo 结构体的实例
	userInfo := &youngee_talent_model.KuaishouUserInfo{}

	// 查询数据库中的 access_token 字段
	// 使用 g.DB() 获取数据库连接，并执行查询
	key, err := g.DB().Model(userInfo).Fields("access_token").Where("talent_id = ?", tid).Value()
	AccessToken := key.String()
	if err != nil {
		// 处理错误
		fmt.Println("Error querying access_token:", err)
	}
	if key == nil {
		// 处理错误
		fmt.Println("can not find talentId's bindinfo :", err)
	}
	//循环使用接口
	//
	// 获取当前时间的时间戳（毫秒）
	currentTime := time.Now().UnixNano() / int64(time.Millisecond)
	// 30天前的时间戳（毫秒）
	beginTime90DaysAgo := currentTime - 90*24*60*60*1000
	// 定义每段查询的天数
	intervalDays := 7
	intervalMillis := int64(intervalDays * 24 * 60 * 60 * 1000)

	// 初始化 beginTime 和 endTime
	beginTime := beginTime90DaysAgo
	endTime := beginTime + intervalMillis
	saleNum := 0 //90天总销量
	// 循环查询，先处理四个7天的时间段
	for i := 0; i < 12; i++ {
		// 调整 endTime，确保不会超过当前时间
		if endTime > currentTime {
			endTime = currentTime
		}
		saleNum += GetSaleNumByDayInterval(ClientKey, SignSecret, AccessToken, beginTime, endTime)
		// 更新时间段
		beginTime = endTime
		endTime = beginTime + intervalMillis
	}

	// 最后处理剩余的6天时间段
	endTime = currentTime
	saleNum += GetSaleNumByDayInterval(ClientKey, SignSecret, AccessToken, beginTime, endTime)
	// 查询成功，返回成功结果和数据
	return &TalentHttpResult{Code: 0, Msg: "获取30天销售量成功", Data: saleNum}
}

func GetSaleNumByDayInterval(ClientKey string, SignSecret string, AccessToken string, beginTime int64, endTime int64) int {
	pageSize := 100
	totalSaleNum := 0

	// 定义要查询的订单状态
	// [30:已付款] [50:已收货] [60:已结算] [80:已失效]
	statuses := []int{30, 50, 60}

	// 遍历所有订单状态并调用 Corderlist 函数
	for _, status := range statuses {
		// 初始化 pcursor
		pcursor := ""

		for {
			// 调用 Corderlist 函数获取订单列表
			response, err := merchant.Corderlist(ClientKey, SignSecret, AccessToken, status, pageSize, beginTime, endTime, pcursor)
			fmt.Println("response********", response)
			if err != nil {
				fmt.Printf("Error calling Corderlist: %v\n", err)
				break
			}

			// 检查响应代码
			if response.Code != "1" {
				fmt.Printf("Corderlist response error: %s\n", response.Msg)
				break
			}

			// 累加订单中商品的数量
			for _, order := range response.Data.OrderViews {
				for _, product := range order.CPSOrderProductViews {
					totalSaleNum += product.Num
				}
			}

			// 检查分页指针 pcursor
			//100个订单以内的情况
			if response.Data.Cursor == "nomore" {
				break
			}
			//大于等于100个订单
			// 更新 pcursor 以获取下一页数据
			pcursor = response.Data.Cursor

			// 处理分页后的数据
			// 如果 pcursor 不是 "nomore"，我们需要累加最后一条订单的数量
			if len(response.Data.OrderViews) > 0 {
				lastOrder := response.Data.OrderViews[len(response.Data.OrderViews)-1]
				if len(lastOrder.CPSOrderProductViews) > 0 {
					lastProduct := lastOrder.CPSOrderProductViews[len(lastOrder.CPSOrderProductViews)-1]
					totalSaleNum += lastProduct.Num
				}
			}
		}
	}
	return totalSaleNum
}

func GetSaleNumByDayInterval_Ok(ClientKey string, SignSecret string, AccessToken string, beginTime int64, endTime int64) int {
	pageSize := 100
	totalSaleNum := 0

	// 定义要查询的订单状态
	// [30:已付款] [50:已收货] [60:已结算] [80:已失效]
	statuses := []int{60}

	// 遍历所有订单状态并调用 Corderlist 函数
	for _, status := range statuses {
		// 初始化 pcursor
		pcursor := ""

		for {
			// 调用 Corderlist 函数获取订单列表
			response, err := merchant.Corderlist(ClientKey, SignSecret, AccessToken, status, pageSize, beginTime, endTime, pcursor)
			fmt.Println("response********", response)
			if err != nil {
				fmt.Printf("Error calling Corderlist: %v\n", err)
				break
			}

			// 检查响应代码
			if response.Code != "1" {
				fmt.Printf("Corderlist response error: %s\n", response.Msg)
				break
			}

			// 累加订单中商品的数量
			for _, order := range response.Data.OrderViews {
				for _, product := range order.CPSOrderProductViews {
					totalSaleNum += product.Num
				}
			}

			// 检查分页指针 pcursor
			//100个订单以内的情况
			if response.Data.Cursor == "nomore" {
				break
			}
			//大于等于100个订单
			// 更新 pcursor 以获取下一页数据
			pcursor = response.Data.Cursor

			// 处理分页后的数据
			// 如果 pcursor 不是 "nomore"，我们需要累加最后一条订单的数量
			if len(response.Data.OrderViews) > 0 {
				lastOrder := response.Data.OrderViews[len(response.Data.OrderViews)-1]
				if len(lastOrder.CPSOrderProductViews) > 0 {
					lastProduct := lastOrder.CPSOrderProductViews[len(lastOrder.CPSOrderProductViews)-1]
					totalSaleNum += lastProduct.Num
				}
			}
		}
	}
	return totalSaleNum
}