duoduo/apis/shanghu/merchant.card.go

package shanghu

import (
	"context"
	"duoduo/apis/common"
	"duoduo/apis/pdd"
	"duoduo/apis/shanghu/models"
	"duoduo/conf"
	"duoduo/models/shanghu"
	"duoduo/tools"
	"duoduo/tools/app"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/qiniu/go-sdk/v7/auth/qbox"
	"github.com/qiniu/go-sdk/v7/storage"
	"github.com/shopspring/decimal"
	"strconv"
	"time"
)

func CreateMerchantCard(c *gin.Context) {
	var inData models.CreateMerchantCardRequest
	var sqlData shanghu.MerchantCard

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.CreatedAt = time.Now()
	sqlData.UpdatedAt = time.Now()
	jsStr, err := json.Marshal(inData.CardProjectData)
	if err != nil {
		app.Error(c, 400, err, "包含项目不能为空")
		return
	}

	sqlData.CardProjectData = string(jsStr)
	sqlData.CardPrice = inData.CardPrice
	sqlData.CardTotalPrice = inData.CardTotalPrice
	sqlData.ActivityEndTime, err = tools.TimeToInt64(inData.ActivityEndTime, "2006-01-02")
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.ActivityStartTime, err = tools.TimeToInt64(inData.ActivityStartTime, "2006-01-02")
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.Inventory, err = strconv.ParseInt(inData.Inventory, 10, 64)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.MerchantCardTime, err = tools.TimeToInt64(inData.MerchantCardTime, "2006-01-02")
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.MerchantOpenID = inData.MerchantOpenID
	sqlData.Picture = inData.Picture
	sqlData.QuotaNum, err = strconv.ParseInt(inData.QuotaNum, 10, 64)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.RebateRate, err = strconv.ParseInt(inData.RebateRate, 10, 64)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.UseRule = inData.UseRule
	sqlData.MerchantCardName = inData.MerchantCardName

	sqlData.CancelNumber, err = strconv.Atoi(inData.CancelNumber)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.BackgroundImage = inData.BackgroundImage

	_, err = sqlData.Create()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	app.OK(c, nil, app.Success)

}

func GetMerchantCard(c *gin.Context) {
	var inData models.GetMerchantCardRequest
	var outData models.GetMerchantCardReply
	var sqlData shanghu.MerchantCard
	var project []int64

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.ID = inData.MerchantId

	merchantCard, err := sqlData.GetMerchantCard()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	err = json.Unmarshal([]byte(merchantCard.CardProjectData), &project)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	merchantCard.CardProjectData = ""
	for i := 0; i < len(project); i++ {
		var cardProject shanghu.MerchantCardProject
		cardProject.ID = project[i]
		projectInfo, err := cardProject.GetMerchantCardProject()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		merchantCard.CardProjectData = merchantCard.CardProjectData + projectInfo.ProjectName + "x1 "
	}
	outData.CardProjectData = merchantCard.CardProjectData
	outData.MerchantCardName = merchantCard.MerchantCardName
	outData.MerchantCardTime = time.Unix(merchantCard.MerchantCardTime, 0).Format("2006-01-02")
	outData.ActivityEndTime = time.Unix(merchantCard.ActivityEndTime, 0).Format("2006-01-02")
	outData.ActivityStartTime = time.Unix(merchantCard.ActivityStartTime, 0).Format("2006-01-02")
	outData.Picture = merchantCard.Picture
	outData.UseRule = merchantCard.UseRule
	outData.QuotaNum = merchantCard.QuotaNum
	outData.Inventory = merchantCard.Inventory
	outData.RebateRate = merchantCard.RebateRate
	outData.CardPrice = merchantCard.CardPrice
	outData.X = merchantCard.X
	outData.Y = merchantCard.Y
	outData.W = merchantCard.W
	outData.H = merchantCard.H
	outData.BackgroundImage = merchantCard.BackgroundImage
	outData.CardTotalPrice = merchantCard.CardTotalPrice

	app.OK(c, outData, app.Success)

}

func GetMerchantCancelInfo(c *gin.Context) {
	var inData models.GetMerchantCancelInfoRequest
	var outData models.GetMerchantCardInfoReply
	var qrMessage models.QRData
	var merchantCardData shanghu.MerchantCard
	var clientPay shanghu.ClientPayTrans
	var project []int64
	var cancelNum shanghu.CancelLog

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	err = json.Unmarshal([]byte(inData.QRMessage), &qrMessage)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	clientPay.MerchantCardID = qrMessage.MerchantId
	clientPay.ClientOpenID = qrMessage.ClientOpenId
	clientInfo, err := clientPay.GetPayTransByOpenid()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	outData.PayTime = clientInfo.PayTime.Format(time.DateTime)

	merchantCardData.ID = qrMessage.MerchantId
	merchantInfo, err := merchantCardData.GetMerchantCard()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	cancelNum.ClientOpenID = qrMessage.ClientOpenId
	cancelNum.MerchantID = qrMessage.MerchantId

	outData.MerchantCardName = merchantInfo.MerchantCardName
	outData.MerchantCardTime = tools.TimeToStr(merchantInfo.MerchantCardTime)
	outData.TotalCancelNumber = merchantInfo.CancelNumber
	outData.CancelNumber = merchantInfo.CancelNumber - cancelNum.GetNumber()

	err = json.Unmarshal([]byte(merchantInfo.CardProjectData), &project)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	for i := 0; i < len(project); i++ {
		var cardProject shanghu.MerchantCardProject
		var cardProjectInfo models.CardProjectInfo
		cardProject.ID = project[i]

		projectInfo, err := cardProject.GetMerchantCardProject()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}

		cardProjectInfo.ProjectUnit = projectInfo.ProjectUnit
		cardProjectInfo.ProjectName = projectInfo.ProjectName
		cardProjectInfo.ProjectUnitPrice = projectInfo.ProjectUnitPrice
		outData.CardProjectData = append(outData.CardProjectData, cardProjectInfo)
	}

	app.OK(c, outData, app.Success)
}

// 核销详情
func GetChargeMerchantCancelInfo(c *gin.Context) {
	var inData models.GetMerchantCancelInfoRequest
	var outData models.GetChargeMerchantCancelInfoReply
	var qrMessage models.RechargeVerificationCodeReply
	var clientAccount shanghu.MerchantRechargeClientAccount
	var clientTicket shanghu.MerchantClientTicket
	var merchant shanghu.Merchant

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	err = json.Unmarshal([]byte(inData.QRMessage), &qrMessage)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	key := tools.MD5(qrMessage.MerchantOpenId + "zhangkun429@")

	key = "CHARGE" + key

	if key != qrMessage.Key {
		app.Error(c, 400, errors.New("报文错误"), "报文错误")
		return
	}

	clientAccount.MerchantOpenID = qrMessage.MerchantOpenId
	clientAccount.ClientOpenID = qrMessage.ClientOpenId
	clientInfo, err := clientAccount.MerchantRechargeClientAccount()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	clientTicket.ClientOpenID = qrMessage.ClientOpenId
	clientTicket.MerchantOpenID = qrMessage.MerchantOpenId

	//获取券
	clientTicketInfo, err := clientTicket.GetMerchantRechargeTicket()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	merchant.OpenId = qrMessage.MerchantOpenId
	merchantInfo, err := merchant.GetMerchant()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	outData.MerchantName = merchantInfo.MerchantName
	outData.Amount = clientInfo.Amount.String()
	outData.AccountId = clientInfo.ID
	for _, v := range clientTicketInfo {
		var chargeProject models.ChargeMerchantCancelInfo
		var project shanghu.MerchantRechargeProject

		project.ID = v.RechargeProjectID
		projectInfo, err := project.GetMerchantRechargeProjectById()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}

		chargeProject.ProjectQuantity = projectInfo.ProjectQuantity
		chargeProject.TicketId = v.ID
		chargeProject.RechargeProjectQuantity = v.RechargeProjectQuantity
		chargeProject.RechargeProjectName = v.RechargeProjectName
		outData.ChargeMerchantCancelInfo = append(outData.ChargeMerchantCancelInfo, chargeProject)
	}

	app.OK(c, outData, app.Success)
}
func GetMerchantCanvasCard(c *gin.Context) {
	var inData models.GetMerchantCardRequest
	var outData models.GetMerchantCanvasCardReply
	var sqlData shanghu.MerchantCard
	var project []int64
	var qr models.QRRequest
	var getQR models.GetQRRequest

	confIni, err := conf.ConnIni()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	err = c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlData.ID = inData.MerchantId

	merchantCard, err := sqlData.GetMerchantCard()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	if merchantCard.ActivityEndTime <= time.Now().Unix() {
		app.Error(c, 500, errors.New("活动已结束"), "活动已结束")
		return
	}

	outData.Static.Background = "/images/背景.jpg"
	var swiperList []models.SwiperList
	var rightButton models.RightButton
	var swiper models.SwiperList

	swiper.ID = 0
	swiper.URL = merchantCard.Picture
	swiperList = append(swiperList, swiper)
	//err = json.Unmarshal([]byte(merchantCard.Picture), &swiperList)
	//if err != nil {
	//	fmt.Println("picture")
	//	app.Error(c, 500, err, err.Error())
	//	return
	//}

	outData.Inventory = merchantCard.Inventory
	outData.SwiperList = swiperList

	rightButton.ImageURL = "/images/资源 24.png"
	outData.RightButton = append(outData.RightButton, rightButton)
	rightButton.ImageURL = "/images/资源 25.png"
	outData.RightButton = append(outData.RightButton, rightButton)
	rightButton.ImageURL = "/images/资源 26.png"
	outData.RightButton = append(outData.RightButton, rightButton)
	rightButton.ImageURL = "/images/资源 28.png"
	outData.RightButton = append(outData.RightButton, rightButton)

	var dataList models.DataList

	err = json.Unmarshal([]byte(merchantCard.CardProjectData), &project)
	if err != nil {
		fmt.Println("picture2")
		app.Error(c, 500, err, err.Error())
		return
	}

	//merchantCard.CardProjectData = ""
	for i := 0; i < len(project); i++ {
		var cardProject shanghu.MerchantCardProject
		cardProject.ID = project[i]
		projectInfo, err := cardProject.GetMerchantCardProject()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		dataList.Name = projectInfo.ProjectName
		dataList.Count = 1
		dataList.Price = projectInfo.ProjectUnitPrice
		dataList.Unit = projectInfo.ProjectUnit
		outData.DataList = append(outData.DataList, dataList)
	}
	var buy models.BuyKnowList

	//buy.Icon = "/images/资源 46.png"
	//buy.Title = "有效期"
	//buy.Text = "至" + tools.TimeToStr(merchantCard.MerchantCardTime)
	//outData.BuyKnowList = append(outData.BuyKnowList, buy)
	buy.Icon = "/images/资源 48.png"
	buy.Title = "限购数量"
	buy.Text = "每位用户限购1张"
	outData.BuyKnowList = append(outData.BuyKnowList, buy)
	buy.Icon = "/images/资源 49.png"
	buy.Title = "使用规则"
	buy.Text = merchantCard.UseRule
	outData.BuyKnowList = append(outData.BuyKnowList, buy)

	var shopData models.ShopData
	var merchant shanghu.Merchant
	merchant.OpenId = merchantCard.MerchantOpenID
	merchantInfo, err := merchant.GetMerchant()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	shopData.Name = merchantInfo.MerchantName
	shopData.Address = merchantInfo.Address
	outData.ShopData = shopData

	outData.FenxiangShow = false

	outData.MerchantAmount, err = decimal.NewFromString(merchantCard.CardPrice)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	outData.MerchantOriginalAmount, err = decimal.NewFromString(merchantCard.CardTotalPrice)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	//outData.MerchantOriginalAmount = outData.MerchantAmount.Add(decimal.NewFromInt(50))

	var outQRData models.ClientCardQRReply

	val, err := pdd.DuoDuoGet("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=wx8595c589dd736486&secret=668f87d2bc24199688e53ee8a88434b8")
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	err = tools.JsonUnmarshal(val, &outQRData)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	if outQRData.AccessToken == "" {
		app.Error(c, 500, err, "token error")
		return
	}
	url := "https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=" + outQRData.AccessToken

	//1.原始码 不需要购买直接分享 ==原生码直接分享
	//2.code 本人openid 需要购买才能分享
	//3.空的 官方邀请码

	//返回邀请码
	var qrCode string
	if inData.Code == "yuanshima" && inData.Openid == "" { //商家平台 可以分享   code 等于自己的与yuanshima的都给平台
		outData.IsShare = true
		outData.InvitationCode = "yuanshima"
		qrCode = "yuanshima"
	} else if inData.Code == "yuanshima" && inData.Openid != "" { // 原始码 c端用户调用
		var userInfo shanghu.MerchantClientUser
		outData.IsShare = true
		userInfo.ClientOpenID = inData.Openid
		userInfoReply, _ := userInfo.GetUserInfo()
		qrCode = userInfoReply.Code
		outData.InvitationCode = inData.Code
	} else if inData.Code != "yuanshima" && inData.Openid != "" && inData.Code != "" { //查询购买记录，没有购买过不让分享
		var payTrans shanghu.ClientPayTrans
		var userInfo shanghu.MerchantClientUser

		payTrans.MerchantCardID = inData.MerchantId
		payTrans.ClientOpenID = inData.Openid
		payInfo, _ := payTrans.GetPayTransByOpenid()
		if payInfo.ID <= 0 {
			outData.IsShare = false
		} else {
			outData.IsShare = true
		}

		outData.InvitationCode = inData.Code

		userInfo.ClientOpenID = inData.Openid
		userInfoReply, _ := userInfo.GetUserInfo()
		qrCode = userInfoReply.Code
	} else {
		app.Error(c, 500, errors.New("code 错误"), "code 错误")
		return
	}

	//点击购买的时候把code给进去把 原始码购买属于平台

	qr.CheckPath = true
	qr.Page = "pages/home/home"
	qr.EnvVersion = "release"
	qr.Scene = "id-" + strconv.FormatInt(inData.MerchantId, 10) + "-c-" + qrCode

	fmt.Println(qr.Scene)
	data, err := json.Marshal(&qr)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	reply, err := common.Post(data, url)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	if getQR.Errcode != 0 {
		app.Error(c, 500, err, getQR.Errmsg)
		return
	}

	encoded := base64.StdEncoding.EncodeToString(reply)

	outData.Base64Img = encoded

	//上传二维码文件
	timeUnixNano := time.Now().UnixNano() //单位纳秒
	fileName := fmt.Sprintf("%d.jpg", timeUnixNano)

	//七牛云上传图片
	bucket := "imgxx"
	key := "shanghuka/" + "erweima/" + time.Now().Format(time.DateOnly) + "/" + fileName

	putPolicy := storage.PutPolicy{
		Scope: bucket,
	}

	mac := qbox.NewMac(confIni.MustValue("ly-qn", "access_key"), confIni.MustValue("ly-qn", "secret_key"))
	upToken := putPolicy.UploadToken(mac)

	cfg := storage.Config{}
	// 空间对应的机房
	cfg.Zone = &storage.ZoneHuanan
	// 是否使用https域名
	cfg.UseHTTPS = false
	// 上传是否使用CDN上传加速
	cfg.UseCdnDomains = false

	// 构建表单上传的对象
	baseUploader := storage.NewBase64Uploader(&cfg)
	ret := storage.PutRet{}
	//data, err := base64.RawStdEncoding.DecodeString(inData.Pictures[i])
	//if err != nil {
	//	app.Error(c, 500, err, "上传图片失败")
	//	return
	//}

	err = baseUploader.Put(context.Background(), &ret, upToken, key, []byte(encoded), nil)
	if err != nil {
		app.Error(c, 500, err, "上传图片失败")
		return
	}

	outData.QRUrl = "http://lingyang.shisanmiao.com/" + key

	//err = json.Unmarshal([]byte(merchantCard.CardProjectData), &project)
	//if err != nil {
	//	app.Error(c, 500, err, err.Error())
	//	return
	//}
	//
	//merchantCard.CardProjectData = ""
	//for i := 0; i < len(project); i++ {
	//	var cardProject shanghu.MerchantCardProject
	//	cardProject.ID = project[i]
	//	projectInfo, err := cardProject.GetMerchantCardProject()
	//	if err != nil {
	//		app.Error(c, 500, err, err.Error())
	//		return
	//	}
	//	merchantCard.CardProjectData = merchantCard.CardProjectData + projectInfo.ProjectName + "x1 "
	//}

	app.OK(c, outData, app.Success)

}

func MerchantCardList(c *gin.Context) {
	var inData models.MerchantCardListRequest
	var sqlData shanghu.MerchantCard
	var outData []models.MerchantCardListReply

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	var pageSize = 10
	var pageIndex = 1

	if inData.PageSize != 0 {
		pageSize = inData.PageSize
	}
	if inData.PageIndex != 0 {
		pageIndex = inData.PageIndex
	}

	sqlData.MerchantOpenID = inData.OpenId

	merchantCard, count, err := sqlData.GetOpenIdList(pageSize, pageIndex, inData.TypeList)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	for _, v := range merchantCard {
		var merchant models.MerchantCardListReply
		var payNumber shanghu.ClientPayTrans
		merchant.ID = v.ID
		merchant.MerchantCardName = v.MerchantCardName
		merchant.ActivityEnd = tools.TimeToStr(v.ActivityEndTime)
		merchant.ActivityStart = tools.TimeToStr(v.ActivityStartTime)
		merchant.CardPrice = v.CardPrice
		payNumber.MerchantCardID = v.ID
		merchant.SaleCardNumber = payNumber.GetNumByCardID()

		outData = append(outData, merchant)
	}
	app.PageOK(c, outData, count, pageIndex, pageSize, app.Success)
	return

	//app.PageOK(c, merchantCard, count, pageIndex, pageSize, app.Success)

}

// c端获取卡信息
func MerchantClientCardList(c *gin.Context) {
	var inData models.MerchantCardListRequest
	var sqlData shanghu.MerchantCard
	var outData []models.MerchantCardListReply

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	var pageSize = 10
	var pageIndex = 1

	if inData.PageSize != 0 {
		pageSize = inData.PageSize
	}
	if inData.PageIndex != 0 {
		pageIndex = inData.PageIndex
	}

	merchantCard, count, err := sqlData.ClientGetOpenIdList(pageSize, pageIndex, inData.TypeList)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	for i := 0; i < len(merchantCard); i++ {
		var reply models.MerchantCardListReply
		reply.RebateRate = merchantCard[i].RebateRate
		reply.ID = merchantCard[i].ID
		reply.QuotaNum = merchantCard[i].QuotaNum
		reply.MerchantCardName = merchantCard[i].MerchantCardName
		reply.CardPrice = merchantCard[i].CardPrice
		priceDec, err := decimal.NewFromString(merchantCard[i].CardPrice)
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}
		reply.RebateAmount = priceDec.Mul(decimal.NewFromInt(merchantCard[i].RebateRate).Div(decimal.NewFromInt(100))).String()
		outData = append(outData, reply)
	}
	app.PageOK(c, outData, count, pageIndex, pageSize, app.Success)

}

func UpdateMerchantCard(c *gin.Context) {
	var inData models.UpdateMerchantCardRequest
	var sqlData shanghu.MerchantCard

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	sqlData.ID = inData.ID
	sqlData.QuotaNum = inData.QuotaNum
	sqlData.UseRule = inData.UseRule
	sqlData.Picture = inData.Picture
	sqlData.Inventory = inData.Inventory
	sqlData.ActivityStartTime = inData.ActivityStartTime
	sqlData.ActivityEndTime = inData.ActivityEndTime
	err = sqlData.UpdateMerchantCard()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	app.OK(c, nil, app.Success)
}

func UpdateMerchantCardWXYZ(c *gin.Context) {
	var inData models.UpdateMerchantCardWHXYRequest
	var sqlData shanghu.MerchantCard
	var whxy []models.WHXYStr

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	//"json: cannot unmarshal number -0.33279827286174424 into Go struct field WHXYStr.rotate of type int"
	err = json.Unmarshal([]byte(inData.Whxy), &whxy)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	for i := 0; i < len(whxy); i++ {
		if !whxy[i].Y.IsZero() {
			sqlData.W = whxy[i].W.String()
			sqlData.X = whxy[i].X.String()
			sqlData.Y = whxy[i].Y.String()
			sqlData.H = whxy[i].H.String()
		}
	}
	sqlData.ID = inData.MerchantCardId

	err = sqlData.UpdateMerchantWHXY()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	app.OK(c, nil, app.Success)
}

// 核销次数
func CancelNumber(c *gin.Context) {
	var inData models.CancelCardRequest
	var sqlData shanghu.MerchantCard
	var log shanghu.CancelLog
	var qrMessage models.QRData
	var clientPay shanghu.ClientPayTrans

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	err = json.Unmarshal([]byte(inData.QRMessage), &qrMessage)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	clientPay.MerchantCardID = qrMessage.MerchantId
	clientPay.ClientOpenID = qrMessage.ClientOpenId
	clientInfo, err := clientPay.GetPayTransByOpenid()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	if clientInfo.ID == 0 {
		app.Error(c, 200, errors.New("用户未购买此卡"), "用户未购买此卡")
		return
	}

	sqlData.ID = qrMessage.MerchantId
	merchantInfo, err := sqlData.GetMerchantCard()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	log.MerchantID = qrMessage.MerchantId
	log.ClientOpenID = qrMessage.ClientOpenId
	if log.GetNumber() >= merchantInfo.CancelNumber {
		app.Error(c, 200, errors.New("卡已使用完，请重新购买"), "卡已使用完，请重新购买")
		return
	}

	if merchantInfo.MerchantOpenID != inData.MerchantOpenId {
		app.Error(c, 200, errors.New("核销商家与发卡商家不一致"), "核销商家与发卡商家不一致")
		return
	}

	log.MerchantID = qrMessage.MerchantId
	log.ClientOpenID = qrMessage.ClientOpenId
	log.MerchantOpenID = inData.MerchantOpenId
	log.CreatedAt = time.Now()
	log.UpdatedAt = time.Now()

	_, err = log.Create()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	app.OK(c, nil, "核销成功")

}

// 核销 v2
func CancelNumberV2(c *gin.Context) {
	var inData models.CancelCardV2Request
	var sqlData shanghu.MerchantCard
	var log shanghu.CancelLog
	var cancelLog []shanghu.CancelLog
	var qrMessage models.QRData
	var clientPay shanghu.ClientPayTrans

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	if inData.Number <= 0 {
		app.Error(c, 400, errors.New("核销次数不能为0"), "核销次数不能为0")
		return
	}

	err = json.Unmarshal([]byte(inData.QRMessage), &qrMessage)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	clientPay.MerchantCardID = qrMessage.MerchantId
	clientPay.ClientOpenID = qrMessage.ClientOpenId
	clientInfo, err := clientPay.GetPayTransByOpenid()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	if clientInfo.ID == 0 {
		app.Error(c, 500, errors.New("用户未购买此卡"), "用户未购买此卡")
		return
	}

	sqlData.ID = qrMessage.MerchantId
	merchantInfo, err := sqlData.GetMerchantCard()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	log.MerchantID = qrMessage.MerchantId
	log.ClientOpenID = qrMessage.ClientOpenId
	if log.GetNumber()+inData.Number > merchantInfo.CancelNumber {
		app.Error(c, 500, errors.New("剩余核销次数不够，请重新购买"), "剩余核销次数不够，请重新购买")
		return
	}

	//if merchantInfo.MerchantOpenID != inData.MerchantOpenId {
	//	app.Error(c, 500, errors.New("核销商家与发卡商家不一致"), "核销商家与发卡商家不一致")
	//	return
	//}

	for i := 0; i < inData.Number; i++ {
		log.MerchantID = qrMessage.MerchantId
		log.ClientOpenID = qrMessage.ClientOpenId
		log.MerchantOpenID = inData.MerchantOpenId
		log.CreatedAt = time.Now()
		log.UpdatedAt = time.Now()
		cancelLog = append(cancelLog, log)
	}

	err = log.CreateBatches(cancelLog)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	app.OK(c, nil, "核销成功")

}

// 充值核销
func RechargeCancel(c *gin.Context) {
	var inData models.RechargeCancelRequest

	ticker := shanghu.MerchantClientTicket{}

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	err = ticker.CancelAccountTicket(inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	app.OK(c, nil, "核销成功")

}