mh_server/controller/order.go

package controller

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	"golang.org/x/sync/errgroup"
	"io/ioutil"
	"mh-server/kuaidi"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/wxpay"
	"mh-server/model"
	"sync"

	"time"
)

//func checkout(response http.ResponseWriter, request *http.Request)  {
//func WxMsg(c *gin.Context) {
//	// 获取参数
//	signature := c.PostForm("signature")
//	timestamp := c.PostForm("timestamp")
//	nonce := c.PostForm("nonce")
//	echostr := c.PostForm("echostr")
//
//	//timestamp := request.FormValue("echostr")
//	//nonce := request.FormValue("nonce")
//	//echostr := request.FormValue("echostr")
//
//	//将token、timestamp、nonce三个参数进行字典序排序
//	var tempArray = []string{TOKEN, timestamp, nonce}
//	sort.Strings(tempArray)
//
//	//将三个参数字符串拼接成一个字符串进行sha1加密
//	var sha1String string = ""
//	for _, v := range tempArray {
//		sha1String += v
//	}
//
//	h := sha1.New()
//	h.Write([]byte(sha1String))
//	sha1String = hex.EncodeToString(h.Sum([]byte("")))
//
//	//获得加密后的字符串可与signature对比
//	if sha1String == signature {
//		_, err := c.Writer.Write([]byte(echostr))
//		if err != nil {
//			fmt.Println("响应失败。。。")
//		}
//	} else {
//		fmt.Println("验证失败")
//	}
//}

func RentCardOrderList(c *gin.Context) {
	fmt.Println("RentCardOrderList")
	req := model.OrderListReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	req.Uid = uc.Uid

	orderCardList, totalPage, err := req.GetOrderCardList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

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

func OrderInfo(c *gin.Context) {
	req := struct {
		//OrderId         uint32 `json:"order_id"`
		//GameCardId      uint64 `json:"game_card_id"`        // 游戏id
		//GameCardGoodsId uint64 `json:"game_card_goods_id" ` // 游戏卡id
		OrderCardId uint32 `json:"order_card_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	order := model.Order{}
	//order.ID = req.OrderId
	//order.GameCardId = req.GameCardId
	info, err := order.Info(req.OrderCardId)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var orderCard model.OrderCard
	if len(info) > 0 {
		orderCard = info[0]
	}
	RespOK(c, orderCard)
	return
}

func OrderExpress(c *gin.Context) {
	req := struct {
		ExpressCompanyNo string `json:"express_company_no"`
		ExpressNo        string `json:"express_no"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("CompanyNo:", req.ExpressCompanyNo)
	fmt.Println("Num:", req.ExpressNo)

	expressInfo, err := kuaidi.ExpressInfo(req.ExpressCompanyNo, req.ExpressNo)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, expressInfo)
	return
}

func WXPaySuccess(c *gin.Context) {
	//fbConfig := model.GetFBConfig()
	//if fbConfig.AssistanceValidityTerm == 0 {
	//	logger.Error(errors.New("get assistance_validity_term err"))
	//	RespJson(c, status.DBOperateError, nil)
	//	return
	//}

	//assistanceValidityTerm := time.Unix(time.Now().Unix()+int64(fbConfig.AssistanceValidityTerm), 0)
	//ret := map[string]interface{}{
	//	"assistance_validity_term": assistanceValidityTerm,
	//	"postage":                  fbConfig.Postage,
	//}
	//RespOK(c, ret)
}

var orderCreateLocker sync.Mutex

// 创建订单
func RentCardOrderCreate(c *gin.Context) {
	req := struct {
		GameCardList  []model.CardInfo `json:"game_card_list"`
		StoreId       uint32           `json:"store_id"`
		UserAddressId uint32           `json:"user_address_id"`
		Price         uint32           `json:"price"`
		DeliveryType  uint8            `json:"delivery_type"` // 取货方式
		ExpressFee    uint32           `json:"express_fee"`
		UserCouponId  uint32           `json:"user_coupon_id"`
	}{}

	bodyString, err := ioutil.ReadAll(c.Request.Body)
	if err != nil {
		logger.Error(errors.New("OrderCreate ReadAll req err"))
		RespJson(c, status.BadRequest, nil)
		return
	}

	//bodyString := strings.Replace(string(body), "\"[", "[", -1)
	//bodyString = strings.Replace(string(bodyString), "]\"", "]", -1)
	//bodyString = strings.Replace(string(bodyString), "\\", "", -1)
	logger.Info("bodyString:", string(bodyString))

	err = json.Unmarshal([]byte(bodyString), &req)
	if err != nil {
		logger.Error(errors.New("OrderCreate Unmarshal req err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	fmt.Println("商品下单 req:", req)

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.BadRequest, nil)
		return
	}

	user := model.GetUserByUid(uc.Uid)
	if user == nil {
		logger.Error(errors.New("GetUserByUid err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	if user.MemberLevel == 1 {
		logger.Error(errors.New("user level  1"))
		RespJson(c, status.NotMember, nil)
		return
	}

	exist, err := model.QueryRecordExist(fmt.Sprintf("SELECT * FROM deposit_refund_record WHERE uid=%d AND `status`= %d", uc.Uid, model.DepositRefundStatusUnconfirmed))
	if err != nil {
		logger.Error("exist user deposit refund record  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if exist {
		logger.Error(errors.New("user deposit refund apply"))
		RespJson(c, status.UserApplyDepositRefund, nil)
		return
	}

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

	if user.Deposit != memberConfig.MemberDeposit {
		logger.Error(errors.New("user deposit  0"))
		RespJson(c, status.OrderUnpaidDeposit, nil)
		return
	}

	cardCount := uint32(0)
	for _, v := range req.GameCardList {
		cardCount += v.Count
	}

	var rentCard *model.UserRentCard
	var tx *gorm.DB
	if req.Price == 0 {
		fmt.Println("*********** req.Price == 0 ***********")
		tx = model.TransactionBegin()
		rentCard = model.GetUserRentCard(tx, uc.Uid)
		fmt.Println("*********** rentCard is:", rentCard)
		if rentCard == nil {
			//logger.Error(errors.New("GetUserByUid err"))
			//RespJson(c, status.InternalServerError, nil)
			//return
			rentCard = &model.UserRentCard{LevelRentCount: memberConfig.CardMax, CanRentCount: memberConfig.CardMax}
		}

	} else {
		fmt.Println("*********** req.Price != 0 ***********")
		rentCard = model.GetUserRentCard(nil, uc.Uid)
		fmt.Println("*********** rentCard is:", rentCard)
		if rentCard == nil {
			//logger.Error(errors.New("GetUserByUid err"))
			//RespJson(c, status.InternalServerError, nil)
			//return
			rentCard = &model.UserRentCard{LevelRentCount: memberConfig.CardMax, CanRentCount: memberConfig.CardMax}
		}
	}

	//if uc.Uid == 45935373 {
	//	rentCard.CanRentCount -= 1
	//}
	if cardCount > rentCard.CanRentCount {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("err:", "会员超过可借卡数")
		RespJson(c, status.OrderOutRentCount, nil)
		return
	}

	// 订单成功后 扣减库存
	//model.UnPayOrderSetCancel(user.Uid)

	orderCreateLocker.Lock()
	defer orderCreateLocker.Unlock()

	isRentCount, err := rentCard.IsHaveUnreturnedOrders(cardCount)
	//unreturnedOrders, err := model.IsHaveUnreturnedOrders(uc.Uid) //
	if err != nil {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if isRentCount {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("unreturnedOrders")
		RespJson(c, status.HaveUnreturnedOrders, nil)
		return
	}

	online, err := model.IsGameCardListOnline(req.GameCardList)
	if err != nil {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if !online {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("unreturnedOrders")
		RespJson(c, status.GoodsSoldOut, nil)
		return
	}
	store := &model.Store{}
	store.ID = req.StoreId
	err = store.Info()
	if err != nil {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("store err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//  邮费
	orderSn := model.GetOrderSn()

	order := model.Order{
		Uid:                   uint64(uc.Uid),
		GameCardId:            0,
		StoreId:               uint64(req.StoreId),
		UserAddressId:         uint64(req.UserAddressId),
		DeliveryType:          req.DeliveryType,
		Count:                 1,
		PickupCode:            model.GetPickupCode(), //  取货码
		CardStatus:            model.OrderCardStatusUnPick,
		PayStatus:             model.PayStatusUnPay,
		PayTime:               time.Now(),
		OrderSn:               orderSn,
		PayPrice:              req.Price,
		Postage:               req.ExpressFee,
		CooperativeBusinessId: store.CooperativeBusinessId,
		CooperativeName:       store.CooperativeName,
		PostageType:           1,
	}
	var userCoupon model.UserCoupon
	//err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uc.Uid).StateEq(1).
	//	OrderAscByID().Limit(1).One(&userCoupon)
	err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&userCoupon)
	if err != nil && err != model.RecordNotFound {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("user coupon err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if err == nil && userCoupon.Uid == uc.Uid &&
		userCoupon.State == 1 && userCoupon.ActivityType == 3 {
		req.Price = 0
		order.PostageType = 2
	}

	// 以支付成功作为订单下单成功的依据，不是订单创建   已修改
	//var gameCardGoodsStock model.GameCardGoodsStock
	//err = model.NewGameCardGoodsStockQuerySet(model.DB).StoreIdEq(req.StoreId).GameCardIdEq(req.GameCardId).One(&gameCardGoodsStock)
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	//if gameCardGoodsStock.RentStock <= 0 {
	//	logger.Error("order stock out ")
	//	RespJson(c, status.OrderStockOut, nil)
	//	return
	//}
	stockEnough, err := model.IsCardGoodsStockEnough(req.GameCardList, req.StoreId)
	if err != nil {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("err:", err)
		RespJson(c, status.OrderStockOut, nil)
		return
	}
	if stockEnough {
		if req.Price == 0 {
			tx.Rollback()
		}
		logger.Error("order stock out ")
		RespJson(c, status.OrderStockOut, nil)
		return
	}
	//if user.OpenMemberChannel == model.OpenMemberChannelStorePromotion {
	//	go func() {
	//		exist, err := model.QueryRecordExist(fmt.Sprintf("SELECT * FROM `order` WHERE uid = %d", uc.Uid))
	//		if err != nil {
	//			logger.Error("order exist err:", err)
	//			return
	//		}
	//
	//		if !exist && user.OpenMemberTime.Format(model.DateTimeFormat) == time.Now().Format(model.DateTimeFormat) {
	//			_, err = model.NewUserQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetStoreId(uint64(req.StoreId)).UpdateNum()
	//			if err != nil {
	//				logger.Error("update user err:", err)
	//			}
	//		}
	//	}()
	//}

	//fmt.Println("PayPrice:", order.PayPrice)
	if req.Price == 0 {
		if tx == nil {
			tx = model.TransactionBegin()
		}
		order.PayStatus = model.PayStatusPaid
		fmt.Println("orderId:", order.PayStatus)
		err = order.OrderCreate(tx)
		if err != nil {
			tx.Rollback()
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		// 减库存
		//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", req.StoreId, req.GameCardId)
		//fmt.Println("sql:", sql)
		//err = model.DB.Exec(sql).Error
		//if err != nil {
		//	logger.Errorf("err:", err)
		//	RespJson(c, status.InternalServerError, nil)
		//	return
		//}
		err = model.GameCardGoodsInventoryReduction(req.GameCardList, req.StoreId, tx)
		if err != nil {
			tx.Rollback()
			logger.Error("inventory reduction err:", err.Error())
			RespJson(c, status.InternalServerError, nil)
			return
		}
		err = order.CreatOrderCard(req.GameCardList, req.StoreId, tx)
		if err != nil {
			tx.Rollback()
			logger.Error("inventory reduction err:", err.Error())
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if userCoupon.ID != 0 {
			err = model.NewUserCouponQuerySet(tx).IDEq(userCoupon.ID).GetUpdater().SetState(2).Update()
			if err != nil {
				tx.Rollback()
				logger.Error("update user coupon state err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}
		err = tx.Commit().Error
		if err != nil {
			tx.Rollback()
			logger.Error("commit err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		go model.OrderCardUserRentCard(uc.Uid, cardCount, memberConfig, nil)
		ret := map[string]interface{}{
			"web_pay":  "",
			"order_id": order.ID,
		}

		go model.ShoppingCartCreateOrder(uc.Uid, req.GameCardList)
		RespOK(c, ret)
		return
	}

	//err = order.OrderCreate()
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	begin := model.DB.Begin()
	err = order.Create(begin)
	if err != nil {
		begin.Rollback()
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	// 减库存
	//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", req.StoreId, req.GameCardId)
	//fmt.Println("sql:", sql)
	//err = begin.Exec(sql).Error
	//if err != nil {
	//	begin.Rollback()
	//	logger.Errorf("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	//   订单回调成功减库存
	//err = model.GameCardGoodsInventoryReduction(req.GameCardList, req.StoreId, begin)
	//if err != nil {
	//	begin.Rollback()
	//	logger.Error("inventory reduction err:%s", err.Error())
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	err = order.CreatOrderCard(req.GameCardList, req.StoreId, begin)
	if err != nil {
		begin.Rollback()
		logger.Error("inventory reduction err:", err.Error())
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//orderId := fmt.Sprintf("%d", order.ID)
	//orderId = "100000"
	//fmt.Println("orderId", orderId)
	//fmt.Println("Price", req.Price)
	//fmt.Println("WxOpenID", user.WxOpenID)
	//fmt.Println("WxPayRentCard", wxpay.WxPayRentCard)
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, OrderId: order.ID, OrderType: 1, Attach: wxpay.WxPayRentCard}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//webPay, err := wxpay.WebPay(order.OrderSn, req.Price, user.WxOpenID, "N", wxpay.WxPayRentCard, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	webPay, err := wxpay.HmJsPayUnifiedOrder(order.OrderSn, req.Price, user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//webPay, err := wxpay.HmJsPayUnifiedOrder(order.OrderSn, req.Price, user.WxOpenID, "N", wxpay.WxPayRentCard, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	//num, err := model.NewOrderQuerySet(model.DB).IDEq(order.ID).GetUpdater().
	//	SetOutTradeNo(webPay.NonceStr).SetMchid(config.AppConfig.WxMchID).UpdateNum()
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	//if num == 0 {
	//	logger.Error("UpdateNum is 0")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	ret := map[string]interface{}{
		"web_pay":  webPay,
		"order_id": order.ID,
	}

	RespOK(c, ret)
	return
}

//func ExpressFeeRefund(c *gin.Context) {
//	req := struct {
//		OrderId uint32 `json:"order_id"`
//	}{}
//	if c.ShouldBindJSON(&req) != nil {
//		logger.Error("ShouldBindJSON err")
//		RespJson(c, status.BadRequest, nil)
//		return
//	}
//	order := model.Order{}
//	order.ID = req.OrderId
//	order.Info()
//	outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(req.OrderId)
//	if err != nil {
//		logger.Error("err:", err)
//		return
//	}
//
//	orderSn := model.GetOrderSn()
//	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,
//		OutRefundNo: orderSn,
//		NotifyUrl:   "",
//		Amount: wxpay.OrderRefundAmount{
//			Refund:   order.Postage,
//			Total:    order.Postage,
//			Currency: "CNY",
//		},
//	}
//	err = wxpay.WxPayOrderRefund(orderRefund)
//	if err != nil {
//		logger.Error("err:", err)
//	}
//
//}

//func ExpressFeeRefund(c *gin.Context) {
//	req := struct {
//		OrderId uint32 `json:"order_id"`
//	}{}
//	if c.ShouldBindJSON(&req) != nil {
//		logger.Error("ShouldBindJSON err")
//		RespJson(c, status.BadRequest, nil)
//		return
//	}
//	order := model.Order{}
//	order.ID = req.OrderId
//	order.Info()
//	outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(req.OrderId)
//	if err != nil {
//		logger.Error("err:", err)
//		return
//	}
//
//	orderSn := model.GetOrderSn()
//	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,
//		OutRefundNo: orderSn,
//		NotifyUrl:   "",
//		Amount: wxpay.OrderRefundAmount{
//			Refund:   order.Postage,
//			Total:    order.Postage,
//			Currency: "CNY",
//		},
//	}
//	err = wxpay.WxPayOrderRefund(orderRefund)
//	if err != nil {
//		logger.Error("err:", err)
//	}
//
//}

const (
	PayStatusUnPay = 1 // 未支付
	PayStatusPaid  = 2 // 已支付

	OrderCardStatusUnPick    = 1 // 待取货中
	OrderCardStatusPlaying   = 2 // 游玩中
	OrderCardStatusReturning = 3 // 归还中
	OrderCardStatusCompleted = 4 // 已完成
	OrderCardStatusCancel    = 5 // 已取消
	OrderCardStatusRefund    = 6 // 已退款
)

// 创建订单
func OrderPay(c *gin.Context) {
	req := struct {
		OrderId uint32 `json:"order_id"`
		//StoreId       uint64 `json:"store_id"`
		//UserAddressId uint64 `json:"user_address_id"`
		//Price         uint32 `json:"price"`
		//DeliveryType  uint8  `json:"delivery_type"` // 取货方式
		//ExpressFee    uint32 `json:"express_fee"`
		//
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error("ShouldBindJSON err:", err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	var order model.Order
	err := model.NewOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order)
	if err != nil {
		logger.Error("Order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if order.PayStatus != PayStatusUnPay || order.CardStatus != OrderCardStatusUnPick || order.CreatedAt.Add(30*time.Minute).Before(time.Now()) {
		//if order.PayStatus != PayStatusUnPay || order.CardStatus != OrderCardStatusUnPick || order.CreatedAt.Add(3*time.Minute).Before(time.Now()) {
		logger.Error("Order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//orderId := fmt.Sprintf("%d", order.ID)
	var user model.User
	err = model.NewUserQuerySet(model.DB).UidEq(uint32(order.Uid)).One(&user)
	if err != nil {
		logger.Error("Order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//webPay, err := wxpay.WebPay(order.OrderSn, order.PayPrice, user.WxOpenID, "N", wxpay.WxPayRentCard, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	orderSn := model.GetOrderSn()
	err = model.UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 1, Attach: wxpay.WxPayRentCard}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	webPay, err := wxpay.HmJsPayUnifiedOrder(order.OrderSn, order.PayPrice, user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	ret := map[string]interface{}{
		"web_pay":  webPay,
		"order_id": order.ID,
	}
	RespOK(c, ret)
}

func OrderAmount(c *gin.Context) {
	req := struct {
		StoreId       uint32 `json:"store_id" binding:"required"`
		UserAddressId uint32 `json:"user_address_id" binding:"required"`
		Price         uint32 `json:"price" `
		UserCouponId  uint32 `json:"user_coupon_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error("ShouldBindJSON err:", err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var (
		eg          errgroup.Group
		userAddress = &model.UserAddress{}
		store       = &model.Store{}
	)

	eg.Go(func() error {
		store.ID = req.StoreId
		err := store.Info()
		if err != nil {
			logger.Error("err:", err)
		}
		return nil
	})

	eg.Go(func() error {
		userAddress.ID = req.UserAddressId
		err := userAddress.Info()
		if err != nil {
			logger.Error("err:", err)
		}
		return nil
	})

	if err := eg.Wait(); err != nil {
		logger.Error("err:", err)
		//fmt.Println("Successfully fetched all URLs.")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//model.UserCoupon{}
	expressFee := model.ExpressFeeProvince
	//if userAddress.Province != "广东省" {
	if userAddress.Province != store.Province {
		expressFee = model.ExpressFeeOutsideProvince
	}

	hasPostagePackage := 0
	if req.UserCouponId != 0 {
		var userCoupon model.UserCoupon
		err := model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&userCoupon)
		if err != nil {
			logger.Error("user coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		if userCoupon.State == 1 && userCoupon.ActivityType == 3 && userCoupon.Uid == uc.Uid {
			expressFee = 0
		}
	} else {
		exist, err := model.QueryRecordExist(fmt.Sprintf("SELECT * FROM user_coupon WHERE uid=%d AND activity_type=3 AND state=1", uc.Uid))
		if err != nil {
			logger.Error("user coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if !exist {
			err := model.DB.Exec("UPDATE statistic  SET count=count+1 WHERE event_type=1").Error
			if err != nil {
				logger.Error("update statistic err:", err)
			}
			hasPostagePackage = 1
		}
	}
	hasPostagePackage = 1

	ret := map[string]interface{}{
		"total_amount":        req.Price + uint32(expressFee),
		"express_fee":         expressFee,
		"has_postage_package": hasPostagePackage,
	}
	RespOK(c, ret)
	return
}

//func WXPay(c *gin.Context) {
//	req := struct {
//		//TotalFee uint32 `json:"total_fee"`
//		AddressId uint32 `json:"address_id"`
//		OrderSn   string `json:"order_sn"`
//	}{}
//	if err := c.ShouldBindJSON(&req); err != nil {
//		logger.Error(err)
//		RespJson(c, status.BadRequest, nil)
//		return
//	}
//
//	uc := auth.GetCurrentUser(c)
//	if uc == nil {
//		RespJson(c, status.Unauthorized, nil)
//		return
//	}
//
//	//user := model.GetUserByUid(uc.Uid)
//
//	var order model.Order
//	// 支付金额    地址id
//	err := model.NewOrderQuerySet(model.DB).OrderSnEq(req.OrderSn).One(&order)
//	if err != nil {
//		logger.Error(err)
//		RespJson(c, status.DBOperateError, nil)
//		return
//	}
//
//	//if err := model.NewFBOrderQuerySet(model.DB).OrderSnEq(req.OrderSn).GetUpdater().
//	//	SetAddressId(req.AddressId).Update(); err != nil {
//	//	logger.Error(err)
//	//	RespJson(c, status.DBOperateError, nil)
//	//	return
//	//}
//	//
//	//var sextuple *wxpay.Sextuple
//	//sextuple, err = wxpay.FBXiaoChengXuPay(order.PayPrice, req.OrderSn, model.FB_WX_PAY_TYPE, user.WxOpenID)
//	//if err != nil {
//	//	logger.Error(err)
//	//	RespJson(c, status.InternalServerError, nil)
//	//	return
//	//}
//
//	//RespOK(c, sextuple)
//}

func ConfirmReceipt(c *gin.Context) {
	req := struct {
		OrderId    uint32 `json:"order_id"`
		GameCardId uint32 `json:"game_card_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	order := model.Order{Uid: uint64(uc.Uid)}
	order.ID = req.OrderId
	order.GameCardId = uint64(req.GameCardId)
	order.CardStatus = model.OrderCardStatusPlaying
	info, err := order.Modify()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, info)
	return
}

func ExpressCompanyList(c *gin.Context) {
	company := &model.ExpressCompany{}
	list, err := company.List()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, list)
	return
}

func OrderRevert(c *gin.Context) {
	order := &model.Order{}
	if c.ShouldBindJSON(order) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	//order := model.Order{}
	//order.ID = req.OrderId
	err := order.Revert()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.OrderCompleted, nil)
		return
	}

	RespOK(c, nil)
	return
}

func OrderRevertCancel(c *gin.Context) {
	order := &model.Order{}
	if c.ShouldBindJSON(order) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	//order := model.Order{}
	//order.ID = req.OrderId
	_, err := order.RevertCancel()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.OrderStatusNotReturning, nil)
		return
	}
	//if isRecede {
	//	outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
	//	if err != nil {
	//		logger.Error("err:", err)
	//		RespJson(c, status.InternalServerError, nil)
	//		return
	//	}
	//
	//	orderSn := model.GetOrderSn()
	//	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,
	//		OutRefundNo: orderSn,
	//		NotifyUrl:   "",
	//		Amount: wxpay.OrderRefundAmount{
	//			Refund:   order.PayPrice,
	//			Total:    order.PayPrice,
	//			Currency: "CNY",
	//		},
	//	}
	//	//bytes, _ := json.Marshal(orderRefund)
	//	//fmt.Println("订单取消:", string(bytes))
	//	//err = wxpay.WxPayOrderRefund(orderRefund)
	//	err = wxpay.TransactionOrderRefund(orderRefund)
	//	if err != nil {
	//		logger.Error("err:", err)
	//		RespJson(c, status.InternalServerError, nil)
	//		return
	//	}
	//}
	RespOK(c, nil)
	return
}

func OrderCancel(c *gin.Context) {
	order := model.Order{}
	if c.ShouldBindJSON(&order) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	//uc := auth.GetCurrentUser(c)
	//if uc == nil {
	//	logger.Error("uc is nil")
	//	RespJson(c, status.Unauthorized, nil)
	//	return
	//}
	fmt.Println("OrderId:", order.ID)
	//order := &model.Order{}
	//order.ID = req.OrderId
	isRecede, orderInfo, err := order.Cancel()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.OrderDelivered, nil)
		return
	}
	order = orderInfo
	fmt.Println("order:", order)
	if isRecede {
		if order.PostageType == 1 {
			outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
			if err != nil {
				logger.Error("err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
			//m.OpenNo = model.GetOrderSn()
			memberRecord := &model.UserOpenMemberRecord{OpenNo: model.GetOrderSn(), OrderType: 2, Order: &order}
			err = memberRecord.OrderRefund(outTradeNo)
			if err != nil {
				logger.Error("err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}

		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)
			}
		}
		//orderSn := model.GetOrderSn()
		//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,
		//	OutRefundNo: orderSn,
		//	NotifyUrl:   "",
		//	Amount: wxpay.OrderRefundAmount{
		//		Refund:   order.PayPrice,
		//		Total:    order.PayPrice,
		//		Currency: "CNY",
		//	},
		//}
		//err = wxpay.TransactionOrderRefund(orderRefund)
		//if err != nil {
		//	logger.Error("err:", err)
		//	RespJson(c, status.InternalServerError, nil)
		//	return
		//}

		//bytes, _ := json.Marshal(order)
		//fmt.Println("订单取消:", string(bytes))
		//orderRefundJson, _ := json.Marshal(&orderRefund)
		//fmt.Println("订单取消 orderRefundJson:", string(orderRefundJson))
		//err = wxpay.WxPayOrderRefund(orderRefund)

	}

	RespOK(c, nil)
	return
}