jyOrderManager/internal/logic/order/deposit.go

package order

import (
	"app.yhyue.com/moapp/jybase/common"
	"context"
	"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"
	"github.com/pkg/errors"
	"jyOrderManager/internal/consts"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/product"
	"jyOrderManager/internal/model"
	"log"
	"math"
	"time"
)

// todo 保证金--新增
func SaveDepositInfo(ctx context.Context, orderCode, userName, dPaymentAccount string, money int64) error {
	timeStr := time.Now().Format("2006-01-02 15:04:05")
	if _, err := g.DB().Ctx(ctx).Insert(ctx, model.DepositTable, g.Map{
		"order_code":      orderCode,
		"money":           money,
		"payment_account": dPaymentAccount,
		"operate_time":    timeStr,
		"operate_person":  userName,
		"create_time":     timeStr,
	}); err != nil {
		return gerror.Wrap(err, "保证金保存异常")
	}
	return nil
}

// todo 保证金编辑（可以新增
func EditDeposit(ctx context.Context, sDeposit model.SDeposit) error {
	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 {
		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 = 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  保证金-支付信息（批量|单条）
func SaveDepositPayment(ctx context.Context, sDepositPayment model.SDepositPayment) error {
	var payWay string
	switch sDepositPayment.PayWay {
	case 1:
		payWay = "微信"
	case 2:
		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
		}
		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("新增保证金失败，保证金金额不符合")
		}
	}
	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, 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("未查到当前订单 有效的保证金信息")
	}
	payMoney := FenToYuanInt64(gconv.Int64(deposits.Map()["pay_money"]))
	if payMoney != sDeposit.RefundMoney+sDeposit.ReturnedMoney {
		return fmt.Errorf("保证金金额异常")
	}
	_, err = g.DB().Insert(ctx, model.DepositOperateTable, g.Map{
		"order_code":     sDeposit.OrderCode,
		"refund_money":   YuanToFen(sDeposit.RefundMoney),
		"refund_time":    sDeposit.RefundTime,
		"returned_money": YuanToFen(sDeposit.ReturnedMoney),
		"operate_time":   time.Now().Format(time.DateTime),
		"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 {
		return gerror.Wrap(err, "删除保证金支付信息异常")
	}
	return nil
}

// 保证金-详情
func FindDepositDetailByOrderCode(ctx context.Context, orderCode string) (res map[string]interface{}) {
	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 record.IsEmpty() {
		g.Log().Errorf(ctx, "订单 %s 暂无保证金数据", orderCode)
		return
	}
	result := record.Map()
	res = map[string]interface{}{}
	//保证金概览
	overviewMap := map[string]interface{}{
		"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"]), //转回款金额
	}
	//保证金支付信息 已支付
	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"]),                        //保证金支付时间
			"payMoney":        FenToYuanInt64(gconv.Int64(result["pay_money"])),        //已支付金额
			"payWay":          payWayStr,                                               //支付方式
			"proceduresMoney": FenToYuanInt64(gconv.Int64(result["procedures_money"])), //手续费
			"bankName":        gconv.String(result["bank_name"]),                       //银行
			"bankFlow":        gconv.String(result["bank_flow"]),                       //银行流水号
			"payAccountName":  gconv.String(result["pay_account_name"]),                //支付户名
			"flowMoney":       FenToYuanInt64(gconv.Int64(result["flow_money"])),       //流水金额
			"payVoucher":      gconv.String(result["pay_voucher"]),                     //支付凭证
			"operateTime":     gconv.String(result["operate_time"]),                    //操作时间
			"operatePerson":   gconv.String(result["operate_person"]),                  //操作人
		}
		//保证金退还/转回款信息记录
		var (
			operateRS gdb.Result
		)
		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 {
			var (
				refundMoney, returnedMoney int64
				operates                   []map[string]interface{}
			)
			for _, v := range operateRS.List() {
				refundMoney = refundMoney + gconv.Int64(v["refund_money"])
				returnedMoney = returnedMoney + gconv.Int64(v["returned_money"])
				operates = append(operates, map[string]interface{}{
					"refundTime":    gconv.String(v["refund_time"]),                   //退还时间
					"refundMoney":   FenToYuanInt64(gconv.Int64(v["refund_money"])),   //退还金额
					"returnedMoney": FenToYuanInt64(gconv.Int64(v["returned_money"])), //转回款金额
					"operateTime":   gconv.String(v["operate_time"]),                  //操作时间
				})
			}
			overviewMap["refundMoney"] = FenToYuanInt64(refundMoney)
			overviewMap["returnedMoney"] = FenToYuanInt64(returnedMoney)
			res["operates"] = operates
		}
	}
	res["overview"] = overviewMap
	return
}

// 分转元 int64
func FenToYuanInt64(fen int64) int64 {
	return fen / 100
}

// 分转元字符串
func FenToYuanString(fen int64) string {
	return fmt.Sprintf("%d", fen/100)
}

// 元转分
func YuanToFen(yuan int64) int64 {
	return yuan * 100
}

// HasDepositOperate 查询是否有保证金操作记录
func HasDepositOperate(ctx context.Context, orderCode string) (bool, error) {
	count, err := g.DB().GetCount(ctx, "SELECT * FROM order_deposit_operate WHERE order_code=?", orderCode)
	if err != nil {
		log.Println("查询是否有保证金操作异常：", err, orderCode)
		return false, err
	}
	return count > 0, nil
}

// GetDepositPayMoney 获取保证金已支付金额
func GetDepositPayMoney(ctx context.Context, orderCode string) (int64, error) {
	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
	}
	if data.Len() == 0 {
		return 0, nil
	}
	dataMap := data[0].Map()
	return common.Int64All(dataMap["pay_money"]), nil
}