Merge branch 'feature/v1.0.1' of https://jygit.jydev.jianyu360.cn/jianyu/jyOrderManager into feature/v1.0.1

internal/logic/order/deposit.go

@@ -15,6 +15,7 @@ import (
 	"jyOrderManager/internal/model"
 	"log"
 	"math"
+	"strings"
 	"time"
 )
 
@@ -85,6 +86,7 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 	var (
 		price, realPrice int64
 		orderArr         = make(map[string]map[string]interface{})
+		depositId        []string
 	)
 	for _, dl := range sDepositPayment.DepositList {
 		if dl.OrderCode == "" || dl.Money == 0 {
@@ -128,7 +130,7 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 			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{ //保证金支付信息
+			res, err := g.DB().Insert(ctx, model.DepositPaymentTable, g.Map{ //保证金支付信息
 				"order_code":       key,
 				"pay_time":         sDepositPayment.PayTime,
 				"pay_money":        YuanToFen(payMoney),
@@ -140,6 +142,8 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 				"flow_money":       YuanToFen(sDepositPayment.FlowMoney),
 				"bank_name":        sDepositPayment.BankName,
 				"bank_flow":        sDepositPayment.BankFlow,
+				"pay_code":         sDepositPayment.PayCode,
+				"transaction_id":   sDepositPayment.TransactionId,
 				"pay_voucher":      sDepositPayment.PayVoucher,
 				"pay_account_name": sDepositPayment.PayAccountName,
 				"create_time":      time.Now().Format(time.DateTime),
@@ -147,70 +151,77 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 			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
+			} else {
+				var insertId int64
+				insertId, err = res.LastInsertId()
+				if err == nil && insertId > 0 {
+					depositId = append(depositId, fmt.Sprint(insertId))
+				}
+				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 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 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 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"]))
+								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)
 								}
-								//更新订单
-								_, err = g.DB().Update(ctx, consts.OrderListTableName, upData, "order_code=?", key)
+								return err
+							}); err != nil {
+								log.Println(err)
+								return err
 							}
-							return err
-						}); err != nil {
-							log.Println(err)
-							return err
 						}
 					}
 				}
@@ -219,20 +230,34 @@ func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayme
 		})
 		return err
 	}
+	//cbs回款流水
+	//查询回款流水记录
+	if sDepositPayment.FlowType == 0 {
+		//修改回款流水记
+		updateTransactionData := map[string]interface{}{
+			"deposit_id": strings.Join(depositId, ","),
+			"ISRELATION": 3,
+		}
+		_, err := g.DB("cbs").Ctx(ctx).Update(ctx, "transaction", updateTransactionData, map[string]interface{}{"id": transactionMap["id"]})
+		if err != nil {
+			return err
+
+		}
+	}
 	return nil
 }
 
 // todo 保证金支付款-退还/转回款
 func DepositRefundOrRetMoney(ctx context.Context, sDeposit model.SDeposit) error {
-	//保证金信息  未删除
-	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)
+	//保证金支付信息  未删除
+	depositPayment, 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() {
+	if depositPayment.IsEmpty() {
 		return fmt.Errorf("未查到当前订单 有效的保证金信息")
 	}
-	payMoney := FenToYuanInt64(gconv.Int64(deposits.Map()["pay_money"]))
+	payMoney := FenToYuanInt64(gconv.Int64(depositPayment.Map()["pay_money"]))
 	if payMoney != sDeposit.RefundMoney+sDeposit.ReturnedMoney {
 		return fmt.Errorf("保证金金额异常")
 	}
@@ -256,19 +281,20 @@ func DepositRefundOrRetMoney(ctx context.Context, sDeposit model.SDeposit) error
 			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"])      //支付单号
+			orderId        = record.Map()["id"]                                     //订单id
+			payWay         = gconv.Int(depositPayment.Map()["pay_way"])             //支付方式，1-微信 2-支付宝 3-对公转账
+			bankFlow       = gconv.String(depositPayment.Map()["bank_flow"])        //对公转账 银行流水号，手动录入
+			bankName       = gconv.String(depositPayment.Map()["bank_name"])        //银行名称
+			payVoucher     = gconv.String(depositPayment.Map()["pay_voucher"])      //支付凭证
+			payTime        = gconv.String(depositPayment.Map()["pay_time"])         //支付时间
+			payAccountName = gconv.String(depositPayment.Map()["pay_account_name"]) //支付户名
+			payCode        = gconv.String(depositPayment.Map()["pay_code"])         //支付宝、微信、第三方平台 支付单号
+			transactionId  = gconv.Int(depositPayment.Map()["transaction_id"])      //对公转账银行流水号 cbs 自动录入
 		)
 		var param = model.OrdersEditBatchReturn{
-			ReturnType:    1,
-			FlowType:      0,
-			ReturnCode:    "",
+			ReturnType:    payWay,
+			FlowType:      0, //保证金转回款，即使保证金是CBS回款，转回款不走CBS逻辑
+			ReturnCode:    payCode,
 			TransactionId: transactionId,
 			OrderArr: []g.Map{
 				{
@@ -418,21 +444,7 @@ func HasDepositOperate(ctx context.Context, orderCode string) (bool, error) {
 
 // GetDepositPayMoney 获取保证金已支付金额
 func GetDepositPayMoney(ctx context.Context, orderCode string) (int64, error) {
-	data, err := g.DB().Query(ctx, "SELECT pay_money FROM order_deposit_payment WHERE order_code=? and is_del=0 ", orderCode)
-	if err != nil {
-		log.Println("获取保证金已支付金额异常：", err, orderCode)
-		return 0, err
-	}
-	if data.Len() == 0 {
-		return 0, nil
-	}
-	dataMap := data[0].Map()
-	return common.Int64All(dataMap["pay_money"]), nil
-}
-
-// GetDepositMoney 获取保证金金额
-func GetDepositMoney(ctx context.Context, orderCode string) (int64, error) {
-	data, err := g.DB().Query(ctx, "SELECT money FROM order_deposit WHERE order_code=?", orderCode)
+	data, err := g.DB().Query(ctx, "SELECT pay_money FROM order_deposit WHERE order_code=? and state=1 and is_del=0 ", orderCode)
 	if err != nil {
 		log.Println("获取保证金已支付金额异常：", err, orderCode)
 		return 0, err

internal/model/deposit.go

@@ -19,12 +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"`        //银行流水号
+	FlowType       int            `json:"flow_type"`        //流水方式 0:cbs回款  1:手动录入
+	TransactionId  int            `json:"transaction_id"`   //对公转账银行流水号 cbs 自动录入
+	BankFlow       string         `json:"bank_flow"`        //对公转账 银行流水号，手动录入
+	PayCode        string         `json:"pay_code"`         //支付宝、微信、第三方平台 支付单号
 	PayAccountName string         `json:"pay_account_name"` //支付户名
 	BankName       string         `json:"bank_name"`        //银行
-	PayTime        string         `json:"pay_time"`         //支付时间
+	PayTime        string         `json:"pay_time"`         //回款时间
 	FlowMoney      int64          `json:"flow_money"`       //银行流水  总金额
 	PayVoucher     string         `json:"pay_voucher"`      //支付凭证
 	Remark         string         `json:"remark"`           //支付说明和备注
@@ -33,6 +34,6 @@ type SDepositPayment struct {
 
 // 关联订单回款明细
 type SDepositList struct {
-	OrderCode string `json:"order_code"` //订单
+	OrderCode string `json:"order_code"` //订单编号
 	Money     int64  `json:"money"`      //金额
 }

internal/model/orderParams.go

@@ -99,18 +99,18 @@ type (
 	}
 
 	OrdersEditBatchReturn struct { //回款
-		ReturnType       int                      `json:"returnType"`
-		FlowType         int                      `json:"flowType"`
-		ReturnCode       string                   `json:"returnCode"`
-		TransactionId    int                      `json:"transactionId"`
-		OrderArr         []map[string]interface{} `json:"orderArr"`
-		ReturnVoucherUrl string                   `json:"returnVoucherUrl"`
-		ReturnRemarks    string                   `json:"returnRemarks"`
-		ReturnMoney      int                      `json:"returnMoney"`
-		PayAccountName   string                   `json:"payAccountName"`
-		BNKTIM           string                   `json:"BNKTIM"`
-		BNKFLW           string                   `json:"BNKFLW"`
-		BNKNAM           string                   `json:"BNKNAM"`
+		ReturnType       int                      `json:"returnType"`       //回款方式1微信2阿里 3对公转账
+		FlowType         int                      `json:"flowType"`         //是否CBS流水回款回款0是非0不是
+		ReturnCode       string                   `json:"returnCode"`       //支付宝，微信，第三方平台回款单号
+		TransactionId    int                      `json:"transactionId"`    //对公转账流水单号id
+		OrderArr         []map[string]interface{} `json:"orderArr"`         //订单信息 id：money
+		ReturnVoucherUrl string                   `json:"returnVoucherUrl"` //回款凭证地址
+		ReturnRemarks    string                   `json:"returnRemarks"`    //回款说明/备注
+		ReturnMoney      int                      `json:"returnMoney"`      //回款流水金额
+		PayAccountName   string                   `json:"payAccountName"`   //支付户名
+		BNKTIM           string                   `json:"BNKTIM"`           //回款时间
+		BNKFLW           string                   `json:"BNKFLW"`           //银行流水号
+		BNKNAM           string                   `json:"BNKNAM"`           //银行名称
 	}
 	OrdersDeleteReturn struct { //回款
 		Id int `p:"username"  v:"required"`