jyOrderManager/internal/logic/order/editBatchReturn.go

package order

import (
	"app.yhyue.com/moapp/jybase/date"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/product"
	"jyOrderManager/internal/model"
	"log"
	"math"
	"strings"
	"time"
)

var (
	AliProceduresMoney       float64
	CorporateProceduresMoney float64
	WxProceduresMoney        float64
)

func init() {
	WxProceduresMoney = g.Cfg().MustGet(context.Background(), "wxProceduresMoney").Float64()
	AliProceduresMoney = g.Cfg().MustGet(context.Background(), "aliProceduresMoney").Float64()
	CorporateProceduresMoney = g.Cfg().MustGet(context.Background(), "corporateProceduresMoney").Float64()
}

// EditBatchReturn 回款
func EditBatchReturn(ctx context.Context, param model.OrdersEditBatchReturn) error {
	if param.OrderArr == nil {
		return errors.New("缺少关键参数")
	}

	orderArr := make(map[string]map[string]interface{})
	var (
		price, realPrice int //cbs回款
	)

	for _, value := range param.OrderArr {
		orderData, _ := g.DB().Ctx(ctx).GetOne(ctx, "select  (IFNULL( a.pay_money, 0 )-IFNULL(a.commission,0)-IFNULL(a.procedures_money,0))-(select  IFNULL(sum(b.return_money),0) from  return_money_record  b where b.order_code=a.order_code and  b.state=1) + (select  IFNULL(sum(c.refund_money),0) from refund_record c where c.order_code=a.order_code) as outstandingPayment, a.*  from  dataexport_order a where  a.id=?", value["orderId"])
		if orderData.IsEmpty() {
			continue
		}
		orderDataMap := orderData.Map()
		if gconv.Int(value["money"]) > gconv.Int(orderDataMap["outstandingPayment"]) {
			return errors.New(gconv.String(orderDataMap["order_code"]) + "回款金额过大")
		}
		orderDataMap["realPrice"] = gconv.Int(value["money"]) //回款
		orderDataMap["returnVoucherUrl"] = param.ReturnVoucherUrl
		realPrice += gconv.Int(value["money"])
		orderArr[gconv.String(orderDataMap["order_code"])] = orderDataMap
		price += gconv.Int(orderDataMap["outstandingPayment"]) //剩余回款
	}
	transactionMap := make(map[string]interface{})
	var (
		money int
	)
	switch param.FlowType == 0 {
	case true: //流水回款
		//查询回款流水记录
		transactionData, _ := g.DB().Ctx(ctx).GetOne(ctx, fmt.Sprintf(`SELECT returnId,BNKNAM,BNKFLW,id,ACTNBR,TRSBAL,BNKTIM,OTHNAM,NUSAGE FROM cbs.transaction WHERE id = %d`, param.TransactionId))
		if transactionData.IsEmpty() {
			return errors.New("未找到该流水")
		}
		if price == 0 {
			return errors.New("订单回款失败，回款金额不符合")
		}
		money = int(math.Floor(gconv.Float64(transactionData.Map()["TRSBAL"]))*100 + 0.5) //流水
		log.Println("回款金额", money, price, realPrice)
		if realPrice > price || money != realPrice {
			return errors.New("订单回款失败，回款金额不符合")
		}
		transactionMap = transactionData.Map()
	case false: //手动回款
		if param.ReturnMoney != realPrice {
			return errors.New("订单回款失败，回款金额不符合")
		}
	}
	var returnId []string
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		for key, value := range orderArr {
			var (
				orderCode   = gconv.String(value["order_code"])
				returnMoney = gconv.Int(value["realPrice"])
			)
			//回款关闭相应的支付码支付
			//go CancelOnlinePay(orderCode)
			isFirst, _ := g.DB().Ctx(ctx).GetCount(ctx, fmt.Sprintf(`SELECT * FROM return_money_record WHERE state = 1 and order_code ='%s'`, orderCode))
			isFirstReturn := isFirst == 0
			insertData := map[string]interface{}{
				"order_code":            key,
				"return_money":          returnMoney,
				"return_invoice_status": 0,
				"return_voucher_url":    value["returnVoucherUrl"],
				"operate_person":        jyutil.GetUserMsgFromCtx(ctx).EntUserName,
				"operate_time":          date.NowFormat(date.Date_Full_Layout),
				"flow_type":             param.FlowType,
				"pay_account_name":      param.PayAccountName,
				"state":                 1,
			}
			switch param.ReturnType {
			case 1:
				insertData["procedures_money"] = math.Round(float64(param.ReturnMoney) * WxProceduresMoney / 100)
			case 2:
				if param.FlowType == 0 { //流水折扣
					insertData["procedures_money"] = math.Round(float64(param.ReturnMoney) * AliProceduresMoney / 100)
				}
			case 3:
				insertData["procedures_money"] = math.Round(float64(param.ReturnMoney) * CorporateProceduresMoney / 100)
			}
			switch param.FlowType == 0 {
			case true:
				insertData["return_time"] = transactionMap["BNKTIM"]
				insertData["return_time"] = transactionMap["BNKTIM"]
				insertData["return_money"] = returnMoney
				insertData["return_type"] = 3
				insertData["return_remark"] = transactionMap["NUSAGE"]
				insertData["return_code"] = ""
				insertData["flow_money"] = money
				insertData["bank_flow"] = transactionMap["BNKFLW"]
				insertData["bank_name"] = transactionMap["BNKNAM"]
			case false:
				insertData["return_time"] = param.BNKTIM
				insertData["return_money"] = returnMoney
				insertData["return_type"] = param.ReturnType
				insertData["return_remark"] = param.ReturnRemarks
				insertData["return_code"] = param.ReturnCode
				insertData["bank_flow"] = param.BNKFLW
				insertData["flow_money"] = param.ReturnMoney
				insertData["bank_name"] = param.BNKNAM
			}
			filterMap := gconv.Map(value["filter"])
			if filterMap == nil {
				filterMap = make(map[string]interface{})
			}
			filterMap["isAll"] = 1
			filter_map, _ := json.Marshal(filterMap)
			updateData := map[string]interface{}{
				"filter":   string(filter_map),
				"pay_time": time.Now().Format("2006-01-02 15:04:05"),
			}
			returnData, _ := g.DB().Ctx(ctx).GetOne(ctx, `select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code=? and state=1`, key)
			refundData, _ := g.DB().Ctx(ctx).GetOne(ctx, `select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code=?`, key)
			return_moneys := gconv.Int(returnData.Map()["return_money"])
			refund_money := gconv.Int(refundData.Map()["refund_money"])
			if returnMoney+return_moneys == refund_money {
				updateData["refund_status"] = 1
			} else if returnMoney+return_moneys > refund_money && refund_money > 0 {
				updateData["refund_status"] = 2
			}
			if returnMoney == gconv.Int(value["outstandingPayment"]) {
				updateData["return_status"] = 1
			} else {
				updateData["return_status"] = 2
			}
			if gconv.Int(value["order_status"]) == 0 {
				updateData["order_status"] = 1
			}
			_, err1 := g.DB().Ctx(ctx).Update(ctx, "dataexport_order", updateData, map[string]interface{}{"id": value["id"]})
			if err1 != nil {
				return err1
			}
			res, err2 := g.DB().Ctx(ctx).Insert(ctx, "return_money_record", insertData)
			if err2 != nil {
				return err2
			}

			//修改成功，判断是否全额回款并且创建订单勾选回款开通权益
			if gconv.Int(value["return_status"]) != 1 && gconv.Int(updateData["return_status"]) == 1 {
				productDetail, err := g.DB().Ctx(ctx).Query(ctx, fmt.Sprintf(`SELECT * FROM jy_order_detail WHERE order_code ='%s' and returned_open =1`, orderCode))
				if err != nil || productDetail.IsEmpty() {
					return err
				}
				// 产品服务开通
				for _, m := range productDetail.List() {
					if !jyutil.IsServiceOpen(m) {
						continue
					}
					//参数注入
					m["phone"] = value["user_phone"]
					m["order_code"] = orderCode
					m["reqCompanyName"] = value["company_name"]
					m["amount"] = m["final_price"]
					m["reqSubject"] = value["buy_subject"]
					productCode := gconv.String(m["product_code"])
					pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
					if err != nil {
						return err
					}
					pObj, err := pFunc(m)
					if err != nil {
						return gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
					}
					if err := pObj.OpenService(ctx, time.Now()); err != nil {
						return err
					}
				}
			}
			id, _ := res.LastInsertId()
			returnId = append(returnId, fmt.Sprint(id))
			//首次回款销售业绩生效
			if isFirstReturn {
				if err := CommonChange(ctx, orderCode, param.BNKTIM, ReturnMoney); err != nil {
					log.Printf("%s 回款销售业绩生效异常 %v", orderCode, err)
				}
			}
		}
		if param.FlowType == 0 {
			//修改回款流水记
			updateTransactionData := map[string]interface{}{
				"return_id":  strings.Join(returnId, ","),
				"ISRELATION": 1,
			}
			_, err := g.DB().Ctx(ctx).Update(ctx, "transaction", updateTransactionData, map[string]interface{}{"id": transactionMap["id"]})
			if err != nil {
				return err

			}
		}
		return nil
	})
}