fonchain-fiee/pkg/service/order/pay.go

package order

import (
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/chain"
	"github.com/fonchain_enterprise/fonchain-main/api/collections"
	"github.com/fonchain_enterprise/fonchain-main/api/order"
	frontSeries "github.com/fonchain_enterprise/fonchain-main/api/series"
	"github.com/fonchain_enterprise/fonchain-main/pkg/common/dingding"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"time"
)

// PayDetail 提交的报表列表
func PayDetail(c *gin.Context) {
	req := &order.PayDetailRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = "mall"

	res, err := service.OrderProvider.PayDetail(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

func SynPaySeriesData(c *gin.Context, seriesUID string) error {

	fmt.Println("1---", seriesUID)
	seriesInfo, err := getSeriesDetail(c, seriesUID)

	fmt.Println("2---", seriesInfo, err)
	if err != nil {
		return err
	}

	if seriesInfo == nil {
		return nil
	}

	seriesReq := &order.PaySeriesDataRequest{
		SeriesStatus:    uint64(seriesInfo.ShelfState),
		SeriesBrandName: seriesInfo.BrandName,
		LaunchStartTime: seriesInfo.LaunchStartTime,
		LaunchEndTime:   seriesInfo.LaunchEndTime,
		SeriesUid:       seriesUID,
	}

	if len(seriesInfo.SeriesLang) > 0 {
		lang := c.GetString("lang")
		if lang == "" {
			lang = "zh-CN"
		}
		if len(seriesInfo.SeriesLang) > 0 {
			for _, tt := range seriesInfo.SeriesLang {
				if tt.Language == lang {
					seriesReq.SeriesName = tt.SeriesName
				}
			}
		}
	}

	req := &order.PaySynSeriesDataRequest{
		IsInsert: false,
		Series:   seriesReq,
	}

	fmt.Println("3---", req)
	_, err = service.OrderProvider.PaySynSeriesData(c, req)
	fmt.Println("4---", err)

	if err != nil {
		return err
	}

	return nil
}

// SynPayCollectionData 更新统计
func SynPayCollectionData(c *gin.Context, artworkUid string) error {
	fmt.Println("1---", artworkUid)
	collectionInfo, err := getCollectionsInfoByID(c, artworkUid)
	if err != nil {
		return err
	}

	fmt.Println("2---", collectionInfo)

	//同步数量
	collectionReq := &order.PayCollectionDataRequest{
		Name:        collectionInfo.Name,
		Img:         collectionInfo.CollectionImg,
		Level:       collectionInfo.Level,
		Total:       uint64(collectionInfo.Num),                //总量
		Price:       fmt.Sprintf("%.2f", collectionInfo.Price), //单价
		StockAmount: uint64(collectionInfo.Num),                //库存
		Uid:         artworkUid,
	}

	req := &order.PaySynSeriesDataRequest{
		Collection: collectionReq,
		IsInsert:   false,
	}

	fmt.Println("3---", req)
	_, err = service.OrderProvider.PaySynSeriesData(c, req)
	if err != nil {
		return err
	}

	return nil

}

func getCollectionsInfoByID(c *gin.Context, CollectionsUID string) (*collections.CollectionsInfo, error) {
	req := collections.CollectionsListReq{
		CollectionsUID: CollectionsUID,
		Language:       c.GetString("lang"),
	}

	fmt.Println("2---")

	resp, err := service.GrpcCollectionImpl.CollectionsList(c, &req)

	fmt.Println("2---", err)
	fmt.Println("2---", resp)

	if err != nil {
		service.ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return nil, err
	}

	if len(resp.Data) > 0 {
		data := resp.Data[0]
		return data, nil
	}

	return nil, errors.New("no found")
}

func getSeriesDetail(c *gin.Context, seriesUid string) (*frontSeries.SeriesDetailResp, error) {
	req := frontSeries.SeriesDetailReq{
		SeriesUuid: seriesUid,
	}

	resp, err := service.GrpcBackendSeriesImpl.SeriesDetail(c, &req)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

func OfflinePayList(c *gin.Context) {
	req := &order.PayListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = "mall"
	req.Status = []uint64{e.Pay_Express_Agree, e.Pay_Express, e.Pay_Success}
	req.PayType = 7

	res, err := service.OrderProvider.PayList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	for i, t := range res.Data {
		timeTemp, err := time.Parse("2006-01-02 15:04:05", t.CreatedAt)
		if err == nil {
			res.Data[i].CreatedAt = timeTemp.Format("2006-01-02")
		}
	}

	service.Success(c, res)
	return
}

func AddTrackingNumber(c *gin.Context) {
	req := &order.AddTrackingNumberRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.OrderProvider.AddTrackingNumber(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// PayList 申请快递
func PayList(c *gin.Context) {
	req := &order.PayListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = "mall"
	req.Status = []uint64{e.Pay_Express_Agree, e.Pay_Express}

	res, err := service.OrderProvider.PayList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// Refund 申请退款，退款成功销毁nft，同时
func Refund(c *gin.Context) {
	req := &order.PayDetailRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = e.Domain_Mall

	//0-退钱
	res, err := service.OrderProvider.PayRefund(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//1-获取隐私数据
	privateReq := &account.PrivacyInfoRequest{
		Domain: e.Domain_Mall,
		ID:     res.BuyerId,
	}

	privateInfo, err := service.AccountProvider.PrivacyInfo(c, privateReq)
	fmt.Println("1--", privateInfo, err)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//2-销毁nft
	burnReq := &chain.BurnNFTRequest{
		Mnemonic: privateInfo.MnemonicWords,
		Address:  privateInfo.Account,
		Hash:     res.Hash,
	}

	_, err = service.ChainProvider.BurnNFT(c, burnReq)

	if err != nil {
		dingding.Send("退款（藏品）销毁藏品失败,info"+res.String(), err)
		service.Error(c, e.Error, err)
		return
	}

	//3-藏品数量+1
	subReq := &collections.SubCollectionsNumReq{
		CollectionUID: res.ArtworkUid,
		AddNum:        1,
		SubNum:        0,
	}

	_, err = service.GrpcCollectionImpl.SubCollectionsNum(c, subReq)

	if err != nil {
		dingding.Send("退款（藏品）数量回滚,info"+res.String(), err)
		fmt.Println("退款（藏品）数量回滚,info", err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// PayHasExpress 申请快递的状态
func PayHasExpress(c *gin.Context) {
	req := &order.PayListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = "mall"
	req.Status = []uint64{e.Pay_Express}

	res, err := service.OrderProvider.PayList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	newRes := make(map[string]uint64)

	newRes["Num"] = res.Count

	service.Success(c, newRes)
	return
}

// PayAgreeExpress 修改订单状态
func PayAgreeExpress(c *gin.Context) {
	req := &order.PaySetExpressRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.OrderProvider.PaySetExpressRemark(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// SeriesList 系列列表
func SeriesList(c *gin.Context) {
	req := &order.PaySeriesDataListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	req.Domain = "mall"

	res, err := service.OrderProvider.PaySeriesDataList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// CollectionsList 藏品列表
func CollectionsList(c *gin.Context) {
	req := &order.PayCollectionsDataListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Domain = "mall"

	res, err := service.OrderProvider.PayCollectionsDataList(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}