mh_server/controller/game_card.go

package controller

import (
	"context"
	"crypto/md5"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"mh-server/config"
	aliyun "mh-server/lib/ali"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/utils"
	"mh-server/lib/wxpay"
	"mh-server/model"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"github.com/rs/zerolog/log"
	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
	"github.com/wechatpay-apiv3/wechatpay-go/core/downloader"
	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
	wechatpayutils "github.com/wechatpay-apiv3/wechatpay-go/utils"
)

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 {
		logger.Error("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		//RespJson(c, status.Unauthorized, nil)
		//return
		uc = &auth.UserClaims{Uid: 0}
	}
	fmt.Println("游戏类型:GameTypeIds:", req.GameTypeIds)

	cardList, totalPage, err := model.GetGameCardList(req.SortType, req.Page, req.PageSize,
		req.GameTypeIds, req.StoreId, uc.Uid)
	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"`
		StoreId uint32 `json:"store_id"` // 门店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
		info, err := model.GetGameCardInfo(req.GameId, req.StoreId)
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		ret := map[string]interface{}{
			"card_info":     info,
			"is_collection": false,
		}
		RespOK(c, ret)
		return
	}

	go func() {
		err := model.HistoryBrowsingAdd(uint64(uc.Uid), req.GameId)
		if err != nil {
			log.Error().Msgf("history browsing add err:%#v", err)
		}
	}()

	info, err := model.GetGameCardInfo(req.GameId, req.StoreId)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	if user.IsMember() {
		info.RealPrice = 0
	}
	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
	}

	if uc != nil { // 登录过的用户才记录搜索历史
		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)
		RespOK(c, []model.SearchHistory{})
		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) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		//RespJson(c, status.Unauthorized, nil)
		//return
		uc = &auth.UserClaims{Uid: 0}
	}
	carouselList, err := model.GetHomeCarouselList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var activityMemberRenewal model.ActivityMemberRenewal
	if uc.Uid != 0 {
		err = model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
			Limit(1).One(&activityMemberRenewal)
		if err != nil && err != model.RecordNotFound {
			logger.Error("activity member renewal err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	user := model.GetUserByUid(uc.Uid)
	if uc.Uid == 0 || !user.IsMember() || !(user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0))) ||
		activityMemberRenewal.State == 3 {
		//	&& user.MemberExpire.After(utils.Now()))
		list := make([]model.HomeCarousel, 0, len(carouselList))
		for i, _ := range carouselList {
			if carouselList[i].ActivityType == 1 {
				continue
			}
			list = append(list, carouselList[i])
		}
		carouselList = list
	}

	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"`
	}
)

// PushWXPayNotice TODO两边都改
//
//	微信推送支付通知
func PushWXPayNotice(c *gin.Context) {
	fmt.Println("微信推送支付通知-start")
	body, err := ioutil.ReadAll(c.Request.Body)
	if err != nil {
		logger.Error(err)
	}

	logger.Info("xml Request.Body1:", string(body))
	var notifyInfo wxpay.WechatNotifyInfo
	err = xml.Unmarshal(body, &notifyInfo)
	if err != nil {
		logger.Error(err)
	}
	ret := WXPayNoticeResp{
		ReturnCode: "FAIL",
	}
	correctSign, err := PayCallBackHandle(notifyInfo, config.AppConfig.WxMchSecret)
	if err != nil {
		logger.Error("PushWXPayNotice sign create fail")
		RespBodyXML(c, ret)
		return
	}
	if notifyInfo.Sign != correctSign {
		logger.Error("PushWXPayNotice sign verification fail")
		RespBodyXML(c, ret)
		return
	}
	fundRecord := new(model.FundRecord)
	if notifyInfo.Attach == wxpay.WxPayRentCard {
		logger.Info("租借游戏卡 支付成功:")
		var order model.Order
		err := model.NewOrderQuerySet(model.DB).OrderSnEq(notifyInfo.OutTradeNo).
			PayStatusEq(PayStatusUnPay).CardStatusNe(OrderCardStatusCancel).One(&order)
		if err != nil {
			logger.Error("err:", err)
			return
		}
		//orderJson, _ := json.Marshal(&order)
		//fmt.Println("orderJson:", string(orderJson))

		begin := model.DB.Begin()
		err = model.NewOrderQuerySet(begin).IDEq(order.ID).GetUpdater().
			SetPayStatus(model.PayStatusPaid).SetPayTime(time.Now()).Update()
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}
		//model.OrderCard{}
		_, err = model.NewOrderCardQuerySet(begin).OrderIdEq(order.ID).GetUpdater().
			SetPayStatus(model.PayStatusPaid).UpdateNum()
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}

		sub := model.DeliverTaskSub{
			Uid:           uint32(order.Uid),
			UserAddressId: uint32(order.UserAddressId),
			OrderType:     1,
			OrderId:       order.ID,
			StoreId:       uint32(order.StoreId),
		}
		err = sub.Add()
		if err != nil {
			logger.Error("deliver task sub add err:", err)
		}

		err = order.InventoryReduction(begin)
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			if order.PostageType == 1 {
				// 库存不足取消订单
				orderSn := model.GetOrderSn()
				memberRecord := &model.UserOpenMemberRecord{OpenNo: orderSn, OrderType: 2, Order: &order}
				err = memberRecord.OrderRefund(notifyInfo.OutTradeNo)
				if err != nil {
					logger.Error("err:", err)
					return
				}
			}

			// TODO
			if order.PostageType == 2 {
				var userCoupon model.UserCoupon
				err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uint32(order.Uid)).
					StateEq(2).OrderAscByID().Limit(1).One(&userCoupon)
				if err != nil && err != model.RecordNotFound {
					logger.Error("user coupon err:", err)
					RespJson(c, status.InternalServerError, nil)
					return
				}
				err = model.NewUserCouponQuerySet(model.DB).IDEq(userCoupon.ID).GetUpdater().SetState(1).Update()
				if err != nil {
					logger.Error("user coupon err:", err)
				}
			}

			//err = model.UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 2}.Insert()
			//if err != nil {
			//	logger.Error(errors.New("WebPay err"))
			//	//RespJson(c, status.InternalServerError, nil)
			//	return
			//}
			//orderRefund := wxpay.OrderRefund{
			//	//OutTradeNo:  outTradeNo,
			//	OutTradeNo:  notify.OutTradeNo,
			//	OutRefundNo: orderSn,
			//	NotifyUrl:   "",
			//	Amount: wxpay.OrderRefundAmount{
			//		Refund:   order.PayPrice,
			//		Total:    order.PayPrice,
			//		Currency: "CNY",
			//	},
			//}
			////bytes, _ := json.Marshal(order)
			////fmt.Println("订单取消:", string(bytes))
			////orderRefundJson, _ := json.Marshal(&orderRefund)
			////fmt.Println("订单取消 orderRefundJson:", string(orderRefundJson))
			//////err = wxpay.WxPayOrderRefund(orderRefund)
			//err = wxpay.TransactionOrderRefund(orderRefund)
			//if err != nil {
			//	logger.Error("err:", err)
			//	//RespJson(c, status.InternalServerError, nil)
			//	return
			//}

			_, err := model.NewOrderQuerySet(model.DB).IDEq(order.ID).GetUpdater().
				SetCardStatus(OrderCardStatusCancel).UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}
			_, err = model.NewOrderCardQuerySet(model.DB).OrderIdEq(order.ID).GetUpdater().
				SetCardStatus(OrderCardStatusCancel).UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}

			return
		}
		err = begin.Commit().Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}
		go model.ShoppingCartCreateOrderByOrder(order)

		fundRecord.Uid = uint32(order.Uid)
		fundRecord.FundType = model.FundTypeExpressFee
		fundRecord.Remark = "借卡邮费"

	}

	if notifyInfo.Attach == wxpay.WxPayMember {
		logger.Info("开通会员 支付成功:")
		logger.Info("用户uid:", notifyInfo.OutTradeNo)

		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}

		remark := ""
		if record.MemberLevel == model.MemberLevelGold {
			if record.MemberGenre != model.MemberGenreQuarter && record.MemberGenre != model.MemberGenreHalfYear {
				record.MemberGenre = model.MemberGenreYear // 新增：如果是年费黄金会员则member_genre设置为200
			}
			remark = "黄金会员费"
		} else if record.MemberLevel == model.MemberLevelPlatinum {
			remark = "白金会员费"
		} else if record.MemberLevel == model.MemberLevelBlackGold {
			remark = "黑金会员费"
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberFee
		fundRecord.Remark = remark
		// 支付金额小于100（99或者49）的情况是：白金会员过期后没退押金，然后直接开通黄金会员
		if notifyInfo.TotalFee < 10000 {
			fundRecord.FundType = model.FundTypeDowngradeRenewal
		}
		memberRecord := &model.UserMemberRecord{
			Uid:              record.Uid,
			AfterMemberLevel: record.MemberLevel,
		}
		newTime := time.Now()
		var spendType uint32
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("err:", err)
			return
		} else {
			spendType = uint32(2) // 2-开通会员
			if !user.OpenMemberTime.IsZero() {
				spendType = 3 // 3-续费
			}
			isShopAssistantCode := false

			var expireTime time.Time
			if record.MemberGenre == model.MemberGenreQuarter { // 季度黄金
				expireTime = newTime.AddDate(0, 0, 90)
			} else if record.MemberGenre == model.MemberGenreHalfYear { // 半年黄金
				expireTime = newTime.AddDate(0, 0, 180)
			} else {
				expireTime = newTime.AddDate(1, 0, 0)
			}

			if user.MemberExpire.After(newTime) {
				//expireTime = user.MemberExpire.AddDate(1, 0, 0)
				if record.MemberGenre == model.MemberGenreQuarter {
					expireTime = user.MemberExpire.AddDate(0, 0, 90)
				} else if record.MemberGenre == model.MemberGenreHalfYear {
					expireTime = user.MemberExpire.AddDate(0, 0, 180)
				} else {
					expireTime = user.MemberExpire.AddDate(1, 0, 0)
				}
			}

			memberRecord.BeforeMemberLevel = user.MemberLevel
			memberRecord.BeforeMemberExpire = user.MemberExpire
			memberRecord.Serial = uint32(user.MemberExpire.Unix())
			memberRecord.AfterMemberExpire = expireTime
			if user.IsMember() {
				memberRecord.OpenMemberLevel = user.OpenMemberLevel
				memberRecord.OpenMemberTime = user.OpenMemberTime
			} else {
				memberRecord.OpenMemberLevel = record.MemberLevel
				memberRecord.OpenMemberTime = newTime
			}
			memberConfig, err := model.GetMemberConfig(record.MemberLevel, record.MemberGenre)
			if err != nil {
				logger.Error("GetMemberConfig err:", err)
				return
			}
			//openMemberTime := newTime
			userUpdateQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
				SetMemberGenre(record.MemberGenre).SetMemberExpire(expireTime).SetDeposit(memberConfig.MemberDeposit)
			if user.OpenMemberTime.IsZero() {
				//openMemberTime = user.OpenMemberTime
				userUpdateQs = userUpdateQs.SetOpenMemberTime(newTime).SetOpenMemberLevel(record.MemberLevel)
				memberRecord.Type = model.GetUserMemberRecordType(record.MemberLevel, 1) // 开通会员类型
			} else {
				memberRecord.Type = model.GetUserMemberRecordType(record.MemberLevel, 2) // 续费会员类型
			}
			_, err = userUpdateQs.UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}

			if record.UserCouponId > 0 { // 如果使用了会员优惠券，更新优惠券状态为2-已使用
				err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
					SetState(2).SetUseTime(utils.Now()).Update()
				if err != nil {
					logger.Error("update user coupon state err:", err)
				}

				var userCoupon model.UserCoupon
				err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
				if err != nil {
					logger.Error("user coupon err:", err)
				} else {
					if userCoupon.Approach == 1 { // 当优惠券是通过店员兑换码获取，则创建邀请记录；此类用户是会员续费用户
						isShopAssistantCode = true
						err = model.StorePromotion(userCoupon.PromotionalSales, userCoupon.Uid, nil, &user)
						if err != nil {
							logger.Error("store promotion err:", err)
						}
					}
				}
			}

			// 邀请记录
			var invite model.UserInvite
			logger.Info("record.Uid:", record.Uid)
			err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).OrderDescByCreatedAt().Limit(1).One(&invite)
			logger.Info("invite:", invite)
			logger.Info("invite ID:", invite.ID)
			if err != nil && err != model.RecordNotFound {
				logger.Error("err:", err)
			} else {
				if err == nil {
					logger.Info("111")
					effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
					if err != nil {
						logger.Error("GetUserEffectiveStore err:", err)
						effectiveStoreInfo.StoreID = 0
					}

					if invite.Action == 1 { //  1-未激活 用户首次开通
						logger.Info("invite.Action == 1")
						qs := model.NewUserInviteQuerySet(model.DB).IDEq(invite.ID).GetUpdater()
						if isShopAssistantCode {
							qs = qs.SetInviteForm(1)
							invite.RenewHide = 0 // 干预
						} else {
							invite.RenewHide = 1 // 自动
						}
						qs = qs.SetMemberOpenTime(newTime).SetMemberLevel(record.MemberLevel)
						_, err = qs.SetMemberType(2).SetMemberStatus(2).
							SetAction(2).SetSpendType(spendType).SetMemberGenre(record.MemberGenre).UpdateNum()
						if err != nil {
							logger.Error("update user invite action spend type err:", err)
						}
						if invite.UserInviteRecordId != 0 {
							go func() {
								err = model.NewUserInviteRecordQuerySet(model.DB).IDEq(invite.UserInviteRecordId).GetUpdater().
									SetAction(2).SetSpendType(spendType).SetMemberLevel(record.MemberLevel).
									SetActionTime(newTime).SetMemberGenre(record.MemberGenre).SetRenewHide(invite.RenewHide).Update()
								if err != nil {
									logger.Error("update user invite record err:", err)
								}
							}()
						}
					} else { // 续费会员-用户直接续费
						logger.Info("invite.Action == 2")
						inviteRecordNew := &model.UserInviteRecord{
							ToUid:       invite.ToUid,
							FromUid:     invite.FromUid,
							StoreId:     effectiveStoreInfo.StoreID,
							Action:      2,
							SpendType:   spendType,
							MemberLevel: record.MemberLevel,
							First:       0,
							Scan:        0, // 自动生成
							ActionTime:  newTime,
							MemberGenre: record.MemberGenre,
							RenewHide:   1,
						}
						if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
							inviteRecordNew.Scan = 1
							inviteRecordNew.RenewHide = 0 // 店员干预续费
							//inviteRecordNew.FromUid = invite.FromUid
							//inviteRecordNew.StoreId = effectiveStoreInfo.StoreID
						}
						err = model.DB.Create(inviteRecordNew).Error
						if err != nil {
							logger.Error("create  invite record err:", err)
						}

						userInviteNew := &model.UserInvite{
							FromUid:            invite.FromUid,
							UserType:           invite.UserType,
							StoreId:            effectiveStoreInfo.StoreID,
							StoreType:          invite.StoreType,
							MemberOpenTime:     time.Now(),
							MemberType:         2,
							MemberStatus:       2,
							ToUid:              invite.ToUid,
							Action:             2,
							SpendType:          spendType,
							MemberLevel:        record.MemberLevel,
							UserInviteRecordId: inviteRecordNew.ID,
							FirstInvite:        0,
							Scan:               0,
							MemberGenre:        record.MemberGenre,
							RenewHide:          1,
						}
						if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
							userInviteNew.Scan = 1
							userInviteNew.RenewHide = 0
							userInviteNew.InviteForm = 1
							//userInviteNew.FromUid = invite.FromUid
							//userInviteNew.StoreId = effectiveStoreInfo.StoreID
							//userInviteNew.UserType = invite.UserType
							//userInviteNew.StoreType = invite.StoreType
						}
						err = model.DB.Create(userInviteNew).Error
						if err != nil {
							logger.Error("create  invite record err:", err)
						}
					}

					if invite.FromUid != 0 {
						inviteUser := model.GetUserByUid(invite.FromUid)
						if inviteUser != nil {
							openMemberChannel := model.OpenMemberChannelUserInvite
							userQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater()

							if inviteUser.UserType == 2 {
								openMemberChannel = model.OpenMemberChannelStorePromotion
								if !user.OpenMemberTime.IsZero() {
									userQs = userQs.SetCooperativeBusinessId(inviteUser.CooperativeBusinessId).
										SetCooperativeName(inviteUser.CooperativeName)

									effectiveStoreId := invite.StoreId
									autoRenewFlag := true    // 自动续费
									if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
										effectiveStoreId = effectiveStoreInfo.StoreID
										userQs = userQs.SetStoreId(effectiveStoreId) // 更新用户门店：邀请人的有效门店
										autoRenewFlag = false                        // 店员干预续费
									}

									fmt.Println("用户续费---")
									model.AddCooperativeMemberRenewal(inviteUser.CooperativeBusinessId,
										uint32(effectiveStoreId), inviteUser.Uid, int(record.MemberLevel),
										int(record.MemberGenre), autoRenewFlag)
								} else {
									fmt.Println("用户开通------")
									model.AddCooperativeMemberPromotion(inviteUser.CooperativeBusinessId,
										uint32(effectiveStoreInfo.StoreID), inviteUser.Uid, int(record.MemberLevel),
										int(record.MemberGenre))
								}
								userQs = userQs.SetStoreId(effectiveStoreInfo.StoreID) // 更新用户门店：邀请人的有效门店
							}

							_, err = userQs.SetOpenMemberChannel(openMemberChannel).UpdateNum()
							if err != nil {
								logger.Error("err:", err)
							}
						}
					}
				} else if err == model.RecordNotFound { // 没有邀请记录，完全是用户自己开通会员，自己续费；按产品要求也需要有记录
					inviteRecordNew := &model.UserInviteRecord{
						ToUid:       user.Uid,
						Action:      2,
						SpendType:   spendType,
						MemberLevel: record.MemberLevel,
						First:       0,
						Scan:        0, // 自动生成
						ActionTime:  newTime,
						MemberGenre: record.MemberGenre,
						RenewHide:   1,
					}
					err = model.DB.Create(inviteRecordNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}

					// 记录对应的数量
					switch spendType {
					case 2: // 开通
						fmt.Println("用户开通------")
						model.AddCooperativeMemberPromotion(user.CooperativeBusinessId, 0, 0,
							int(record.MemberLevel), int(record.MemberGenre))
					case 3: // 续费
						fmt.Println("用户续费---")
						model.AddCooperativeMemberRenewal(user.CooperativeBusinessId, 0, 0,
							int(record.MemberLevel), int(record.MemberGenre), true)
					}
				}
			}

			// 赠送积分
			err = model.NewSendUserVm(user.Uid, uint32(notifyInfo.TotalFee/100), spendType)
			if err != nil {
				logger.Error("send user vm err:", err)
			}

			go func() {
				err = model.DB.Create(memberRecord).Error
				if err != nil {
					logger.Error("create member record err:", err)
				}
			}()
			model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).
			GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fmt.Println("notify.TotalFee:", notifyInfo.TotalFee)
		fmt.Println("notify.OutTradeNo:", notifyInfo.OutTradeNo)
	}

	if notifyInfo.Attach == wxpay.WxPayDeposit {
		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
			return
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}

		//if record.State != 2 {
		user := model.GetUserByUid(record.Uid)
		if user == nil {
			logger.Error("user nil")
			return
		}

		memberConfig, err := model.GetMemberConfig(user.MemberLevel, user.MemberGenre)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		remark := ""
		if user.MemberLevel == 2 {
			remark = "黄金会员押金"
		} else if user.MemberLevel == 4 {
			remark = "白金会员押金"
		} else if user.MemberLevel == 5 {
			remark = "黑金会员押金"
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberDeposit
		fundRecord.Remark = remark

		num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().
			SetDeposit(memberConfig.MemberDeposit).UpdateNum()
		if err != nil {
			logger.Error("update deposit err:", err)
		}
		if num == 0 {
			logger.Error("update deposit num is 0")
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		//}
	}

	if notifyInfo.Attach == wxpay.WxPayBuyGoods {
		_, err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notifyInfo.OutTradeNo).GetUpdater().
			SetPayTime(time.Now()).
			SetPayStatus(model.PayStatusOK).
			SetState(model.GoodsOrderStateOnDeliver).UpdateNum()

		if err != nil {
			logger.Error("err:", err)
		}
		var goodsOrder model.GoodsOrder
		err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notifyInfo.OutTradeNo).One(&goodsOrder)
		if err != nil {
			logger.Error("err:", err)
		}

		err = model.OrderUpdateGoodsStock(goodsOrder.GoodsAttributeId, goodsOrder.Quantity, model.DB)
		if err != nil {
			logger.Error("err:", err)
		}

		err = model.UserVmUpdate(goodsOrder.Uid, int(goodsOrder.Vm)*-1, model.VmEventBuyGoods, "购买商品积分抵扣")
		if err != nil {
			logger.Error("err:", err)
		}
		sub := model.DeliverTaskSub{
			Uid:           uint32(goodsOrder.Uid),
			UserAddressId: uint32(goodsOrder.AddressId),
			OrderType:     2,
			OrderId:       goodsOrder.OrderId,
			StoreId:       13,
		}
		err = sub.Add()
		if err != nil {
			logger.Error("deliver task sub add err:", err)
		}
		fundRecord.Uid = uint32(goodsOrder.Uid)
		fundRecord.FundType = model.FundTypeBuyGoods
		fundRecord.Remark = "商城购买"
	}

	if notifyInfo.Attach == wxpay.WxPayUpgradeMember {
		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}
		isShopAssistantCode := false

		fmt.Println("UpgradeMember:", record.Uid)
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("user err:", err)
			return
		}

		memberRecord := &model.UserMemberRecord{
			Uid:                record.Uid,
			BeforeMemberLevel:  user.MemberLevel,
			AfterMemberLevel:   record.MemberLevel,
			BeforeMemberExpire: user.MemberExpire,
			AfterMemberExpire:  record.MemberExpire,
			InviteUid:          0,
			DeductionDays:      record.DeductionDays,
			DeductionFee:       record.DeductionFee,
			CouponId:           record.UserCouponId,
			Serial:             uint32(user.MemberExpire.Unix()),
			Type:               model.GetUserMemberRecordType(record.MemberLevel, 3),
			OpenMemberLevel:    user.OpenMemberLevel,
			OpenMemberTime:     user.OpenMemberTime,
		}
		memberRecord.Add()

		memberConfig, err := model.GetMemberConfig(record.MemberLevel, record.MemberGenre)
		if err != nil {
			logger.Error("GetMemberConfig err:", err)
			return
		}
		var fundRecordRecord model.FundRecord
		err = model.NewFundRecordQuerySet(model.DB).UidEq(record.Uid).FundTypeEq(model.FundTypeMemberFee).
			CreatedAtGte(time.Now().Add(-10 * time.Minute)).One(&fundRecordRecord)
		if err == nil && fundRecordRecord.OutTradeNo != "" {
			var userOpenMemberRecord model.UserOpenMemberRecord
			err := model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(fundRecordRecord.OutTradeNo).One(&userOpenMemberRecord)
			if err != nil {
				logger.Error("user open member record err:", err)
				return
			}
			if userOpenMemberRecord.CreatedAt.After(record.CreatedAt) {
				record.MemberExpire = record.MemberExpire.AddDate(1, 0, 0)
			}
		}

		_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).SetMemberGenre(record.MemberGenre).
			SetMemberExpire(record.MemberExpire).SetDeposit(memberConfig.MemberDeposit).UpdateNum()
		//err = model.UserUpdate(&model.User{Uid: uint32(record.Uid), MemberLevel: record.MemberLevel, MemberExpire: expireTime, Deposit: memberConfig.MemberDeposit})
		if err != nil {
			logger.Error("err:", err)
			return
		}
		// 添加会员时长 等级 借卡数量
		var userRentCard model.UserRentCard
		err = model.NewUserRentCardQuerySet(model.DB).UidEq(record.Uid).One(&userRentCard)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		_, err = model.NewUserRentCardQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
			SetLevelRentCount(memberConfig.CardMax).SetCanRentCount(memberConfig.CardMax - userRentCard.HaveRentCount).UpdateNum()
		if err != nil {
			logger.Error("err:", err)
			return
		}

		model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)

		if record.UserCouponId > 0 {
			_, err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
				SetState(2).SetUseTime(utils.Now()).UpdateNum()
			if err != nil {
				logger.Error("update user coupon state err:", err)
			}

			var userCoupon model.UserCoupon
			err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
			if err != nil {
				logger.Error("user coupon err:", err)
			} else {
				if userCoupon.Approach == 1 { // 当优惠券是通过店员兑换码获取，则创建邀请记录；此类用户是会员续费用户
					isShopAssistantCode = true
					err = model.StorePromotion(userCoupon.PromotionalSales, userCoupon.Uid, nil, &user)
					if err != nil {
						logger.Error("store promotion err:", err)
					}
				}
			}
		}

		// 邀请记录
		newTime := time.Now()
		var invite model.UserInvite
		err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).OrderDescByCreatedAt().Limit(1).One(&invite)
		if err != nil && err != model.RecordNotFound {
			logger.Error("err:", err)
		} else {
			if err == nil {
				effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
				if err != nil {
					logger.Error("GetUserEffectiveStore err:", err)
					effectiveStoreInfo.StoreID = 0
				}

				if invite.Action != 2 {
					qs := model.NewUserInviteQuerySet(model.DB).IDEq(invite.ID).GetUpdater()
					if isShopAssistantCode {
						qs = qs.SetInviteForm(1)
						invite.RenewHide = 0 // 干预
					} else {
						invite.RenewHide = 1 // 自动
					}
					qs = qs.SetMemberOpenTime(newTime).SetMemberLevel(record.MemberLevel)
					_, err = qs.SetMemberType(record.MemberLevel).SetMemberStatus(2).
						SetAction(2).SetSpendType(4).SetMemberGenre(record.MemberGenre).UpdateNum()
					if err != nil {
						logger.Error("update user invite action spend type err:", err)
					}
					if invite.UserInviteRecordId != 0 {
						go func() {
							err = model.NewUserInviteRecordQuerySet(model.DB).IDEq(invite.UserInviteRecordId).GetUpdater().
								SetAction(2).SetSpendType(4).SetMemberLevel(record.MemberLevel).
								SetActionTime(newTime).SetMemberGenre(record.MemberGenre).SetRenewHide(invite.RenewHide).Update()
							if err != nil {
								logger.Error("update user invite record err:", err)
							}
						}()
					}
				} else {
					inviteRecordNew := &model.UserInviteRecord{
						ToUid:       invite.ToUid,
						FromUid:     invite.FromUid,
						StoreId:     effectiveStoreInfo.StoreID,
						Action:      2,
						SpendType:   4,
						MemberLevel: record.MemberLevel,
						First:       0,
						Scan:        0, // 自动生成
						ActionTime:  newTime,
						MemberGenre: record.MemberGenre,
						RenewHide:   1,
					}
					if isShopAssistantCode {
						inviteRecordNew.RenewHide = 0
					}
					err = model.DB.Create(inviteRecordNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}

					userInviteNew := &model.UserInvite{
						FromUid:  invite.FromUid,
						UserType: invite.UserType,
						StoreId:  effectiveStoreInfo.StoreID,
						//MemberOpenTime:     invite.MemberOpenTime,
						MemberOpenTime:     time.Now(),
						MemberType:         2,
						MemberStatus:       2,
						ToUid:              invite.ToUid,
						StoreType:          invite.StoreType,
						Action:             2,
						SpendType:          4,
						MemberLevel:        record.MemberLevel,
						UserInviteRecordId: inviteRecordNew.ID,
						FirstInvite:        0,
						Scan:               0,
						MemberGenre:        record.MemberGenre,
						RenewHide:          1,
					}
					if isShopAssistantCode {
						userInviteNew.InviteForm = 1
						userInviteNew.RenewHide = 0
					}
					err = model.DB.Create(userInviteNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}
				}
			} else if err == model.RecordNotFound { // 没有邀请记录，完全是用户自己开通会员，自己续费；按产品要求也需要有记录
				inviteRecordNew := &model.UserInviteRecord{
					Action:      2,
					SpendType:   4,
					MemberLevel: record.MemberLevel,
					First:       0,
					Scan:        0, // 自动生成
					ActionTime:  newTime,
					MemberGenre: record.MemberGenre,
					RenewHide:   1,
				}
				err = model.DB.Create(inviteRecordNew).Error
				if err != nil {
					logger.Error("create  invite record err:", err)
				}
			}
		}

		// 赠送积分
		err = model.NewSendUserVm(user.Uid, uint32(notifyInfo.TotalFee/100), 4)
		if err != nil {
			logger.Error("send user vm err:", err)
		}

		fmt.Println("用户升级---")
		effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
		if err != nil {
			logger.Error("GetUserEffectiveStore err:", err)
			effectiveStoreInfo.StoreID = 0
		}
		// 统计用户升级的数量，方便前端展示
		// 分3种情况：1-店员干预（使用了店员兑换码兑换的优惠券）、2-自动续费（开通会员时有店员邀请，原价or优惠券续费）
		// 3-自动续费（自己开通会员，原价or优惠券续费） 目前只有1算店员提成，正常1和2都会算；3不算提成
		if isShopAssistantCode { // 1-店员干预（使用了店员兑换码兑换的优惠券）
			model.AddCooperativeMemberUpgrade(user.CooperativeBusinessId,
				uint32(effectiveStoreInfo.StoreID), invite.FromUid, user.MemberLevel, int(record.MemberLevel), false)

			_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().
				SetStoreId(effectiveStoreInfo.StoreID).UpdateNum() // 更新用户门店：邀请人的有效门店
			if err != nil {
				logger.Info("uid:", user.Uid)
				logger.Info("store_id:", effectiveStoreInfo.StoreID)
				logger.Error("MemberUpgrade update user store_id err:", err)
			}
		} else if !isShopAssistantCode && err != model.RecordNotFound { // 2-自动续费（开通会员时有店员邀请，原价or优惠券续费）
			model.AddCooperativeMemberUpgrade(user.CooperativeBusinessId,
				uint32(effectiveStoreInfo.StoreID), invite.FromUid, user.MemberLevel, int(record.MemberLevel), true)
		}

		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}

		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeUpgradeMember
		fundRecord.Remark = "升级会员"
	}

	if notifyInfo.Attach == wxpay.WxPayMemberExpireDelay {
		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
			return
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		_, err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(record.Uid).MemberExpireEq(user.MemberExpire).
			GetUpdater().SetIsPay(1).UpdateNum()
		if err != nil {
			logger.Error("err:", err)
			return
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberExpireDelay
		fundRecord.Remark = "会员过期滞纳金"
	}

	if notifyInfo.Attach == wxpay.WxPayShareCardRetrieve {
		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}
		fmt.Println("UpgradeMember:", record.Uid)
		//var user model.User
		//err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		//if err != nil {
		//	logger.Error("err:", err)
		//	return
		//}

		_, err = model.NewShareCardRetrieveQuerySet(model.DB).IDEq(record.OrderId).
			GetUpdater().SetPayState(2).UpdateNum()
		if err != nil {
			logger.Error("update pay state err:", err)
		}
		_, err = model.NewShareCardRetrieveCardQuerySet(model.DB).ShareCardRetrieveIdEq(record.OrderId).GetUpdater().
			SetPayState(2).UpdateNum()
		if err != nil {
			logger.Error("update pay state err:", err)
		}

		var share model.ShareCardRetrieve
		err = model.NewShareCardRetrieveQuerySet(model.DB).IDEq(record.ID).One(&share)
		if err != nil {
			log.Error().Msgf("share card retrieve err:%#v", err)
		}
		if err == nil {
			sub := model.DeliverTaskSub{
				Uid:           share.Uid,
				UserAddressId: share.AddressId,
				OrderType:     3,
				OrderId:       share.ID,
			}
			err = sub.Add()
			if err != nil {
				logger.Error("deliver task sub add err:", err)
			}
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeExpressFee
		fundRecord.Remark = "共享卡收回卡快递费"
	}

	if notifyInfo.Attach == wxpay.WxPayPostagePackage {
		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		err := record.GetByOpenNo()
		if err != nil {
			logger.Error("err:", err)
		}
		if record.State == 2 {
			ret.ReturnCode = "SUCCESS"
			RespBodyXML(c, ret)
			return
		}
		var activity model.Activity
		err = model.NewActivityQuerySet(model.DB).IDEq(3).One(&activity)
		if err != nil {
			logger.Error("coupon err:", err)
			return
		}
		var coupon model.Coupon
		err = model.NewCouponQuerySet(model.DB).ActivityTypeEq(activity.ActivityType).One(&coupon)
		if err != nil {
			logger.Error("coupon err:", err)
			ret.ReturnCode = "Error"
			RespBodyXML(c, ret)
			return
		}

		defer func() {
			if err := recover(); err != nil {
				logger.Error("err:", err)
			}
		}()

		//info, err := model.PostagePackageFeeConfigInfo()
		//if err != nil {
		//	logger.Error("postage package fee config err")
		//	ret.ReturnCode = "Error"
		//	RespBodyXML(c, ret)
		//	return
		//}

		//originalMemberConfig, err := model.GetMemberConfig(record.MemberLevel)
		//if err != nil {
		//	logger.Error("err:", err)
		//	ret.ReturnCode = "Error"
		//	RespBodyXML(c, ret)
		//	return
		//}
		//days := (info.PostagePackageFee * 365) / originalMemberConfig.MemberFee
		user := model.GetUserByUid(record.Uid)
		days := model.GetPostagePackageMemberDuration(user.MemberLevel)
		durationRecord := &model.UserMemberDurationRecord{
			Uid:         record.Uid,
			Duration:    days,
			EventType:   1,
			MemberLevel: record.MemberLevel,
		}
		nowTime := time.Now()

		go func() {
			begin := model.DB.Begin()
			for i := 0; i < 10; i++ {
				userCoupon := &model.UserCoupon{
					Uid:          record.Uid,
					CouponId:     coupon.ID,
					CouponType:   coupon.CouponType,
					ActivityType: activity.ActivityType,
					ActivityId:   activity.ID,
					Value:        coupon.Value,
					State:        1,
					ActiveStart:  nowTime,
					ActiveEnd:    nowTime.AddDate(10, 0, 0),
					MemberLevel:  record.MemberLevel,
				}
				err = begin.Create(userCoupon).Error
				if err != nil {
					begin.Rollback()
					logger.Error("user coupon err:", err)
					return
				}
			}

			memberExpire := user.MemberExpire.AddDate(0, 0, int(days))
			err := model.NewUserQuerySet(begin).UidEq(record.Uid).GetUpdater().SetMemberExpire(memberExpire).Update()
			if err != nil {
				begin.Rollback()
				logger.Error("update member expire err:", err)
				return
			}

			err = begin.Create(durationRecord).Error
			if err != nil {
				logger.Error("create duration record err:", err)
				return
			}

			err = begin.Commit().Error
			if err != nil {
				begin.Rollback()
				logger.Error("commit err:", err)
				return
			}
		}()

		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypePostagePackageFee
		fundRecord.Remark = "购买运费包"
	}

	fundRecord.Amount = int64(notifyInfo.TotalFee)
	fundRecord.TransactionId = notifyInfo.TransactionId
	fundRecord.OutTradeNo = notifyInfo.OutTradeNo
	fundRecord.Status = 2
	err = model.DB.Create(&fundRecord).Error
	if err != nil {
		logger.Error("create fund record err:", err)
	}
	logger.Debug("微信推送支付通知-end")
	ret.ReturnCode = "SUCCESS"
	RespBodyXML(c, ret)
}

type HmPushWXPayNoticeReq struct {
	AppId                    string `json:"app_id" form:"app_id"`
	BankOrderNo              string `json:"bank_order_no" form:"bank_order_no"`
	BankTrxNo                string `json:"bank_trx_no" form:"bank_trx_no"`
	BankWayCode              string `json:"bank_way_code" form:"bank_way_code"`
	BuyerId                  string `json:"buyer_id" form:"buyer_id"`
	BuyerTradeFundBillDetail string `json:"buyer_trade_fund_bill_detail" form:"buyer_trade_fund_bill_detail"`
	NotifyType               string `json:"notify_type" form:"notify_type"`
	OutOrderNo               string `json:"out_order_no" form:"out_order_no"`
	PayAmount                string `json:"pay_amount" form:"pay_amount"`
	PayModeCode              string `json:"pay_mode_code" form:"pay_mode_code"`
	PaySuccessTime           string `json:"pay_success_time" form:"pay_success_time"`
	PayWayCode               string `json:"pay_way_code" form:"pay_way_code"`
	PlatTrxNo                string `json:"plat_trx_no" form:"plat_trx_no"`
	SettleAmount             string `json:"settle_amount" form:"settle_amount"`
	SettleAppId              string `json:"settle_app_id" form:"settle_app_id"`
	Sign                     string `json:"sign" form:"sign"`
	SignType                 string `json:"sign_type" form:"sign_type"`
}

// HmPushWXPayNotice 河马付推送支付通知
func HmPushWXPayNotice(c *gin.Context) {
	fmt.Println("河马付推送支付通知-start")
	logger.Debug("河马付推送支付通知-start")

	bankOrderNo := c.Query("bank_order_no")
	outOrderNo := c.Query("out_order_no")
	payAmount := c.Query("pay_amount")
	sign := c.Query("sign")
	tradeStatus := c.Query("trade_status")
	if tradeStatus != "SUCCESS" {
		logger.Error("tradeStatus err:")
		RespOK(c, "Error")
		return
	}
	//fmt.Println("URL:", c.Request.URL.String())
	//fmt.Println("sign-----", sign)
	substance, err := model.ParaToSubstance(c, sign)
	if err != nil {
		logger.Error("substance err:", err)
		RespOK(c, "Error")
		return
	}

	err = wxpay.HmVerifySha1Rsa(substance, sign)
	if err != nil {
		logger.Error("HmVerifySha1Rsa err:", err)
		RespOK(c, "Error")
		return
	}

	record := &model.UserOpenMemberRecord{OpenNo: outOrderNo}
	err = record.GetByOpenNo()
	if err != nil {
		logger.Error("err:", err)
	}
	if record.State == 2 {
		RespOK(c, "SUCCESS")
		return
	}

	fundRecord := new(model.FundRecord)
	payAmountFloat, err := strconv.ParseFloat(payAmount, 64)
	if err != nil {
		logger.Error("parse err:", err)
	}
	fundRecord.Amount = int64(payAmountFloat * 100)

	if record.Attach == wxpay.WxPayRentCard {
		logger.Info("租借游戏卡 支付成功:")
		var order model.Order
		err := model.NewOrderQuerySet(model.DB).OrderSnEq(outOrderNo).
			PayStatusEq(PayStatusUnPay).CardStatusNe(OrderCardStatusCancel).One(&order)
		if err != nil {
			logger.Error("err:", err)
			return
		}
		//orderJson, _ := json.Marshal(&order)
		//fmt.Println("orderJson:", string(orderJson))

		begin := model.DB.Begin()
		err = model.NewOrderQuerySet(begin).IDEq(order.ID).GetUpdater().
			SetPayStatus(model.PayStatusPaid).SetPayTime(time.Now()).Update()
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}
		//model.OrderCard{}
		_, err = model.NewOrderCardQuerySet(begin).OrderIdEq(order.ID).GetUpdater().
			SetPayStatus(model.PayStatusPaid).UpdateNum()
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}

		sub := model.DeliverTaskSub{
			Uid:           uint32(order.Uid),
			UserAddressId: uint32(order.UserAddressId),
			OrderType:     1,
			OrderId:       order.ID,
			StoreId:       uint32(order.StoreId),
		}
		err = sub.Add()
		if err != nil {
			logger.Error("deliver task sub add err:", err)
		}

		err = order.InventoryReduction(begin)
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			if order.PostageType == 1 {
				// 库存不足取消订单
				orderSn := model.GetOrderSn()
				memberRecord := &model.UserOpenMemberRecord{OpenNo: orderSn, OrderType: 2, Order: &order}
				err = memberRecord.OrderRefund(outOrderNo)
				if err != nil {
					logger.Error("err:", err)
					return
				}
			}

			// TODO
			if order.PostageType == 2 {
				var userCoupon model.UserCoupon
				err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uint32(order.Uid)).
					StateEq(2).OrderAscByID().Limit(1).One(&userCoupon)
				if err != nil && err != model.RecordNotFound {
					logger.Error("user coupon err:", err)
					RespJson(c, status.InternalServerError, nil)
					return
				}
				err = model.NewUserCouponQuerySet(model.DB).IDEq(userCoupon.ID).GetUpdater().SetState(1).Update()
				if err != nil {
					logger.Error("user coupon err:", err)
				}
			}

			_, err := model.NewOrderQuerySet(model.DB).IDEq(order.ID).GetUpdater().
				SetCardStatus(OrderCardStatusCancel).UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}
			_, err = model.NewOrderCardQuerySet(model.DB).OrderIdEq(order.ID).GetUpdater().
				SetCardStatus(OrderCardStatusCancel).UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}

			return
		}
		err = begin.Commit().Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			return
		}
		go model.ShoppingCartCreateOrderByOrder(order)

		fundRecord.Uid = uint32(order.Uid)
		fundRecord.FundType = model.FundTypeExpressFee
		fundRecord.Remark = "借卡邮费"

	}

	if record.Attach == wxpay.WxPayMember {
		logger.Info("开通会员 支付成功:")
		logger.Info("用户uid:", outOrderNo)

		remark := ""
		if record.MemberLevel == model.MemberLevelGold {
			if record.MemberGenre != model.MemberGenreQuarter && record.MemberGenre != model.MemberGenreHalfYear {
				record.MemberGenre = model.MemberGenreYear // 新增：如果是年费黄金会员则member_genre设置为200
			}
			remark = "黄金会员费"
		} else if record.MemberLevel == model.MemberLevelPlatinum {
			remark = "白金会员费"
		} else if record.MemberLevel == model.MemberLevelBlackGold {
			remark = "黑金会员费"
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberFee
		fundRecord.Remark = remark
		// 支付金额小于100（99或者49）的情况是：白金会员过期后没退押金，然后直接开通黄金会员
		if fundRecord.Amount < 10000 {
			fundRecord.FundType = model.FundTypeDowngradeRenewal
		}
		memberRecord := &model.UserMemberRecord{
			Uid:              record.Uid,
			AfterMemberLevel: record.MemberLevel,
		}
		newTime := time.Now()
		var spendType uint32 // 开通类型： 1-未开通 2-开通会员 3-续费 4-升级 5-店员推广续费
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("err:", err)
			return
		} else {
			spendType = uint32(2) // 2-开通会员
			//if !user.OpenMemberTime.IsZero() && user.MemberExpire.After(time.Now()) {
			if !user.OpenMemberTime.IsZero() {
				spendType = 3 // 3-续费
			}
			isShopAssistantCode := false

			var expireTime time.Time
			if record.MemberGenre == model.MemberGenreQuarter {
				expireTime = newTime.AddDate(0, 0, 90)
			} else if record.MemberGenre == model.MemberGenreHalfYear {
				expireTime = newTime.AddDate(0, 0, 180)
			} else {
				expireTime = newTime.AddDate(1, 0, 0)
			}

			if user.MemberExpire.After(newTime) {
				//expireTime = user.MemberExpire.AddDate(1, 0, 0)
				if record.MemberGenre == model.MemberGenreQuarter {
					expireTime = user.MemberExpire.AddDate(0, 0, 90)
				} else if record.MemberGenre == model.MemberGenreHalfYear {
					expireTime = user.MemberExpire.AddDate(0, 0, 180)
				} else {
					expireTime = user.MemberExpire.AddDate(1, 0, 0)
				}
			}

			memberRecord.BeforeMemberLevel = user.MemberLevel
			memberRecord.BeforeMemberExpire = user.MemberExpire
			memberRecord.Serial = uint32(user.MemberExpire.Unix())
			memberRecord.AfterMemberExpire = expireTime
			if user.IsMember() {
				memberRecord.OpenMemberLevel = user.OpenMemberLevel
				memberRecord.OpenMemberTime = user.OpenMemberTime
			} else {
				memberRecord.OpenMemberLevel = record.MemberLevel
				memberRecord.OpenMemberTime = newTime
			}
			memberConfig, err := model.GetMemberConfig(record.MemberLevel, record.MemberGenre)
			if err != nil {
				logger.Error("GetMemberConfig err:", err)
				return
			}
			//openMemberTime := newTime
			userUpdateQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
				SetMemberGenre(record.MemberGenre).SetMemberExpire(expireTime).SetDeposit(memberConfig.MemberDeposit)
			if user.OpenMemberTime.IsZero() {
				//openMemberTime = user.OpenMemberTime
				userUpdateQs = userUpdateQs.SetOpenMemberTime(newTime).SetOpenMemberLevel(record.MemberLevel)
				memberRecord.Type = model.GetUserMemberRecordType(record.MemberLevel, 1) // 开通会员类型
			} else {
				memberRecord.Type = model.GetUserMemberRecordType(record.MemberLevel, 2) // 续费会员类型
			}
			_, err = userUpdateQs.UpdateNum()
			if err != nil {
				logger.Error("err:", err)
				return
			}

			if record.UserCouponId > 0 { // 如果使用了会员优惠券，更新优惠券状态为2-已使用
				err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
					SetState(2).SetUseTime(utils.Now()).Update()
				if err != nil {
					logger.Error("update user coupon state err:", err)
				}

				var userCoupon model.UserCoupon
				err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
				if err != nil {
					logger.Error("user coupon err:", err)
				} else {
					if userCoupon.Approach == 1 { // 当优惠券是通过店员兑换码获取，则创建邀请记录；此类用户是会员续费用户
						isShopAssistantCode = true
						err = model.StorePromotion(userCoupon.PromotionalSales, userCoupon.Uid, nil, &user)
						if err != nil {
							logger.Error("store promotion err:", err)
						}
					}
				}
			}

			// 邀请记录
			var invite model.UserInvite
			err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).OrderDescByCreatedAt().Limit(1).One(&invite)
			if err != nil && err != model.RecordNotFound {
				logger.Error("err:", err)
			} else {
				if err == nil {
					effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
					if err != nil {
						logger.Error("GetUserEffectiveStore err:", err)
						effectiveStoreInfo.StoreID = 0
					}

					if invite.Action == 1 { // 首次开通会员
						qs := model.NewUserInviteQuerySet(model.DB).IDEq(invite.ID).GetUpdater()

						if isShopAssistantCode {
							qs = qs.SetInviteForm(1)
							invite.RenewHide = 0 // 干预
						} else {
							invite.RenewHide = 1 // 自动
						}
						qs = qs.SetMemberOpenTime(newTime).SetMemberLevel(record.MemberLevel)
						_, err = qs.SetMemberType(2).SetMemberStatus(2).
							SetAction(2).SetSpendType(spendType).SetMemberGenre(record.MemberGenre).UpdateNum()
						if err != nil {
							logger.Error("update user invite action spend type err:", err)
						}
						if invite.UserInviteRecordId != 0 {
							go func() {
								err = model.NewUserInviteRecordQuerySet(model.DB).IDEq(invite.UserInviteRecordId).GetUpdater().
									SetAction(2).SetSpendType(spendType).SetMemberLevel(record.MemberLevel).
									SetActionTime(newTime).SetMemberGenre(record.MemberGenre).SetRenewHide(invite.RenewHide).Update()
								if err != nil {
									logger.Error("update user invite record err:", err)
								}
							}()
						}
					} else { // 续费会员-用户直接续费
						inviteRecordNew := &model.UserInviteRecord{
							ToUid:       invite.ToUid,
							FromUid:     invite.FromUid,
							StoreId:     effectiveStoreInfo.StoreID,
							Action:      2,
							SpendType:   spendType,
							MemberLevel: record.MemberLevel,
							First:       0,
							Scan:        0, // 自动生成
							ActionTime:  newTime,
							MemberGenre: record.MemberGenre,
							RenewHide:   1,
						}
						if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
							inviteRecordNew.Scan = 1
							inviteRecordNew.RenewHide = 0 // 店员干预续费
							//inviteRecordNew.FromUid = invite.FromUid
							//inviteRecordNew.StoreId = effectiveStoreInfo.StoreID
						}
						err = model.DB.Create(inviteRecordNew).Error
						if err != nil {
							logger.Error("create  invite record err:", err)
						}

						userInviteNew := &model.UserInvite{
							FromUid:            invite.FromUid,
							UserType:           invite.UserType,
							StoreId:            effectiveStoreInfo.StoreID,
							StoreType:          invite.StoreType,
							MemberOpenTime:     time.Now(),
							MemberType:         2,
							MemberStatus:       2,
							ToUid:              invite.ToUid,
							Action:             2,
							SpendType:          spendType,
							MemberLevel:        record.MemberLevel,
							UserInviteRecordId: inviteRecordNew.ID,
							FirstInvite:        0,
							Scan:               0,
							MemberGenre:        record.MemberGenre,
							RenewHide:          1,
							//MemberOpenTime:     invite.MemberOpenTime,
						}
						if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
							userInviteNew.Scan = 1
							userInviteNew.RenewHide = 0
							userInviteNew.InviteForm = 1
							//userInviteNew.FromUid = invite.FromUid
							//userInviteNew.StoreId = effectiveStoreInfo.StoreID
							//userInviteNew.UserType = invite.UserType
							//userInviteNew.StoreType = invite.StoreType
						}
						err = model.DB.Create(userInviteNew).Error
						if err != nil {
							logger.Error("create  invite record err:", err)
						}
					}

					if invite.FromUid != 0 {
						logger.Info("invite.FromUid != 0")
						fmt.Println("invite.FromUid != 0")
						inviteUser := model.GetUserByUid(invite.FromUid)
						if inviteUser != nil {
							openMemberChannel := model.OpenMemberChannelUserInvite
							userQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater()

							logger.Info("userQs:", userQs)
							fmt.Println("userQs:", userQs)
							if inviteUser.UserType == 2 {
								openMemberChannel = model.OpenMemberChannelStorePromotion
								if !user.OpenMemberTime.IsZero() {
									userQs = userQs.SetCooperativeBusinessId(inviteUser.CooperativeBusinessId).
										SetCooperativeName(inviteUser.CooperativeName)

									autoRenewFlag := true // 自动续费
									effectiveStoreId := invite.StoreId
									if isShopAssistantCode { // 如果使用了优惠券，则是店员邀请续费；否则是用户自己发起续费
										effectiveStoreId = effectiveStoreInfo.StoreID
										userQs = userQs.SetStoreId(effectiveStoreId) // 更新用户门店：邀请人的有效门店
										autoRenewFlag = false                        // 店员干预续费
									}

									fmt.Println("用户续费---")
									model.AddCooperativeMemberRenewal(inviteUser.CooperativeBusinessId,
										uint32(effectiveStoreId), inviteUser.Uid, int(record.MemberLevel),
										int(record.MemberGenre), autoRenewFlag)
								} else {
									fmt.Println("用户开通------")
									model.AddCooperativeMemberPromotion(inviteUser.CooperativeBusinessId,
										uint32(effectiveStoreInfo.StoreID), inviteUser.Uid, int(record.MemberLevel), int(record.MemberGenre))
								}
								userQs = userQs.SetStoreId(effectiveStoreInfo.StoreID) // 更新用户门店：邀请人的有效门店
							}

							logger.Info("userQs UpdateNum start")
							fmt.Println("userQs UpdateNum start")
							_, err = userQs.SetOpenMemberChannel(openMemberChannel).UpdateNum()
							if err != nil {
								logger.Error("err:", err)
							}
							logger.Info("userQs UpdateNum end")
							fmt.Println("userQs UpdateNum end")
						}
					}
				} else if err == model.RecordNotFound { // 没有邀请记录，完全是用户自己开通会员，自己续费；按产品要求也需要有记录
					inviteRecordNew := &model.UserInviteRecord{
						Action:      2,
						SpendType:   spendType,
						MemberLevel: record.MemberLevel,
						First:       0,
						Scan:        0, // 自动生成
						ActionTime:  newTime,
						MemberGenre: record.MemberGenre,
						RenewHide:   1,
					}
					err = model.DB.Create(inviteRecordNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}

					// 记录对应的数量
					switch spendType {
					case 2: // 开通
						fmt.Println("用户开通------")
						model.AddCooperativeMemberPromotion(user.CooperativeBusinessId, 0, 0,
							int(record.MemberLevel), int(record.MemberGenre))
					case 3: // 续费
						fmt.Println("用户续费---")
						model.AddCooperativeMemberRenewal(user.CooperativeBusinessId, 0, 0,
							int(record.MemberLevel), int(record.MemberGenre), true)
					}
				}
			}

			// 赠送积分
			err = model.NewSendUserVm(user.Uid, uint32(payAmountFloat), spendType)
			if err != nil {
				logger.Error("send user vm err:", err)
			}

			go func() {
				err = model.DB.Create(memberRecord).Error
				if err != nil {
					logger.Error("create member record err:", err)
				}
			}()
			model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).
			GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fmt.Println("notify.TotalFee:", fundRecord.Amount)
		fmt.Println("notify.OutTradeNo:", outOrderNo)

	}

	if record.Attach == wxpay.WxPayDeposit {
		//record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		//err := record.GetByOpenNo()
		//if err != nil {
		//	logger.Error("err:", err)
		//	return
		//}
		//if record.State == 2 {
		//	ret.ReturnCode = "SUCCESS"
		//	RespBodyXML(c, ret)
		//	return
		//}

		//if record.State != 2 {
		user := model.GetUserByUid(record.Uid)
		if user == nil {
			logger.Error("user nil")
			return
		}

		memberConfig, err := model.GetMemberConfig(user.MemberLevel, user.MemberGenre)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		remark := ""
		if user.MemberLevel == 2 {
			remark = "黄金会员押金"
		} else if user.MemberLevel == 4 {
			remark = "白金会员押金"
		} else if user.MemberLevel == 5 {
			remark = "黑金会员押金"
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberDeposit
		fundRecord.Remark = remark

		num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().
			SetDeposit(memberConfig.MemberDeposit).UpdateNum()
		if err != nil {
			logger.Error("update deposit err:", err)
		}
		if num == 0 {
			logger.Error("update deposit num is 0")
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		//}
	}

	if record.Attach == wxpay.WxPayBuyGoods {
		_, err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(outOrderNo).GetUpdater().
			SetPayTime(time.Now()).
			SetPayStatus(model.PayStatusOK).
			SetState(model.GoodsOrderStateOnDeliver).UpdateNum()

		if err != nil {
			logger.Error("err:", err)
		}
		var goodsOrder model.GoodsOrder
		err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(outOrderNo).One(&goodsOrder)
		if err != nil {
			logger.Error("err:", err)
		}

		err = model.OrderUpdateGoodsStock(goodsOrder.GoodsAttributeId, goodsOrder.Quantity, model.DB)
		if err != nil {
			logger.Error("err:", err)
		}

		err = model.UserVmUpdate(goodsOrder.Uid, int(goodsOrder.Vm)*-1, model.VmEventBuyGoods, "购买商品积分抵扣")
		if err != nil {
			logger.Error("err:", err)
		}
		sub := model.DeliverTaskSub{
			Uid:           uint32(goodsOrder.Uid),
			UserAddressId: uint32(goodsOrder.AddressId),
			OrderType:     2,
			OrderId:       goodsOrder.OrderId,
			StoreId:       13,
		}
		err = sub.Add()
		if err != nil {
			logger.Error("deliver task sub add err:", err)
		}
		fundRecord.Uid = uint32(goodsOrder.Uid)
		fundRecord.FundType = model.FundTypeBuyGoods
		fundRecord.Remark = "商城购买"
	}

	if record.Attach == wxpay.WxPayUpgradeMember {
		//record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		//err := record.GetByOpenNo()
		//if err != nil {
		//	logger.Error("err:", err)
		//}
		//if record.State == 2 {
		//	ret.ReturnCode = "SUCCESS"
		//	RespBodyXML(c, ret)
		//	return
		//}

		fmt.Println("UpgradeMember:", record.Uid)
		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("user err:", err)
			return
		}
		isShopAssistantCode := false

		memberRecord := &model.UserMemberRecord{
			Uid:                record.Uid,
			BeforeMemberLevel:  user.MemberLevel,
			AfterMemberLevel:   record.MemberLevel,
			BeforeMemberExpire: user.MemberExpire,
			AfterMemberExpire:  record.MemberExpire,
			InviteUid:          0,
			DeductionDays:      record.DeductionDays,
			DeductionFee:       record.DeductionFee,
			CouponId:           record.UserCouponId,
			Serial:             uint32(user.MemberExpire.Unix()),
			Type:               model.GetUserMemberRecordType(record.MemberLevel, 3),
			OpenMemberLevel:    user.OpenMemberLevel,
			OpenMemberTime:     user.OpenMemberTime,
		}
		memberRecord.Add()

		memberConfig, err := model.GetMemberConfig(record.MemberLevel, record.MemberGenre)
		if err != nil {
			logger.Error("GetMemberConfig err:", err)
			return
		}
		var fundRecordRecord model.FundRecord
		err = model.NewFundRecordQuerySet(model.DB).UidEq(record.Uid).FundTypeEq(model.FundTypeMemberFee).
			CreatedAtGte(time.Now().Add(-10 * time.Minute)).One(&fundRecordRecord)
		if err == nil && fundRecordRecord.OutTradeNo != "" {
			var userOpenMemberRecord model.UserOpenMemberRecord
			err := model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(fundRecordRecord.OutTradeNo).One(&userOpenMemberRecord)
			if err != nil {
				logger.Error("user open member record err:", err)
				return
			}
			if userOpenMemberRecord.CreatedAt.After(record.CreatedAt) {
				record.MemberExpire = record.MemberExpire.AddDate(1, 0, 0)
			}
		}

		_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).SetMemberGenre(record.MemberGenre).
			SetMemberExpire(record.MemberExpire).SetDeposit(memberConfig.MemberDeposit).UpdateNum()
		//err = model.UserUpdate(&model.User{Uid: uint32(record.Uid), MemberLevel: record.MemberLevel, MemberExpire: expireTime, Deposit: memberConfig.MemberDeposit})
		if err != nil {
			logger.Error("err:", err)
			return
		}
		// 添加会员时长 等级 借卡数量
		var userRentCard model.UserRentCard
		err = model.NewUserRentCardQuerySet(model.DB).UidEq(record.Uid).One(&userRentCard)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		_, err = model.NewUserRentCardQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
			SetLevelRentCount(memberConfig.CardMax).SetCanRentCount(memberConfig.CardMax - userRentCard.HaveRentCount).UpdateNum()
		if err != nil {
			logger.Error("err:", err)
			return
		}

		model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)

		if record.UserCouponId > 0 {
			_, err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
				SetState(2).SetUseTime(utils.Now()).UpdateNum()
			if err != nil {
				logger.Error("update user coupon state err:", err)
			}

			var userCoupon model.UserCoupon
			err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
			if err != nil {
				logger.Error("user coupon err:", err)
			} else {
				if userCoupon.Approach == 1 { // 当优惠券是通过店员兑换码获取，则创建邀请记录；此类用户是会员续费用户
					isShopAssistantCode = true
					err = model.StorePromotion(userCoupon.PromotionalSales, userCoupon.Uid, nil, &user)
					if err != nil {
						logger.Error("store promotion err:", err)
					}
				}
			}
		}

		// 邀请记录
		newTime := time.Now()
		var invite model.UserInvite
		err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).OrderDescByCreatedAt().Limit(1).One(&invite)
		if err != nil && err != model.RecordNotFound {
			logger.Error("err:", err)
		} else {
			if err == nil {
				effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
				if err != nil {
					logger.Error("GetUserEffectiveStore err:", err)
					effectiveStoreInfo.StoreID = 0
				}

				if invite.Action != 2 {
					qs := model.NewUserInviteQuerySet(model.DB).IDEq(invite.ID).GetUpdater()
					if isShopAssistantCode {
						qs = qs.SetInviteForm(1)
						invite.RenewHide = 0 // 干预
					} else {
						invite.RenewHide = 1 // 自动
					}
					qs = qs.SetMemberOpenTime(newTime).SetMemberLevel(record.MemberLevel)
					_, err = qs.SetMemberType(record.MemberLevel).SetMemberStatus(2).
						SetAction(2).SetSpendType(4).SetMemberGenre(record.MemberGenre).UpdateNum()
					if err != nil {
						logger.Error("update user invite action spend type err:", err)
					}
					if invite.UserInviteRecordId != 0 {
						go func() {
							err = model.NewUserInviteRecordQuerySet(model.DB).IDEq(invite.UserInviteRecordId).GetUpdater().
								SetAction(2).SetSpendType(4).SetMemberLevel(record.MemberLevel).
								SetActionTime(newTime).SetMemberGenre(record.MemberGenre).SetRenewHide(invite.RenewHide).Update()
							if err != nil {
								logger.Error("update user invite record err:", err)
							}
						}()
					}
				} else {
					inviteRecordNew := &model.UserInviteRecord{
						ToUid:       invite.ToUid,
						FromUid:     invite.FromUid,
						StoreId:     effectiveStoreInfo.StoreID,
						Action:      2,
						SpendType:   4,
						MemberLevel: record.MemberLevel,
						First:       0,
						Scan:        0, // 自动生成
						ActionTime:  newTime,
						MemberGenre: record.MemberGenre,
						RenewHide:   1,
					}
					if isShopAssistantCode {
						inviteRecordNew.RenewHide = 0
					}
					err = model.DB.Create(inviteRecordNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}

					userInviteNew := &model.UserInvite{
						FromUid:  invite.FromUid,
						UserType: invite.UserType,
						StoreId:  effectiveStoreInfo.StoreID,
						//MemberOpenTime:     invite.MemberOpenTime,
						MemberOpenTime:     time.Now(),
						MemberType:         2,
						MemberStatus:       2,
						ToUid:              invite.ToUid,
						StoreType:          invite.StoreType,
						Action:             2,
						SpendType:          4,
						MemberLevel:        record.MemberLevel,
						UserInviteRecordId: inviteRecordNew.ID,
						FirstInvite:        0,
						Scan:               0,
						MemberGenre:        record.MemberGenre,
						RenewHide:          1,
					}
					if isShopAssistantCode {
						userInviteNew.InviteForm = 1
						userInviteNew.RenewHide = 0
					}
					err = model.DB.Create(userInviteNew).Error
					if err != nil {
						logger.Error("create  invite record err:", err)
					}
				}
			} else if err == model.RecordNotFound { // 没有邀请记录，完全是用户自己开通会员，自己续费；按产品要求也需要有记录
				inviteRecordNew := &model.UserInviteRecord{
					Action:      2,
					SpendType:   4,
					MemberLevel: record.MemberLevel,
					First:       0,
					Scan:        0, // 自动生成
					ActionTime:  newTime,
					MemberGenre: record.MemberGenre,
					RenewHide:   1,
				}
				err = model.DB.Create(inviteRecordNew).Error
				if err != nil {
					logger.Error("create  invite record err:", err)
				}
			}
		}

		// 赠送积分
		err = model.NewSendUserVm(user.Uid, uint32(payAmountFloat), 4)
		if err != nil {
			logger.Error("send user vm err:", err)
		}

		fmt.Println("用户升级---")
		effectiveStoreInfo, err := model.GetUserEffectiveStore(invite.FromUid)
		if err != nil {
			logger.Error("GetUserEffectiveStore err:", err)
			effectiveStoreInfo.StoreID = 0
		}

		// 统计用户升级的数量，方便前端展示
		// 分3种情况：1-店员干预（使用了店员兑换码兑换的优惠券）、2-自动续费（开通会员时有店员邀请，原价or优惠券续费）
		// 3-自动续费（自己开通会员，原价or优惠券续费） 目前只有1算店员提成，正常1和2都会算；3不算提成
		fmt.Println("isShopAssistantCode:", isShopAssistantCode)
		if isShopAssistantCode { // 1-店员干预（使用了店员兑换码兑换的优惠券）
			model.AddCooperativeMemberUpgrade(user.CooperativeBusinessId,
				uint32(effectiveStoreInfo.StoreID), invite.FromUid, user.MemberLevel, int(record.MemberLevel), false)

			_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().
				SetStoreId(effectiveStoreInfo.StoreID).UpdateNum() // 更新用户门店：邀请人的有效门店
			if err != nil {
				logger.Info("uid:", user.Uid)
				logger.Info("store_id:", effectiveStoreInfo.StoreID)
				logger.Error("MemberUpgrade update user store_id err:", err)
			}
		} else if !isShopAssistantCode && err != model.RecordNotFound { // 2-自动续费（开通会员时有店员邀请，原价or优惠券续费）
			model.AddCooperativeMemberUpgrade(user.CooperativeBusinessId,
				uint32(effectiveStoreInfo.StoreID), invite.FromUid, user.MemberLevel, int(record.MemberLevel), true)
		}

		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}

		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeUpgradeMember
		fundRecord.Remark = "升级会员"
	}

	if record.Attach == wxpay.WxPayMemberExpireDelay {
		//record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		//err := record.GetByOpenNo()
		//if err != nil {
		//	logger.Error("err:", err)
		//	return
		//}
		//if record.State == 2 {
		//	ret.ReturnCode = "SUCCESS"
		//	RespBodyXML(c, ret)
		//	return
		//}

		var user model.User
		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
		if err != nil {
			logger.Error("err:", err)
			return
		}

		_, err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(record.Uid).MemberExpireEq(user.MemberExpire).
			GetUpdater().SetIsPay(1).UpdateNum()
		if err != nil {
			logger.Error("err:", err)
			return
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeMemberExpireDelay
		fundRecord.Remark = "会员过期滞纳金"
	}

	if record.Attach == wxpay.WxPayShareCardRetrieve {
		//record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		//err := record.GetByOpenNo()
		//if err != nil {
		//	logger.Error("err:", err)
		//}
		//if record.State == 2 {
		//	ret.ReturnCode = "SUCCESS"
		//	RespBodyXML(c, ret)
		//	return
		//}
		fmt.Println("UpgradeMember:", record.Uid)

		_, err = model.NewShareCardRetrieveQuerySet(model.DB).IDEq(record.OrderId).
			GetUpdater().SetPayState(2).UpdateNum()
		if err != nil {
			logger.Error("update pay state err:", err)
		}
		_, err = model.NewShareCardRetrieveCardQuerySet(model.DB).ShareCardRetrieveIdEq(record.OrderId).GetUpdater().
			SetPayState(2).UpdateNum()
		if err != nil {
			logger.Error("update pay state err:", err)
		}

		var share model.ShareCardRetrieve
		err = model.NewShareCardRetrieveQuerySet(model.DB).IDEq(record.ID).One(&share)
		if err != nil {
			log.Error().Msgf("share card retrieve err:%#v", err)
		}
		if err == nil {
			sub := model.DeliverTaskSub{
				Uid:           share.Uid,
				UserAddressId: share.AddressId,
				OrderType:     3,
				OrderId:       share.ID,
			}
			err = sub.Add()
			if err != nil {
				logger.Error("deliver task sub add err:", err)
			}
		}
		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
		if err != nil {
			logger.Error("update user open member record state:err", err)
		}
		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypeExpressFee
		fundRecord.Remark = "共享卡收回卡快递费"
	}

	if record.Attach == wxpay.WxPayPostagePackage {
		//record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
		//err := record.GetByOpenNo()
		//if err != nil {
		//	logger.Error("err:", err)
		//}
		//if record.State == 2 {
		//	ret.ReturnCode = "SUCCESS"
		//	RespBodyXML(c, ret)
		//	return
		//}
		var activity model.Activity
		err = model.NewActivityQuerySet(model.DB).IDEq(3).One(&activity)
		if err != nil {
			logger.Error("coupon err:", err)
			return
		}
		var coupon model.Coupon
		err = model.NewCouponQuerySet(model.DB).ActivityTypeEq(activity.ActivityType).One(&coupon)
		if err != nil {
			logger.Error("coupon err:", err)
			//ret.ReturnCode = "Error"
			//RespBodyXML(c, ret)
			RespOK(c, "Error")
			return
		}

		defer func() {
			if err := recover(); err != nil {
				logger.Error("err:", err)
			}
		}()

		//info, err := model.PostagePackageFeeConfigInfo()
		//if err != nil {
		//	logger.Error("postage package fee config err")
		//	ret.ReturnCode = "Error"
		//	RespBodyXML(c, ret)
		//	return
		//}

		//originalMemberConfig, err := model.GetMemberConfig(record.MemberLevel)
		//if err != nil {
		//	logger.Error("err:", err)
		//	ret.ReturnCode = "Error"
		//	RespBodyXML(c, ret)
		//	return
		//}
		//days := (info.PostagePackageFee * 365) / originalMemberConfig.MemberFee
		user := model.GetUserByUid(record.Uid)
		days := model.GetPostagePackageMemberDuration(user.MemberLevel)
		durationRecord := &model.UserMemberDurationRecord{
			Uid:         record.Uid,
			Duration:    days,
			EventType:   1,
			MemberLevel: record.MemberLevel,
		}
		nowTime := time.Now()

		go func() {
			begin := model.DB.Begin()
			for i := 0; i < 10; i++ {
				userCoupon := &model.UserCoupon{
					Uid:          record.Uid,
					CouponId:     coupon.ID,
					CouponType:   coupon.CouponType,
					ActivityType: activity.ActivityType,
					ActivityId:   activity.ID,
					Value:        coupon.Value,
					State:        1,
					ActiveStart:  nowTime,
					ActiveEnd:    nowTime.AddDate(10, 0, 0),
					MemberLevel:  record.MemberLevel,
				}
				err = begin.Create(userCoupon).Error
				if err != nil {
					begin.Rollback()
					logger.Error("user coupon err:", err)
					return
				}
			}

			memberExpire := user.MemberExpire.AddDate(0, 0, int(days))
			err := model.NewUserQuerySet(begin).UidEq(record.Uid).GetUpdater().SetMemberExpire(memberExpire).Update()
			if err != nil {
				begin.Rollback()
				logger.Error("update member expire err:", err)
				return
			}

			err = begin.Create(durationRecord).Error
			if err != nil {
				logger.Error("create duration record err:", err)
				return
			}

			err = begin.Commit().Error
			if err != nil {
				begin.Rollback()
				logger.Error("commit err:", err)
				return
			}
		}()

		fundRecord.Uid = uint32(record.Uid)
		fundRecord.FundType = model.FundTypePostagePackageFee
		fundRecord.Remark = "购买运费包"
	}

	fundRecord.TransactionId = bankOrderNo
	fundRecord.OutTradeNo = outOrderNo
	fundRecord.Status = 2
	err = model.DB.Create(&fundRecord).Error
	if err != nil {
		logger.Error("create fund record err:", err)
	}
	logger.Debug("河马付推送支付通知-end")
	RespOK(c, "SUCCESS")
}

type WxPayRefundPlaintext struct {
	Mchid         string    `json:"mchid"`
	OutTradeNo    string    `json:"out_trade_no"`
	TransactionId string    `json:"transaction_id"`
	OutRefundNo   string    `json:"out_refund_no"`
	RefundId      string    `json:"refund_id"`
	RefundStatus  string    `json:"refund_status"`
	SuccessTime   time.Time `json:"success_time"`
	Amount        struct {
		Total       int `json:"total"`
		Refund      int `json:"refund"`
		PayerTotal  int `json:"payer_total"`
		PayerRefund int `json:"payer_refund"`
	} `json:"amount"`
	UserReceivedAccount string `json:"user_received_account"`
}

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

	mchID := "1609877389"
	mchAPIv3Key := "DeovoMingHuiRengTianTang45675123"                        // 商户APIv3密钥
	mchCertificateSerialNumber := "7540301D8FD52CCF7D6267DCF7CD2BC0AB467EFF" // 商户证书序列号

	mchPrivateKey, err := wechatpayutils.LoadPrivateKeyWithPath("./configs/merchant/apiclient_key.pem")
	if err != nil {
		log.Print("load merchant private key error")
	}
	ctx := context.Background()
	// 1. 使用 `RegisterDownloaderWithPrivateKey` 注册下载器
	err = downloader.MgrInstance().RegisterDownloaderWithPrivateKey(ctx, mchPrivateKey, mchCertificateSerialNumber, mchID, mchAPIv3Key)
	if err != nil {
		fmt.Println(err)
		return
	}
	// 2. 获取商户号对应的微信支付平台证书访问器
	certVisitor := downloader.MgrInstance().GetCertificateVisitor(mchID)
	// 3. 使用证书访问器初始化 `notify.Handler`
	handler := notify.NewNotifyHandler(mchAPIv3Key, verifiers.NewSHA256WithRSAVerifier(certVisitor))

	transaction := new(payments.Transaction)
	notifyReq, err := handler.ParseNotifyRequest(context.Background(), c.Request, transaction)
	// 如果验签未通过，或者解密失败
	if err != nil {
		fmt.Println(err)
		return
	}
	// 处理通知内容
	//fmt.Println(notifyReq.Summary)
	//fmt.Println(transaction.TransactionId)

	//transactionJson, _ := json.Marshal(transaction)
	//fmt.Println("transactionJson:", string(transactionJson))
	//notifyReqJson, _ := json.Marshal(notifyReq)
	//fmt.Println("notifyReqJson:", string(notifyReqJson))
	if notifyReq.EventType == "REFUND.SUCCESS" {
		plaintext := new(WxPayRefundPlaintext)
		err = json.Unmarshal([]byte(notifyReq.Resource.Plaintext), plaintext)
		if err != nil {
			logger.Error("unmarshal plaintext err:", err)
			return
		}
		count, err := model.NewFundRecordQuerySet(model.DB).RefundIdEq(plaintext.RefundId).Count()
		if err != nil {
			logger.Error("count refund id err:", err)
			return
		}
		plaintextJson, _ := json.Marshal(plaintext)
		fmt.Println("plaintextJson:", string(plaintextJson))

		if count == 0 {
			openMemberRecord := new(model.UserOpenMemberRecord)
			err = model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(plaintext.OutRefundNo).One(openMemberRecord)
			if err != nil {
				logger.Error("user open member record err:", err)
				return
			}
			//fundType := model.FundTypeExpressFeeRefund
			//if openMemberRecord.OrderType == 6 {
			//	fundType = model.FundTypeBuyGoodsRefund
			//}
			fundRecord := &model.FundRecord{
				Uid:           openMemberRecord.Uid,
				FundType:      GetFundRecordFundType(openMemberRecord.OrderType),
				Amount:        int64(plaintext.Amount.Refund) * (-1),
				TransactionId: plaintext.TransactionId,
				OutTradeNo:    plaintext.OutTradeNo,
				RefundId:      plaintext.RefundId,
				Status:        2,
				Remark:        GetFundRecordRemark(openMemberRecord.OrderType),
			}
			err = model.DB.Create(fundRecord).Error
			if err != nil {
				logger.Error("create fund record err:", err)
				return
			}
		}
	}

	RespNotice(c, "SUCCESS", "成功")
	return
	//logger.Error("xml Request.Body1:", string(body))
}

func GetFundRecordRemark(orderType uint32) string {
	switch orderType {
	case 5:
		return "邮费退款"
	case 7:
		return "商城购买取消订单"
	case 8:
		return "商城购买退货"
	}
	return ""
}

func GetFundRecordFundType(orderType uint32) string {
	switch orderType {
	case 2:
		return model.FundTypeExpressFeeRefund
	case 5:
		return model.FundTypeExpressFeeRefund
	case 7:
		return model.FundTypeBuyGoodsCancel
	case 8:
		return model.FundTypeBuyGoodsRefund
	}
	return ""
}

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.Info("微信推送支付通知  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)
}