mh_server/controller/game_card.go

package controller

import (
	"crypto/md5"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"github.com/rs/zerolog/log"
	"io/ioutil"
	"mh-server/config"
	aliyun "mh-server/lib/ali"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/wxpay"
	"mh-server/model"
	"sort"
	"strings"
	"time"
)

func GameCardList(c *gin.Context) {
	req := struct {
		Page        int      `json:"cur_page"`
		PageSize    int      `json:"page_size"`
		SortType    int      `json:"sort_type"`    // 排序类型 1-默认 2-新品 3-销量 4-价格 大到小 5-价格 小到大
		GameTypeIds []uint64 `json:"game_type_id"` // 游戏类型id
		StoreId     uint32   `json:"store_id"`
	}{
		Page:     1,
		PageSize: 10,
	}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("游戏类型:GameTypeIds:", req.GameTypeIds)

	cardList, totalPage, err := model.GetGameCardList(req.SortType, req.Page, req.PageSize, req.GameTypeIds, req.StoreId)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"card_list":  cardList,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
}

func GameCardInfo(c *gin.Context) {
	req := struct {
		GameId uint64 `json:"game_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	go model.HistoryBrowsingAdd(uint64(uc.Uid), req.GameId)

	info, err := model.GetGameCardInfo(req.GameId)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	userCollection := model.GameCardUserCollection(uint64(uc.Uid), req.GameId)

	ret := map[string]interface{}{
		"card_info":     info,
		"is_collection": userCollection,
	}
	RespOK(c, ret)
}

func GameCardSearch(c *gin.Context) {
	req := struct {
		Page     int    `json:"page"`
		PageSize int    `json:"page_size"`
		Name     string `json:"name"` // 搜索
		StoreId  uint32 `json:"store_id"`
	}{
		Page:     1,
		PageSize: 10,
	}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	cardList, totalPage, err := model.GetGameCardSearch(req.Name, req.Page, req.PageSize, req.StoreId)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.SearchHistoryAdd(uc.Uid, req.Name)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	ret := map[string]interface{}{
		"card_list":  cardList,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
}

func GameCardSearchHistory(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	historyList, err := model.GetSearchHistoryList(uc.Uid)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, historyList)
}

func GameCardHotSearch(c *gin.Context) {
	searchList, err := model.HotSearchList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, searchList)
}

func HomeCarouselList(c *gin.Context) {
	carouselList, err := model.GetHomeCarouselList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, carouselList)
}

func GameCardTypeList(c *gin.Context) {
	gameTypes, err := model.GetGameCardTypeList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, gameTypes)
	return
}

func GameCardTypes(c *gin.Context) {
	req := struct {
		GameId uint64 `json:"game_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	gameCard := model.GameCard{}
	gameCard.ID = uint32(req.GameId)

	gameTypes, err := gameCard.GetGameType()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, gameTypes)
	return
}

type (
	PushTemplateMessageTarget struct {
		Uid      uint32 `json:"uid"`
		WxName   string `json:"wx_name"`
		WxOpenID string `json:"wx_open_id"`
		FormIdID uint32 `json:"form_id_id"`
		FormId   string `json:"form_id"`
	}

	WXPayNoticeResp struct {
		XMLName    xml.Name `xml:"xml"`
		ReturnCode string   `xml:"return_code" json:"return_code"`
	}
)

const (
	PRIZE_WX_PAY_TYPE = "pwxpt"
	FB_WX_PAY_TYPE    = "fbwxpt"
)

//  0 元购 微信推送支付通知
func PushWXPayNotice(c *gin.Context) {
	fmt.Println("微信推送支付通知")
	body, err := ioutil.ReadAll(c.Request.Body)
	if err != nil {
		logger.Error(err)
	}

	logger.Error("xml Request.Body1:", string(body))
	var notify wxpay.WechatNotifyInfo
	//if err := c.ShouldBindXML(&notify); err != nil {
	//	logger.Error(err)
	//	RespBodyXML(c, map[string]string{
	//		"return_code": "FAIL",
	//	})
	//	return
	//}

	err = xml.Unmarshal(body, &notify)
	if err != nil {
		logger.Error(err)
	}
	ret := WXPayNoticeResp{
		ReturnCode: "FAIL",
	}
	correctSign, err := PayCallBackHandle(notify, config.AppConfig.WxMchSecret)

	if err != nil {
		logger.Error("PushWXPayNotice sign create fail")
		RespBodyXML(c, ret)
		return
	}
	if notify.Sign != correctSign {
		logger.Error("PushWXPayNotice sign verification fail")
		RespBodyXML(c, ret)
		return
	}

	if notify.Attach == wxpay.WxPayRentCard {
		logger.Info("租借游戏卡 支付成功:")

		err = model.NewOrderQuerySet(model.DB).OrderSnEq(notify.OutTradeNo).GetUpdater().
			SetPayStatus(model.PayStatusPaid).SetPayTime(time.Now()).Update()
		if err != nil {
			logger.Error("err:", err)
		}

	} else if notify.Attach == wxpay.WxPayMember {

		logger.Info("开通会员 支付成功:")

		logger.Info("用户uid:", notify.OutTradeNo)

		//uid, err := strconv.Atoi(notify.OutTradeNo)
		//if err != nil {
		//	logger.Error("err:", err)
		//	return
		//}
		record := &model.UserOpenMemberRecord{OpenNo: notify.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("err:", err)
		} else {
			//expireTime := user.MemberExpire.AddDate(1, 0, 0)
			//if user.MemberLevel == 1 {
			//	expireTime = time.Now().AddDate(1, 0, 0)
			//}
			expireTime := time.Now().AddDate(1, 0, 0)
			if user.MemberExpire.After(time.Now()) {
				expireTime = user.MemberExpire.AddDate(1, 0, 0)
			}

			//configInfo, err := model.PayConfigInfo()
			//if err != nil {
			//	logger.Error("err:", err)
			//	return
			//}
			memberConfig, err := model.GetMemberConfig(record.MemberLevel)
			if err != nil {
				logger.Error("GetMemberConfig err:", err)
				return
			}

			err = model.UserUpdate(&model.User{Uid: uint32(record.Uid), MemberLevel: record.MemberLevel, MemberExpire: expireTime, Deposit: memberConfig.MemberDeposit})
			if err != nil {
				logger.Error("err:", err)
			}

			var invite model.UserInvite
			err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).One(&invite)
			if err != nil && err != model.RecordNotFound {
				logger.Error("err:", err)
			} else {
				if err == model.RecordNotFound {
					userInvite := &model.UserInvite{
						FromUid:        0,
						UserType:       0,
						StoreId:        0,
						MemberOpenTime: time.Now(),
						MemberType:     2,
						ToUid:          record.Uid,
						MemberStatus:   2,
						MemberLevel:    record.MemberLevel,
					}
					err := userInvite.Create(model.DB)
					if err != nil {
						logger.Error("err:", err)
					}
				} else {
					qs := model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).GetUpdater()
					if user.MemberLevel != 2 {
						qs = qs.SetMemberOpenTime(time.Now()).SetMemberLevel(record.MemberLevel)
					}
					num, err := qs.SetMemberType(2).SetMemberStatus(2).UpdateNum()
					if err != nil {
						logger.Error("err:", err)
					}
					if num == 0 {
						logger.Error("更新错误")
					}

					if invite.FromUid != 0 {
						inviteUser := model.GetUserByUid(invite.FromUid)
						if inviteUser.UserType != 2 && user.MemberLevel != 2 { // 邀请 新用户推送一次
							err := model.CodeSendToUser(invite.FromUid, model.CodeTypeMemberCard30, model.RedeemCodeActivityTypeUserInvite)
							if err != nil {
								logger.Error("err:", err)
							}
						}
					}
				}
			}

			if user.MemberLevel != 2 {
				err = model.CodeSendToUser(user.Uid, model.CodeTypeMemberCard30, model.RedeemCodeActivityTypeStore)
				if err != nil {
					logger.Error("err:", err)
				}
			}

		}

		fmt.Println("notify.TotalFee:", notify.TotalFee)
		fmt.Println("notify.OutTradeNo:", notify.OutTradeNo)

	} else if notify.Attach == wxpay.WxPayDeposit {
		record := &model.UserOpenMemberRecord{OpenNo: notify.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}

		configInfo, err := model.PayConfigInfo()
		if err != nil {
			logger.Error("err:", err)
			return
		}

		num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetDeposit(configInfo.DepositFee).UpdateNum()
		if err != nil {
			logger.Error("update deposit err:", err)
		}
		if num == 0 {
			logger.Error("update deposit num is 0")
		}
	}

	logger.Debug("微信推动支付通知")
	ret.ReturnCode = "SUCCESS"
	RespBodyXML(c, ret)
}

func PayCallBackHandle(notify wxpay.WechatNotifyInfo, payKey string) (string, error) {

	m, err := struct2Map(notify)
	if err != nil {
		return "", err
	}

	sign, err := GenWechatPaySign(m, payKey)

	if err != nil {
		return "", err
	}
	sign = strings.ToUpper(sign)
	logger.Error("微信推送支付通知  sign : payKey", sign, payKey)
	return sign, err
}

func GenWechatPaySign(m map[string]string, payKey string) (string, error) {
	delete(m, "sign")
	var signData []string
	for k, v := range m {
		if v != "" && v != "0" {
			signData = append(signData, fmt.Sprintf("%s=%s", k, v))
		}
	}

	sort.Strings(signData)
	signStr := strings.Join(signData, "&")
	signStr = signStr + "&key=" + payKey
	logger.Error("签字符串1 :", signStr)
	c := md5.New()
	_, err := c.Write([]byte(signStr))
	if err != nil {
		return "", err
	}

	signByte := c.Sum(nil)
	if err != nil {
		return "", err
	}

	return fmt.Sprintf("%x", signByte), nil
}

func struct2Map(r interface{}) (s map[string]string, err error) {
	var temp map[string]interface{}
	var result = make(map[string]string)

	bin, err := json.Marshal(r)
	if err != nil {
		return result, err
	}

	if err := json.Unmarshal(bin, &temp); err != nil {
		return nil, err
	}
	for k, v := range temp {
		switch v2 := v.(type) {
		case string:
			result[k] = v2
		case uint, int8, uint8, int, int16, uint16, int32, uint32, int64, uint64:
			result[k] = fmt.Sprintf("%d", v2)
		case float32, float64:
			result[k] = fmt.Sprintf("%.0f", v2)
		}
	}

	return result, nil
}

func AliyunStsTokenGet(c *gin.Context) {
	uploadInfo, err := aliyun.GenStsToken("21000505")
	if err != nil {
		log.Error().Msgf("err=%v", err)
		return
	}

	stsToken := model.RspAliyunStsToken{
		AccessKeyId:     uploadInfo.AccessKeyId,
		AccessKeySecret: uploadInfo.AccessKeySecret,
		SecurityToken:   uploadInfo.SecurityToken,
		BucketName:      uploadInfo.BucketName,
		Expiration:      uint64(uploadInfo.Expiration),
	}

	RespOK(c, stsToken)
}