wangshan 2 zile în urmă
părinte
comite
ee5e400516
2 a modificat fișierele cu 233 adăugiri și 57 ștergeri
  1. 229 56
      internal/logic/order/deposit.go
  2. 4 1
      internal/model/deposit.go

+ 229 - 56
internal/logic/order/deposit.go

@@ -8,9 +8,13 @@ import (
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/pkg/errors"
+	"jyOrderManager/internal/consts"
 	"jyOrderManager/internal/jyutil"
+	"jyOrderManager/internal/logic/product"
 	"jyOrderManager/internal/model"
 	"log"
+	"math"
 	"time"
 )
 
@@ -23,7 +27,6 @@ func SaveDepositInfo(ctx context.Context, orderCode, userName, dPaymentAccount s
 		"payment_account": dPaymentAccount,
 		"operate_time":    timeStr,
 		"operate_person":  userName,
-		"flow_money":      money,
 		"create_time":     timeStr,
 	}); err != nil {
 		return gerror.Wrap(err, "保证金保存异常")
@@ -33,32 +36,37 @@ func SaveDepositInfo(ctx context.Context, orderCode, userName, dPaymentAccount s
 
 // todo 保证金编辑(可以新增
 func EditDeposit(ctx context.Context, sDeposit model.SDeposit) error {
-	result, err := g.DB().Query(ctx, `SELECT  * FROM  jianyu.order_deposit_operate odo WHERE odo.order_code  = ? ORDER BY  odo.operate_time  DESC`, sDeposit.OrderCode)
+	result, err := g.DB().Query(ctx, fmt.Sprintf(`SELECT  * FROM  %s odo WHERE odo.order_code  = ? ORDER BY  odo.operate_time  DESC`, model.DepositTable), sDeposit.OrderCode)
 	if err != nil {
-		if result.IsEmpty() {
-			if sDeposit.DepositAmount > 0 {
-				//存储
-				err = SaveDepositInfo(ctx, sDeposit.OrderCode, jyutil.GetUserMsgFromCtx(ctx).EntUserName, sDeposit.DepositPaymentAccount, sDeposit.DepositAmount)
-			} else {
-				err = fmt.Errorf("保证金参数异常")
-			}
+		return errors.Wrap(err, "查询保证金信息异常")
+	}
+	if result.IsEmpty() {
+		if sDeposit.DepositAmount > 0 {
+			//存储
+			err = SaveDepositInfo(ctx, sDeposit.OrderCode, jyutil.GetUserMsgFromCtx(ctx).EntUserName, sDeposit.DepositPaymentAccount, sDeposit.DepositAmount)
 		} else {
-			//更新
-			_, err = g.DB().Update(ctx, model.DepositTable, g.Map{
-				"order_code": sDeposit.OrderCode,
-			}, g.Map{
-				"money":           sDeposit.DepositAmount,
-				"payment_account": sDeposit.DepositPaymentAccount,
-				"operate_time":    time.Now().Format(time.DateTime),
-				"operate_person":  jyutil.GetUserMsgFromCtx(ctx).EntUserName,
-				"state":           0,
-			})
+			err = fmt.Errorf("保证金参数异常")
 		}
+	} else {
+		//更新 todo 有保证金支付信息不鞥编辑更新
+		var dpCount int
+		dpCount, err = g.DB().GetCount(ctx, fmt.Sprintf(`SELECT  count(*) FROM  %s od WHERE  od.order_code  = ? AND  od.pay_money > 0 AND od.is_del = 0  ORDER BY  od.operate_time DESC ;`, model.DepositPaymentTable), sDeposit.OrderCode)
+		if dpCount > 0 || err != nil {
+			return errors.Wrap(err, "保证金编辑失败")
+		}
+		_, err = g.DB().Update(ctx, model.DepositTable, g.Map{
+			"order_code": sDeposit.OrderCode,
+		}, g.Map{
+			"money":           sDeposit.DepositAmount,
+			"payment_account": sDeposit.DepositPaymentAccount,
+			"operate_time":    time.Now().Format(time.DateTime),
+			"operate_person":  jyutil.GetUserMsgFromCtx(ctx).EntUserName,
+		})
 	}
 	return err
 }
 
-// todo  保证金-支付(批量|单条)
+// todo  保证金-支付信息(批量|单条)
 func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayment) error {
 	var payWay string
 	switch sDepositPayment.PayWay {
@@ -68,50 +76,164 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 		payWay = "支付宝"
 	case 3:
 		payWay = "对公转账"
+	case 4:
+		payWay = "第三方平台"
 	}
 	if payWay == "" {
 		return fmt.Errorf("pay_way 参数异常")
 	}
+	var (
+		price, realPrice int64
+		orderArr         = make(map[string]map[string]interface{})
+	)
 	for _, dl := range sDepositPayment.DepositList {
 		if dl.OrderCode == "" || dl.Money == 0 {
 			continue
 		}
-		_, err := g.DB().Update(ctx, model.DepositTable, g.Map{
-			"order_code": dl.OrderCode,
-		}, g.Map{
-			"pay_time":         sDepositPayment.PayTime,
-			"pay_money":        YuanToFen(dl.Money),
-			"pay_way":          payWay,
-			"remark":           sDepositPayment.Remark,
-			"state":            1,
-			"operate_time":     time.Now().Format(time.DateTime),
-			"operate_person":   jyutil.GetUserMsgFromCtx(ctx).EntUserName,
-			"pay_account_name": sDepositPayment.PayAccountName,
-			"flow_money":       YuanToFen(sDepositPayment.FlowMoney),
-			"bank_name":        sDepositPayment.BankName,
-			"bank_flow":        sDepositPayment.BankFlow,
-			"pay_voucher":      sDepositPayment.PayVoucher,
-		})
-		if err != nil {
-			g.Log().Errorf(ctx, "保证金支付信息更新异常 %s", err.Error())
+		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.order_code=?", dl.OrderCode)
+		if orderData.IsEmpty() {
+			g.Log().Infof(ctx, "未查到%s当前订单回款信息", dl.OrderCode)
+			continue
+		}
+		orderDataMap := orderData.Map()
+		if dl.Money > gconv.Int64(orderDataMap["outstandingPayment"]) { //合同金额
+			g.Log().Infof(ctx, errors.New(dl.OrderCode+"保证金金额过大").Error())
+			return errors.New(dl.OrderCode + "保证金金额过大")
+		}
+		orderDataMap["realPrice"] = dl.Money //保证金
+		orderDataMap["returnVoucherUrl"] = sDepositPayment.PayVoucher
+		realPrice += dl.Money
+		orderArr[dl.OrderCode] = orderDataMap
+		price += gconv.Int64(orderDataMap["outstandingPayment"]) //剩余回款?
+	}
+	//cbs回款流水
+	//查询回款流水记录
+	if sDepositPayment.FlowType == 0 {
+		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`, sDepositPayment.TransactionId))
+		if transactionData.IsEmpty() {
+			return errors.New("未找到该流水")
+		}
+		money := int64(math.Floor(gconv.Float64(transactionData.Map()["TRSBAL"]))*100 + 0.5) //流水
+		log.Println("CBS流水金额:", money, "回款总金额:", price, "保证金总金额:", realPrice)
+		if money != realPrice {
+			return errors.New("新增保证金失败,保证金金额不符合")
+		}
+	} else {
+		if sDepositPayment.FlowMoney != realPrice {
+			return errors.New("新增保证金失败,保证金金额不符合")
 		}
-		//todo 1、是否需要关闭对应保证金的支付订单;2、保证金支付金额=订单金额 需要开通权限
+	}
+	for key, value := range orderArr {
+		var (
+			payMoney = gconv.Int64(value["realPrice"])
+		)
+		err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+			_, err := g.DB().Insert(ctx, model.DepositPaymentTable, g.Map{ //保证金支付信息
+				"order_code":       key,
+				"pay_time":         sDepositPayment.PayTime,
+				"pay_money":        YuanToFen(payMoney),
+				"pay_way":          payWay,
+				"remark":           sDepositPayment.Remark,
+				"state":            1,
+				"operate_time":     time.Now().Format(time.DateTime),
+				"operate_person":   jyutil.GetUserMsgFromCtx(ctx).EntUserName,
+				"flow_money":       YuanToFen(sDepositPayment.FlowMoney),
+				"bank_name":        sDepositPayment.BankName,
+				"bank_flow":        sDepositPayment.BankFlow,
+				"pay_voucher":      sDepositPayment.PayVoucher,
+				"pay_account_name": sDepositPayment.PayAccountName,
+				"create_time":      time.Now().Format(time.DateTime),
+			})
+			if err != nil {
+				g.Log().Errorf(ctx, "新增保证金支付信息异常 %s", err.Error())
+				return errors.Wrap(err, "新增保证金支付信息异常")
+			} else if realPrice == price { //保证金总金额 等于剩余需要回款的总金额
+				//todo 1、是否需要关闭对应保证金的支付订单;2、保证金支付金额=合同金额 需要开通权限
+				//是否需要开通权限 当前订单 保证金金额 == 剩余回款金额
+				if payMoney == gconv.Int64(value["outstandingPayment"]) {
+					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`, key)) //是否选中自动开通权限
+					if !productDetail.IsEmpty() {
+						var (
+							uData                 map[string]interface{}
+							entId, userPositionId int64
+						)
+						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"] = key
+								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=?", key)
+							}
+							return err
+						}); err != nil {
+							log.Println(err)
+							return err
+						}
+					}
+				}
+			}
+			return err
+		})
+		return err
 	}
 	return nil
 }
 
 // todo 保证金支付款-退还/转回款
 func DepositRefundOrRetMoney(ctx context.Context, sDeposit model.SDeposit) error {
-	//保证金信息
-	deposits, err := g.DB().GetOne(ctx, `SELECT  * FROM  jianyu.order_deposit od WHERE  od.order_code  = ? AND  od.pay_money > 0 AND od.state = 1;`, sDeposit.OrderCode)
+	//保证金信息  未删除
+	deposits, err := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT  * FROM  %s od WHERE  od.order_code  = ? AND  od.pay_money > 0 AND od.is_del = 0  ORDER BY  od.operate_time DESC ;`, model.DepositPaymentTable), sDeposit.OrderCode)
 	if err != nil {
 		return err
 	}
 	if deposits.IsEmpty() {
-		return fmt.Errorf("未查到当前订单的保证金信息")
+		return fmt.Errorf("未查到当前订单 有效的保证金信息")
 	}
 	payMoney := FenToYuanInt64(gconv.Int64(deposits.Map()["pay_money"]))
-	if payMoney != sDeposit.RefundMoney+sDeposit.RefundMoney {
+	if payMoney != sDeposit.RefundMoney+sDeposit.ReturnedMoney {
 		return fmt.Errorf("保证金金额异常")
 	}
 	_, err = g.DB().Insert(ctx, model.DepositOperateTable, g.Map{
@@ -123,19 +245,66 @@ func DepositRefundOrRetMoney(ctx context.Context, sDeposit model.SDeposit) error
 		"operate_person": jyutil.GetUserMsgFromCtx(ctx).EntUserName,
 	})
 	//todo 如果回款金额》0,增加回款记录;如果回款金额== 剩余支付金额 需要开通权益
-
+	if sDeposit.ReturnedMoney > 0 {
+		//获取订单信息
+		var (
+			record gdb.Record
+		)
+		record, err = g.DB().GetOne(ctx, `SELECT  * FROM  jianyu.dataexport_order do WHERE do.order_code = ?`, sDeposit.OrderCode)
+		if err != nil || record.IsEmpty() {
+			g.Log().Infof(ctx, "未查到 %s 订单信息", sDeposit.OrderCode)
+			return err
+		}
+		var (
+			orderId        = record.Map()["id"]                               //订单id
+			payWay         = deposits.Map()["pay_way"]                        //支付方式
+			bankFlow       = gconv.String(deposits.Map()["bank_flow"])        //银行流水号
+			bankName       = gconv.String(deposits.Map()["bank_name"])        //银行名称
+			payVoucher     = gconv.String(deposits.Map()["pay_voucher"])      //支付凭证
+			payTime        = gconv.String(deposits.Map()["pay_time"])         //支付时间
+			payAccountName = gconv.String(deposits.Map()["pay_account_name"]) //支付户名
+			transactionId  = gconv.Int(deposits.Map()["transaction_id"])      //支付单号
+		)
+		var param = model.OrdersEditBatchReturn{
+			ReturnType:    1,
+			FlowType:      0,
+			ReturnCode:    "",
+			TransactionId: transactionId,
+			OrderArr: []g.Map{
+				{
+					"orderId": orderId,
+					"money":   sDeposit.ReturnedMoney,
+				},
+			},
+			ReturnVoucherUrl: payVoucher,
+			ReturnRemarks:    "",
+			ReturnMoney:      int(sDeposit.ReturnedMoney),
+			PayAccountName:   payAccountName,
+			BNKTIM:           payTime,
+			BNKFLW:           bankFlow,
+			BNKNAM:           bankName,
+		}
+		err = EditBatchReturn(ctx, param)
+		if err != nil {
+			return errors.Wrap(err, "订单回款失败")
+		}
+	}
 	return err
 }
 
 // todo 保证金支付信息-删除
 func DelDepositPayment(ctx context.Context, orderCode string) error {
+	result, err := g.DB().Query(ctx, fmt.Sprintf(`SELECT  * FROM  %s odo WHERE odo.order_code = ? AND odo.is_del = 0`, model.DepositPaymentTable), orderCode)
+	if err != nil || !result.IsEmpty() {
+		return errors.Wrap(err, "删除保证金支付信息失败或已删除")
+	}
 	queryMap := map[string]interface{}{
 		"order_code": orderCode,
 	}
 	updateMap := map[string]interface{}{
 		"is_del": 1,
 	}
-	if _, err := g.DB().Update(ctx, model.DepositTable, queryMap, updateMap); err != nil {
+	if _, err = g.DB().Update(ctx, model.DepositTable, queryMap, updateMap); err != nil {
 		return gerror.Wrap(err, "删除保证金支付信息异常")
 	}
 	return nil
@@ -143,35 +312,40 @@ func DelDepositPayment(ctx context.Context, orderCode string) error {
 
 // 保证金-详情
 func FindDepositDetailByOrderCode(ctx context.Context, orderCode string) (res map[string]interface{}) {
-	querySql := `SELECT  * FROM  jianyu.order_deposit od WHERE od.order_code  = ? AND od.money > 0` //保证金大于0,是有效保证金;is_del是保证金支付信息 是否删除
-	results, err := g.DB().Query(ctx, querySql, orderCode)
+	querySql := fmt.Sprintf(`SELECT  * FROM  %s od WHERE od.order_code  = ? AND od.money > 0`, model.DepositTable) //保证金大于0,是有效保证金;is_del是保证金支付信息 是否删除
+	record, err := g.DB().GetOne(ctx, querySql, orderCode)
 	if err != nil {
 		g.Log().Errorf(ctx, "订单 %s 保证金查询异常 %s", orderCode, err.Error())
 		return
 	}
-	if len(results) == 0 {
+	if record.IsEmpty() {
 		g.Log().Errorf(ctx, "订单 %s 暂无保证金数据", orderCode)
 		return
 	}
-	result := results[0]
+	result := record.Map()
 	res = map[string]interface{}{}
 	//保证金概览
 	overviewMap := map[string]interface{}{
-		"money":    FenToYuanInt64(gconv.Int64(result["money"])),     //保证金
-		"payMoney": FenToYuanInt64(gconv.Int64(result["pay_money"])), //已支付金额
+		"money": FenToYuanInt64(gconv.Int64(result["money"])), //保证金
+		//"payMoney": FenToYuanInt64(gconv.Int64(result["pay_money"])), //已支付金额
 		//"refundMoney":   gconv.Int(result["refund_money"]),   //退还金额
 		//"returnedMoney": gconv.Int(result["returned_money"]), //转回款金额
 	}
 	//保证金支付信息 已支付
-	state := gconv.Int(result["state"])
-	if state == 1 {
-		payWayStr := "对公转账"
+	paymentSql := fmt.Sprintf("SELECT  * FROM  %s odp WHERE odp.order_code  = ? AND  odp.is_del  = 0 ORDER BY  odp.operate_time DESC ", model.DepositPaymentTable)
+	record, err = g.DB().GetOne(ctx, paymentSql, orderCode)
+	if err == nil && !record.IsEmpty() {
+		result = record.Map()
+		overviewMap["payMoney"] = FenToYuanInt64(gconv.Int64(result["pay_money"])) //已支付金额
+		payWayStr := "第三方支付"
 		payWay := gconv.Int(result["pay_way"]) //支付方式,1-微信 2-支付宝 3-对公转账
 		switch payWay {
 		case 1:
 			payWayStr = "微信"
 		case 2:
 			payWayStr = "支付宝"
+		case 3:
+			payWayStr = "对公转账"
 		}
 		res["payment"] = map[string]interface{}{
 			"payTime":         gconv.String(result["pay_time"]),                        //保证金支付时间
@@ -188,10 +362,9 @@ func FindDepositDetailByOrderCode(ctx context.Context, orderCode string) (res ma
 		}
 		//保证金退还/转回款信息记录
 		var (
-			oSql      = `SELECT  * FROM  jianyu.order_deposit_operate odo WHERE odo.order_code  = ? ORDER BY  odo.operate_time  DESC `
 			operateRS gdb.Result
 		)
-		operateRS, err = g.DB().Query(ctx, oSql, orderCode)
+		operateRS, err = g.DB().Query(ctx, fmt.Sprintf(`SELECT  * FROM  %s odo WHERE odo.order_code  = ? ORDER BY  odo.operate_time  DESC `, model.DepositOperateTable), orderCode)
 		if err != nil || operateRS.IsEmpty() {
 			g.Log().Info(ctx, "未查到保证金退还/转回款信息记录")
 		} else {

+ 4 - 1
internal/model/deposit.go

@@ -3,6 +3,7 @@ package model
 var (
 	DepositTable        = "jianyu.order_deposit"
 	DepositOperateTable = "jianyu.order_deposit_operate"
+	DepositPaymentTable = "jianyu.order_deposit_payment"
 )
 
 // 保证金
@@ -18,11 +19,13 @@ type SDeposit struct {
 // 保证金支付信息
 type SDepositPayment struct {
 	PayWay         int            `json:"pay_way"`          //支付方式,1-微信 2-支付宝 3-对公转账
+	FlowType       int            `json:"flow_type"`        //流水方式 0cds回款  1手动录入
+	TransactionId  int            `json:"transaction_id"`   //对公转账银行流水号? todo
 	BankFlow       string         `json:"bank_flow"`        //银行流水号
 	PayAccountName string         `json:"pay_account_name"` //支付户名
 	BankName       string         `json:"bank_name"`        //银行
 	PayTime        string         `json:"pay_time"`         //支付时间
-	FlowMoney      int64          `json:"flow_money"`       //银行流水
+	FlowMoney      int64          `json:"flow_money"`       //银行流水  总金额
 	PayVoucher     string         `json:"pay_voucher"`      //支付凭证
 	Remark         string         `json:"remark"`           //支付说明和备注
 	DepositList    []SDepositList `json:"deposit_list"`     //关联订单回款明细