duoduo/apis/shanghu/client.trans.go

package shanghu

import (
	"duoduo/apis/shanghu/models"
	"duoduo/models/shanghu"
	"duoduo/tools"
	"duoduo/tools/app"
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/goccy/go-json"
	"github.com/shopspring/decimal"
	"github.com/skip2/go-qrcode"
	"strconv"
	"time"
)

func GetPayTransList(c *gin.Context) {
	var inData models.ClientTransRequest
	var outTransData []models.ClientTransReply
	var sqlData shanghu.ClientPayTrans

	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
	}
	fmt.Println(inData.OpenId)
	sqlData.ClientOpenID = inData.OpenId

	merchantCard, count, err := sqlData.GetPayTransSuccessByOpenID(pageSize, pageIndex)

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

	for i := 0; i < len(merchantCard); i++ {
		var transData models.ClientTransReply
		var cardSql shanghu.MerchantCard
		var cancelNum shanghu.CancelLog
		cardSql.ID = merchantCard[i].MerchantCardID
		cardInfo, err := cardSql.GetMerchantCard()
		if err != nil {
			app.Error(c, 500, err, err.Error())
			return
		}

		cancelNum.ClientOpenID = inData.OpenId
		cancelNum.MerchantID = cardInfo.ID

		transData.TransId = merchantCard[i].ID
		transData.Amount = merchantCard[i].Amount
		transData.PayTime = merchantCard[i].PayTime.Format(time.DateTime)
		transData.MerchantCardID = merchantCard[i].MerchantCardID
		transData.MerchantCardName = cardInfo.MerchantCardName
		transData.MerchantCardTime = tools.TimeToStr(cardInfo.MerchantCardTime)
		transData.TotalCancelNumber = cardInfo.CancelNumber
		transData.CancelNumber = cardInfo.CancelNumber - cancelNum.GetNumber()
		transData.CommAmount = merchantCard[i].Amount.Mul(decimal.NewFromInt(cardInfo.RebateRate)).Div(decimal.NewFromInt(100)).Round(2)

		outTransData = append(outTransData, transData)
	}
	app.PageOK(c, outTransData, count, pageIndex, pageSize, app.Success)
}

func GetVerificationCode(c *gin.Context) {
	var inData models.VerificationCodeRequest
	var sqlData shanghu.ClientPayTrans
	var qrData models.QRData
	//var outData models.VerificationCodeReply
	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	if inData.TransId <= 0 {
		app.Error(c, 400, errors.New("核销id错误"), "核销id错误")
		return
	}

	sqlData.ID = inData.TransId
	transInfo, err := sqlData.GetPayTransById()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	key := tools.MD5(strconv.FormatInt(transInfo.MerchantCardID, 10) + "zhangkun429@")

	qrData.MerchantId = transInfo.MerchantCardID
	qrData.Key = key
	qrData.ClientOpenId = transInfo.ClientOpenID
	str, err := json.Marshal(&qrData)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}

	qr, err := qrcode.Encode(string(str), qrcode.High, 200)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	encodedData := base64.StdEncoding.EncodeToString(qr)
	//outData.QR = ``

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

// 充值核销码
func GetRechargeVerificationCode(c *gin.Context) {
	var inData models.RechargeVerificationCodeRequest
	var outData models.RechargeVerificationCodeReply

	err := c.ShouldBindJSON(&inData)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	if inData.MerchantOpenId == "" || inData.ClientOpenId == "" {
		app.Error(c, 400, errors.New("参数错误"), "参数错误")
		return
	}

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

	key = "CHARGE" + key
	outData.Key = key
	outData.ClientOpenId = inData.ClientOpenId
	outData.MerchantOpenId = inData.MerchantOpenId

	str, err := json.Marshal(&outData)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	qr, err := qrcode.Encode(string(str), qrcode.High, 200)
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	encodedData := base64.StdEncoding.EncodeToString(qr)

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

func GetMerchantPayTransList(c *gin.Context) {
	var inData models.MerchantTransRequest
	var sqlMerchant shanghu.MerchantCard
	var sqlPay shanghu.ClientPayTrans
	var outData []models.MerchantTransReply
	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
	}

	sqlMerchant.MerchantOpenID = inData.MerchantOpenId
	merchantData, err := sqlMerchant.GetMerchantByOpenId()
	if err != nil {
		app.Error(c, 500, err, err.Error())
		return
	}
	mer := make(map[int64]shanghu.MerchantCard, 0)
	var merIdList []int64
	for i := 0; i < len(merchantData); i++ {
		merIdList = append(merIdList, merchantData[i].ID)
		fmt.Println(merchantData[i])
		mer[merchantData[i].ID] = merchantData[i]
	}

	payInfo, count, err := sqlPay.GetPayTransSuccessByMerchantID(pageSize, pageIndex, merIdList)
	for i := 0; i < len(payInfo); i++ {
		data := models.MerchantTransReply{}
		data.TransId = payInfo[i].ID
		data.MerchantCardTime = tools.TimeToStr(mer[payInfo[i].MerchantCardID].MerchantCardTime)
		data.MerchantCardName = mer[payInfo[i].MerchantCardID].MerchantCardName
		data.TotalAmount = payInfo[i].Amount
		if payInfo[i].InvitationCode == app.LIANMENGKA_YUAN_SHI_MA {
			data.SaleAmount = decimal.NewFromInt(0)
		} else {
			data.SaleAmount = payInfo[i].Amount.Mul(decimal.NewFromInt(mer[payInfo[i].MerchantCardID].RebateRate)).Div(decimal.NewFromInt(100)).Round(2)
		}
		data.MerchantAmount = data.TotalAmount.Sub(data.SaleAmount)
		data.MerchantCardID = payInfo[i].MerchantCardID
		data.PayTime = payInfo[i].PayTime.Format(time.DateTime)
		if payInfo[i].InvitationCode == app.LIANMENGKA_YUAN_SHI_MA {
			data.SaleId = "原始码"
		} else {
			data.SaleId = payInfo[i].InvitationCode
		}

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

}

func GetClientPayTransList(c *gin.Context) {
	var inData models.ClientTransListRequest
	var sqlClientUser shanghu.MerchantClientUser
	var sqlPay shanghu.ClientPayTrans
	var outData []models.ClientTransListReply
	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
	}

	sqlClientUser.ClientOpenID = inData.ClientOpenId
	clientUserInfo, err := sqlClientUser.GetUserInfo()
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}
	sqlPay.InvitationCode = clientUserInfo.Code
	codeTransInfo, count, err := sqlPay.GetPaySuccessTransByInvitationCode(pageSize, pageIndex)
	if err != nil {
		app.Error(c, 400, err, err.Error())
		return
	}

	for i := 0; i < len(codeTransInfo); i++ {
		data := models.ClientTransListReply{}
		var cardSql shanghu.MerchantCard
		var clientInfoSql shanghu.MerchantClientUser
		data.TransId = codeTransInfo[i].ID
		data.PayTime = codeTransInfo[i].PayTime.Format(time.DateTime)
		data.MerchantCardID = codeTransInfo[i].MerchantCardID
		cardSql.ID = codeTransInfo[i].MerchantCardID
		cardInfo, _ := cardSql.GetMerchantCard()
		data.MerchantCardName = cardInfo.MerchantCardName
		clientInfoSql.ClientOpenID = codeTransInfo[i].ClientOpenID
		userInfo, _ := clientInfoSql.GetUserInfo()
		data.UserId = userInfo.Code
		data.SaleAmount = codeTransInfo[i].Amount.Mul(decimal.NewFromInt(cardInfo.RebateRate)).Div(decimal.NewFromInt(100)).Round(2)
		outData = append(outData, data)
	}

	app.PageOK(c, outData, count, pageIndex, pageSize, app.Success)
}