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/consts"
	"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)+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection c where c.orderCode=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 return_id,BNKNAM,BNKFLW,id,ACTNBR,TRSBAL,BNKTIM,OTHNAM,NUSAGE FROM cadmin.transaction WHERE id = %d`, param.TransactionId))
		transactionData, _ := g.DB().Ctx(ctx).GetOne(ctx, fmt.Sprintf(`SELECT return_id,BNKNAM,BNKFLW,id,ACTNBR,TRSBAL,BNKTIM,OTHNAM,NUSAGE FROM cadmin.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

	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, err3 := g.DB().Ctx(ctx).Insert(ctx, "return_money_record", insertData)
		if err3 != nil {
			return err3
		}
		id, _ := res.LastInsertId()
		returnId = append(returnId, fmt.Sprint(id))
		//修改成功，判断是否全额回款并且创建订单勾选回款开通权益
		if gconv.Int(value["return_status"]) != 1 && consts.PhoneRegex.MatchString(gconv.String(value["user_phone"])) && 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 and is_service_open = 0 and status =1`, orderCode))
			if err != nil || productDetail.IsEmpty() {
				return err
			}
			uData, entId, userPositionId, err := jyutil.GetCreateUserData(gconv.String(value["user_phone"]), gconv.String(value["company_name"]), gconv.Int(value["buy_subject"]) == 2)
			if err != nil {
				return errors.New("用户企业信息初始花失败")
			}
			if err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
				// 产品服务开通
				for _, m := range productDetail.List() {
					if !jyutil.IsServiceOpen(m) {
						continue
					}
					//参数注入
					m["userMap"] = map[string]interface{}{
						"userData": uData, "entId": entId, "userPositionId": userPositionId,
					}
					m["phone"] = value["user_phone"]
					m["order_code"] = orderCode
					m["reqCompanyName"] = value["company_name"]
					m["amount"] = m["final_price"]
					m["reqSubject"] = value["buy_subject"]
					m["linked_orderId"] = m["linked_detail_id"]
					productCode := gconv.String(m["product_code"])
					pFunc, err4 := product.JyProFunc.GetProductInitFuncByCode(productCode)
					if err4 != nil {
						return err4
					}
					pObj, err5 := pFunc(m)
					if err5 != nil {
						return gerror.Wrap(err5, fmt.Sprintf("获取%s商品异常", productCode))
					}
					if err = pObj.OpenService(ctx, time.Now()); err != nil {
						return err
					}
				}
				if orderUserId := gconv.String(value["user_id"]); orderUserId == "" || orderUserId != gconv.String(uData["userId"]) {
					log.Printf("同步更新订单用户身份:orderUserId:%s,userId:%s,entId:%d\n", orderUserId, uData["userId"], entId)
					upData := g.Map{
						"user_id": uData["userId"],
					}
					if entId > 0 { //企业服务
						upData["ent_id"] = entId
						if personPhone := gconv.String(value["personPhone"]); personPhone != "" {
							jyutil.EndAddUser(ctx, entId, gconv.String(value["user_phone"]), personPhone, gconv.String(value["personName"]))
						}
					}
					//更新订单
					_, err = g.DB().Update(ctx, consts.OrderListTableName, upData, "order_code=?", orderCode)
				}
				return nil
			}); err != nil {
				log.Println(err)
				return err
			}
		}

		//首次回款销售业绩生效
		log.Printf("%s 回款销售业绩是否生效 %v", orderCode, isFirstReturn)
		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, "cadmin.transaction", updateTransactionData, map[string]interface{}{"id": transactionMap["id"]})
		if err != nil {
			return err

		}
	}
	return nil
}