jyOrderManager/internal/logic/order/editBatchReturn.go

package order

import (
	"app.yhyue.com/moapp/jybase/common"
	"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/dayActivity"
	"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(CASE WHEN a.is_backstage_order = 1 THEN a.pay_money ELSE a.order_money END, 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("cbs").Ctx(ctx).GetOne(ctx, fmt.Sprintf(`SELECT return_id,BNKNAM,BNKFLW,id,ACTNBR,TRSBAL,BNKTIM,OTHNAM,NUSAGE FROM 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, allReturnOrder []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,
		}
		updateData := make(map[string]interface{})
		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:
			updateData["pay_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:
			updateData["pay_time"] = param.BNKTIM
			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["filter"] = string(filter_map)
		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
			// p718 全额回款赠送抽奖机会
			if common.IntAll(updateData["return_status"]) == 1 && common.IntAll(value["return_status"]) != 1 {
				allReturnOrder = append(allReturnOrder, orderCode)
			}
		} else {
			updateData["return_status"] = 2
		}
		if gconv.Int(value["order_status"]) == 0 {
			updateData["order_status"] = 1
		}
		updateData["last_update_person"] = jyutil.GetUserMsgFromCtx(ctx).EntUserName
		updateData["last_update_time"] = date.NowFormat(date.Date_Full_Layout)
		_, 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, _ := 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 !productDetail.IsEmpty() {
				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 gconv.Int(value["buy_subject"]) == 2 {
						uData["userId"] = userPositionId
					}
					if orderUserId := gconv.String(value["user_id"]); orderUserId == "" || orderUserId != gconv.String(uData["userId"]) || (gconv.Int(value["buy_subject"]) == 2 && gconv.Int64(value["ent_id"]) != entId) {
						log.Printf("同步更新订单用户身份:orderUserId:%s,userId:%v,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 _, err := g.DB().Update(ctx, "jy_order_detail", g.Map{
			"pay_status": 1,
		}, " order_code=?", id, orderCode); err != nil {
			log.Printf("%s 回款更新订单详情支付状态异常 %v", orderCode, err)
		}
	}
	log.Println("p718 ", allReturnOrder)
	for _, orderCode := range allReturnOrder {
		orderCodeRs, _ := g.DB().Query(ctx, `SELECT dor.user_id,dor.user_phone,jod.product_type,jod.service_type FROM dataexport_order dor
LEFT JOIN jy_order_detail jod on jod.order_code = dor.order_code
WHERE dor.order_code=?
`, orderCode)
		if !orderCodeRs.IsEmpty() {
			var (
				nsqOrderState                     int
				newProductType, userId, userPhone string
			)
			for _, m := range orderCodeRs.List() {
				productType := gconv.String(m["product_type"])
				if (productType == "大会员" || productType == "VIP订阅") && gconv.Int(m["service_type"]) > 0 && gconv.Int(m["service_type"]) < 4 {
					newProductType = productType
					userId = gconv.String(m["user_id"])
					userPhone = gconv.String(m["user_phone"])
					nsqOrderState = gconv.Int(m["service_type"])
					break
				}
			}
			if nsqOrderState > 0 {
				go dayActivity.ActivityNsqPublish(newProductType, userId, userPhone, orderCode, nsqOrderState-1)
			}
		}
	}
	if param.FlowType == 0 {
		//修改回款流水记
		updateTransactionData := map[string]interface{}{
			"return_id":  strings.Join(returnId, ","),
			"ISRELATION": 1,
		}
		_, err := g.DB("cbs").Ctx(ctx).Update(ctx, "transaction", updateTransactionData, map[string]interface{}{"id": transactionMap["id"]})
		if err != nil {
			return err

		}
	}
	return nil
}