youngee_mc_api/router/router.go

package router

import (
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/net/ghttp"
	"github.com/gogf/gf/os/gtime"
	douyinOauth "github.com/lin-jim-leon/douyin/open/oauth"
	douyinUser "github.com/lin-jim-leon/douyin/open/user"
	_ "github.com/lin-jim-leon/kuaishou/open/merchant"
	"github.com/lin-jim-leon/kuaishou/open/oauth"
	_ "github.com/lin-jim-leon/kuaishou/open/oauth"
	"github.com/lin-jim-leon/kuaishou/open/user"
	_ "github.com/lin-jim-leon/kuaishou/open/user"
	youngeetalentapi "youngmini_server/app/api/youngee_talent_api"
	"youngmini_server/app/model/youngee_talent_model"
	"youngmini_server/app/service/youngee_talent_service"
	"youngmini_server/app/system/assignment"
	"youngmini_server/app/system/sectask"
	"youngmini_server/app/system/wxpay"
	"youngmini_server/middleware"
)

// MiddlewareCORS 允许跨域请求中间件 所有的路由都会经过这个中间件
func MiddlewareCORS(r *ghttp.Request) {
	corsOptions := r.Response.DefaultCORSOptions()
	corsOptions.AllowHeaders = "Authorization,Content-Length,X-CSRF-Token,Token,session,X_Requested_With,Accept,Origin,Host,Connection,Accept-Encoding,Accept-Language,DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Pragma"
	corsOptions.ExposeHeaders = "Content-Length,Access-Control-Allow-Origin,Access-Control-Allow-Headers,Content-Language,Expires,Last-Modified,Pragma,FooBar"
	corsOptions.MaxAge = 1728000
	//corsOptions := ghttp.CORSOptions{
	//AllowOrigin:      "*",
	//AllowMethods:     "POST,GET,OPTIONS,PUT,DELETE,UPDATE",
	//AllowCredentials: "false",
	//MaxAge:           1728000,
	//AllowHeaders:     "Authorization,Content-Length,X-CSRF-Token,Token,session,X_Requested_With,Accept,Origin,Host,Connection,Accept-Encoding,Accept-Language,DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Pragma",
	//ExposeHeaders:    "Content-Length,Access-Control-Allow-Origin,Access-Control-Allow-Headers,Content-Language,Expires,Last-Modified,Pragma,FooBar",
	//}
	//corsOptions.AllowDomain = []string{"goframe.org", "johng.cn"}
	//corsOptions.AllowHeaders = "Authorization,Content-Type,Accept,Origin,User-Agent,DNT,Cache-Control,X-Mx-ReqToken,Keep-Alive,X-Requested-With,X-Forwarded-*,Pragma,Cache-Control,If-Modified-Since,userToken,appid"
	r.Response.CORS(corsOptions)
	r.Middleware.Next()
}

// MiddlewareAuth 用户认证中间件
//
//	func MiddlewareAuth(r *ghttp.Request) {
//		//排除路径
//		array := garray.NewFrom(g.Slice{"/admin/account"})
//		if array.Contains(r.RequestURI) == false {
//			userData, err := backstage_service.Token.AuthorizationGetUserData(r)
//			if err != nil {
//				r.Response.WriteStatus(http.StatusForbidden)
//				response.JsonExit(r, http.StatusForbidden, err.Error())
//			}
//			if userData == nil {
//				r.Response.WriteStatus(http.StatusUnauthorized)
//				response.JsonExit(r, http.StatusForbidden, "用户不存在")
//			}
//		}
//		// 中间件处理逻辑
//		r.Middleware.Next()
//	}
//
// 用于存数据库的验证信息
// json用于序列化和反序列化

// MiddlewareSuperAuth 超级管理员可以操作的登录接口
//
//	func MiddlewareSuperAuth(r *ghttp.Request) {
//		// 排除路径
//		userData, _ := backstage_service.Token.AuthorizationGetUserData(r)
//		if userData.User != "10000000" {
//			r.Response.WriteStatus(http.StatusPaymentRequired)
//			response.JsonExit(r, http.StatusPaymentRequired, "没有权限操作")
//		}
//		// 中间件处理逻辑
//		r.Middleware.Next()
//	}
func init() {
	s := g.Server()

	// 解决跨域
	s.BindMiddleware("/*", MiddlewareCORS)

	// v2小程序端接口
	s.Group("/youngee/c", func(group *ghttp.RouterGroup) {
		group.Middleware(middleware.ErrorHandler)
		//用于接口测试
		s.BindHandler("/apitest", func(r *ghttp.Request) {
			r.Response.WriteJson("成功访问服务端")
		})
		//扫码之后---用于快手电商：nignx转发含code的请求到此处
		s.BindHandler("/kuaishouauth", func(r *ghttp.Request) {

			fmt.Println("****进入rounter中的/kuaishouauth*******")
			ClientKey := "ks651333097154138217"
			ClientSecret := "dBt0rVRhTpUqcrOYGGpv0A"
			//SignSecret := "bf6393dce0a2b669ee348bebb837b0da"
			code := r.GetString("code")
			state := r.GetString("state")
			//来自管理后台的用户，state是手机号码
			if len(state) == 11 {
				record, err := g.DB().Model("youngee_m_kuaishou_userinfo").Where("phone_num = ? ", state).One()
				if record.IsEmpty() {
					fmt.Println("未找到符合条件的记录")
					return
				}
				if err != nil {
					fmt.Println("查询youngee_m_kuaishou_userinfo表出错")
				}
				//发起请求，将数据存在record中
				m_res_auth, _ := oauth.GetAccessToken(ClientKey, ClientSecret, code)
				AccessToken := m_res_auth.AccessToken
				//获取基本信息
				m_res_info, _ := user.GetUserinfo(ClientKey, AccessToken)

				//将值update到表中
				// 将值更新到表中的记录中
				_, err = g.DB().Model("youngee_m_kuaishou_userinfo").
					Where("phone_number = ?", state).
					Data(g.Map{
						"access_token": AccessToken,
						// 假设 m_res_info 中有 fields 例如 nickname 和 avatar
						"nickname":      m_res_info.Data.Name,
						"code":          code,
						"refresh_token": m_res_auth.RefreshToken,
						"open_id":       m_res_auth.OpenId,
						"create_time":   gtime.Now(),
						"update_time":   gtime.Now(),
						"expired":       0, //是否到期   1.后台两个小时刷新一次  2.获取list的时候需要将这个字段更新到数据中
						"is_delete":     0,
					}).
					Update()
			}
			//来自达人授权，获取accesstoken
			res_auth, _ := oauth.GetAccessToken(ClientKey, ClientSecret, code)
			r.Response.WriteJson("输出用户授权信息")
			r.Response.WriteJson(res_auth)
			//防止一个快手账号重复绑定
			userInfo := youngee_talent_model.KuaishouUserInfo{}
			//这个openid存在(如果对应到两条数据，只保留一条) 且对应的达人不是我,
			err := g.DB().Model("platform_kuaishou_user_info").Where("open_id = ? ", res_auth.OpenId).Order("platform_id DESC").Scan(&userInfo)
			if err != nil {
				r.Response.WriteJson(err)
				fmt.Println("查询数据库失败:", err)
			}
			//快手电商账号重复绑定，提示前端
			//此openId在表中有对应数据，且对应的达人不是当前达人
			if userInfo.TalentId != "" && userInfo.TalentId != state {
				redisKsBindStatusKey := fmt.Sprintf("Bind:%s", state)
				//redis设置绑定状态为
				_, err := g.Redis().Do("SETEX", redisKsBindStatusKey, 10, "bound_to_other")
				if err != nil {
					fmt.Println("redis出错")
					fmt.Println("err---->", err.Error())
				}
				return
			}

			//如果该快手账号（openID）已经有数据了，更新数据。没有数据则插入数据。
			_, err = g.DB().Model("platform_kuaishou_user_info").
				Where("open_id = ? AND platform_id = ?", res_auth.OpenId, 4).
				Delete()
			if err != nil {
				r.Response.WriteJson("platform_kuaishou_user_info delete failed")
			}
			AccessToken := res_auth.AccessToken
			//获取基本信息
			res_info, err := user.GetUserinfo(ClientKey, AccessToken)
			r.Response.WriteJson("输出用户基本信息")
			r.Response.WriteJson(res_info)
			//30天销量不在扫码时获取。
			err_auth := r.Response.WriteJson(res_auth)
			err_info := r.Response.WriteJson(res_info)
			if err_auth != nil {
				panic("write auth_response error")
			}
			if err_info != nil {
				panic("write auth_response error")
			}
			if res_auth.Result != 1 {
				panic("授权结果出错了")
			}
			if res_info.Result != 1 {
				panic("获取用户信息出错了")
			}
			//auth中含有最终信息
			authInfo := &youngee_talent_model.KuaishouUserInfo{
				Code:         code,
				TalentId:     state,
				AccessToken:  AccessToken,
				OpenId:       res_auth.OpenId,
				PlatformId:   4, //快手电商
				RefreshToken: res_auth.RefreshToken,
				HeadUri:      res_info.Data.Head,
				NickName:     res_info.Data.Name,
				Fan:          res_info.Data.Fan,
				City:         res_info.Data.City,
				Gender:       res_info.Data.Sex,
				UpdateTime:   gtime.Now(),
				CreateTime:   gtime.Now(),
			}
			if _, err := g.DB().Model("platform_kuaishou_user_info").Save(authInfo); err != nil {
				r.Response.WriteJson(g.Map{
					"error": err.Error(),
				})
				return
			}
		})
		//用于快手平台：nignx转发含code的请求到此处
		s.BindHandler("/kuaishouVideo", func(r *ghttp.Request) {
			fmt.Println("****进入rounter中的/kuaishouVideo*******")
			ClientKey := "ks671599294546520767"
			ClientSecret := "8VSrp3O09nunjLMXR1uotg"
			//SignSecret := "bf6393dce0a2b669ee348bebb837b0da"
			code := r.GetString("code")
			state := r.GetString("state")

			//获取accesstoken
			res_auth, _ := oauth.GetAccessToken(ClientKey, ClientSecret, code)

			userInfo := youngee_talent_model.KuaishouUserInfo{}
			//这个openid存在 且对应的达人不是我
			err := g.DB().Model("platform_kuaishou_user_info").Where("open_id = ? ", userInfo.OpenId).Scan(&userInfo)
			if err != nil {
				fmt.Println("查询数据库失败")
			}
			//抖音账号重复绑定，提示前端
			//此openId在表中有对应数据，且对应的达人不是当前达人，
			if userInfo.TalentId != "" && userInfo.TalentId != state {
				redisKsBindStatusKey := fmt.Sprintf("Bind:%s", state)
				//redis设置绑定状态为
				_, err := g.Redis().Do("SETEX", 10, redisKsBindStatusKey, "bound_to_other")
				if err != nil {
					fmt.Println("redis出错")
				}
				return
			}
			//如果该快手账号（openID）已经有数据了，删除。模拟在快手刷新授权 没有数据则空操作
			_, err = g.DB().Model("platform_kuaishou_user_info").
				Where("open_id = ? AND platform_id = ?", res_auth.OpenId, 8).
				Delete()
			if err != nil {
				r.Response.WriteJson("platform_kuaishou_user_info delete failed")
			}
			AccessToken := res_auth.AccessToken
			//获取基本信息
			res_info, _ := user.GetUserinfo(ClientKey, AccessToken)
			//视频数据
			videoCount, err := youngee_talent_service.GetVideoCount(ClientKey, AccessToken)
			likeCount, err := youngee_talent_service.GetLikeCount(ClientKey, AccessToken)
			//用户进入主页获取，并存入数据库中
			err_auth := r.Response.WriteJson(res_auth)
			err_info := r.Response.WriteJson(res_info)
			if err_auth != nil {
				panic("write auth_response error")
			}
			if err_info != nil {
				panic("write auth_response error")
			}
			if res_auth.Result != 1 {
				panic("授权结果出错了")
			}
			if res_info.Result != 1 {
				panic("获取用户信息出错了")
			}
			//auth中含有最终信息
			authInfo := &youngee_talent_model.KuaishouUserInfo{
				Code:         code,
				TalentId:     state,
				AccessToken:  AccessToken,
				OpenId:       res_auth.OpenId,
				PlatformId:   8, //快手平台
				RefreshToken: res_auth.RefreshToken,
				HeadUri:      res_info.Data.Head,
				NickName:     res_info.Data.Name,
				Fan:          res_info.Data.Fan,

				LikeNum:    likeCount,              //点赞数
				VideoNum:   videoCount.PublicCount, //作品数目
				UpdateTime: gtime.Now(),
				CreateTime: gtime.Now(),
				City:       res_info.Data.City,
				Gender:     res_info.Data.Sex,
			}
			if _, err := g.DB().Model("platform_kuaishou_user_info").Save(authInfo); err != nil {
				r.Response.WriteJson(g.Map{
					"error": err.Error(),
				})
				return
			}
		})
		//用于抖音平台：nignx转发含code的请求到此处
		s.BindHandler("/douyinauth", func(r *ghttp.Request) {
			ClientKey := "awi77xl5kpl16hmi"
			ClientSecret := "7ce6d2531bd4489122d89658063fd76e"
			code := r.GetString("code")
			state := r.GetString("state")
			//获取accesstoken
			res_auth, _ := douyinOauth.GetAccessToken(ClientKey, ClientSecret, code)
			douyinOpenId := res_auth.Data.OpenId
			userInfo := youngee_talent_model.KuaishouUserInfo{}
			//这个openid存在 且对应的达人不是我,
			err := g.DB().Model("platform_kuaishou_user_info").Where("open_id = ? and platform_id = ? ", douyinOpenId, 2).Scan(&userInfo)
			if err != nil {
				fmt.Println("查询数据库失败")
			}
			//抖音账号重复绑定，提示前端
			//此openId在表中有对应数据，且对应的达人不是当前达人，
			if userInfo.TalentId != "" && userInfo.TalentId != state {
				redisDyBindStatusKey := fmt.Sprintf("Bind:%s", state)
				//redis设置绑定状态为  10s过期
				_, err := g.Redis().Do("SETEX", 10, redisDyBindStatusKey, "bound_to_other")
				if err != nil {
					fmt.Println("redis出错")
				}
				return
			}
			//如果达人已经有抖音数据了，删除。模拟在抖音刷新授权 没有数据则空操作
			_, err = g.DB().Model("platform_kuaishou_user_info").
				Where("open_id = ? AND platform_id = ?  AND  talent_id = ?", douyinOpenId, 2, state).
				Delete()
			if err != nil {
				r.Response.WriteJson("抖音账号覆盖失败")
			}
			AccessToken := res_auth.Data.AccessToken
			//获取基本信息
			res_info, _ := douyinUser.GetUserInfo(res_auth.Data.OpenId, AccessToken)
			//获取用户粉丝数  千粉以上
			//res_fans, _ := douyinUser.GetUserFans(AccessToken, "7", douyinOpenId) //近7天，返回一个列表每天都有总粉丝数
			//errCode := res_fans.Data.ErrorCode
			//var fansNumStr string
			//if errCode == 0 { // 满足千粉以上
			//	fansNumStr = res_fans.Data.ResultList[0].TotalFans
			//} else {
			//	fansNumStr = "0"
			//}
			//fansNum, err := strconv.Atoi(fansNumStr)
			//if err != nil {
			//	fmt.Println("Error converting string to int:", err)
			//	// 可以在这里添加错误处理逻辑
			//}
			//获取抖音作品数目和点赞数目
			VideoInfo, _ := youngee_talent_service.GetDyVideoInfo(douyinOpenId, AccessToken)
			//用户进入主页获取，并存入数据库中
			err_auth := r.Response.WriteJson(res_auth)
			err_info := r.Response.WriteJson(res_info)
			if err_auth != nil {
				panic("write auth_response error")
			}
			if err_info != nil {
				panic("write auth_response error")
			}
			if res_auth.Data.ErrorCode != 0 {
				panic("抖音授权结果出错了")
			}
			if res_info.Data.ErrorCode != 0 {
				panic("抖音获取用户信息出错了")
			}
			//auth中含有最终信息
			authInfo := &youngee_talent_model.KuaishouUserInfo{
				Code:         code,
				TalentId:     state,
				AccessToken:  AccessToken,
				OpenId:       douyinOpenId,
				PlatformId:   2, //抖音平台
				RefreshToken: res_auth.Data.RefreshToken,
				HeadUri:      res_info.Data.Avatar,
				NickName:     res_info.Data.Nickname,
				//Fan:          fansNum, //专门获取粉丝数的接口，默认为0。
				VideoNum:   VideoInfo.VideoCount,
				LikeNum:    VideoInfo.LikeCount,
				UpdateTime: gtime.Now(),
				CreateTime: gtime.Now(),
			}
			//sava，有数据则更新，没有数据则插入
			if _, err := g.DB().Model("platform_kuaishou_user_info").Save(authInfo); err != nil {
				r.Response.WriteJson(g.Map{
					"error": err.Error(),
				})
				return
			}
		})
		//微信支付的回调，被nginx重定向到此
		s.BindHandler("/WxPayCallBack", func(r *ghttp.Request) {
			//微信响应回来的请求头和请求体中有 是否支付成功的内容
			//if 支付成功
			//1. 构造生产者的消息
			//2. 发送消息给MQ的指定topic 消费者监听这个topic进行订单表、支付表、用户表的更新操作【异步 ， 解耦 】
			//3. 返回给前端支付成功的标识
			//else 支付失败
			//响应支付失败
		})
		// 达人不需要鉴权的接口
		group.GET("/g", youngeetalentapi.TalentGetApi)
		group.POST("/p", youngeetalentapi.TalentPostApi)

		// 达人需要鉴权的接口
		group.Group("/t", func(group *ghttp.RouterGroup) {
			group.Middleware(middleware.DuplicateVerify, middleware.WxAuth)
			group.GET("/g", youngeetalentapi.TalentAuthGetApi)
			group.POST("/p", youngeetalentapi.TalentAuthPostApi)
		})
	})
	// v2小程序端接口
	s.Group("/youngee/c/api", func(group *ghttp.RouterGroup) {
		group.Middleware(middleware.ErrorHandler)

		//// 达人不需要鉴权的接口
		//group.GET("/g", youngeetalentapi.TalentGetApi)
		//group.POST("/p", youngeetalentapi.TalentPostApi)

		group.Group("/selection", func(group *ghttp.RouterGroup) {
			group.GET("/list", sectask.SecTask.List)
		})

		// 达人需要鉴权的接口
		group.Group("/t", func(group *ghttp.RouterGroup) {
			group.Middleware(middleware.DuplicateVerify, middleware.WxAuth)
			group.Group("/secTask", func(group *ghttp.RouterGroup) {
				group.GET("/list", sectask.SecTask.List)
				group.GET("/list-tab", sectask.SecTask.ListTab)
				group.GET("/logistics/detail", sectask.SecTask.ShowLogisticsDetail)
			})
			group.Group("/assignment", func(group *ghttp.RouterGroup) {
				group.GET("/list", assignment.Assignment.List)
				group.POST("/add", assignment.Assignment.Add)
			})
			group.Group("/wxpay", func(group *ghttp.RouterGroup) {
				group.POST("/pay", wxpay.WxPay.WxPay)
			})
		})
	})
}