jyOrderManager/internal/logic/timedTask/onlineReturnMoney.go

package timedTask

import (
	"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"
	"jyOrderManager/internal/consts"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/order"
	"jyOrderManager/internal/logic/product"
	"log"
	"math"
	"strings"
	"time"
)

// 线上回款-合并至回款表
func OnlineReturnMoney() {
	var ctx = context.Background()
	data, _ := g.DB().Query(ctx, "SELECT r.id,r.order_code,r.return_money,p.pay_way,p.transaction_id,p.pay_time FROM return_money_online r inner join return_money_online_pay  p on (r.id=p.return_id)  WHERE r.status=1 and p.status =1 ")
	if !data.IsEmpty() {
		for _, m := range data.List() {
			var (
				rowId         = gconv.String(m["id"])
				orderCode     = gconv.String(m["order_code"])
				returnMoney   = gconv.Int(m["return_money"])
				payTime       = gconv.String(m["pay_time"])
				transactionId = gconv.String(m["transaction_id"])
				payWay        = gconv.String(m["pay_way"])
			)

			orderData, _ := g.DB().GetOne(ctx, "dataexport_order", map[string]interface{}{
				"order_code": orderCode,
			}, "", "")
			if orderData.IsEmpty() {
				continue
			}
			var (
				money        = gconv.Int(orderData.Map()["pay_money"])
				order_status = gconv.Int(orderData.Map()["order_status"])
			)

			//计算已回款金额
			var returned_money int
			if calculation, _ := g.DB().GetOne(ctx, "SELECT SUM(return_money) as returned_money  FROM return_money_record WHERE order_code=? AND state=1", orderCode); !calculation.IsEmpty() {
				returned_money = gconv.Int(calculation.Map()["returned_money"])
			}
			uData := make(map[string]interface{})
			var (
				entId, userPositionId int64
				err                   error
			)
			if returnMoney+returned_money == money && consts.PhoneRegex.MatchString(gconv.String(orderData["user_phone"])) {
				uData, entId, userPositionId, err = jyutil.GetCreateUserData(gconv.String(orderData.Map()["user_phone"]), gconv.String(orderData.Map()["company_name"]), gconv.Int(orderData.Map()["buy_subject"]) == 2)
				if err != nil {
					continue
				}
			}
			if err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
				if returned_money == 0 { //首次回款业绩生效
					if err := order.CommonChange(ctx, orderCode, payTime, order.ReturnMoney); err != nil {
						log.Printf("%s 回款销售业绩生效异常 %v", orderCode, err)
					}
				}
				orderUpdate := map[string]interface{}{}
				if order_status != 1 {
					orderUpdate["order_status"] = 1
				}
				if returnMoney+returned_money == money { //全额回款
					orderUpdate["return_status"] = 1
				} else {
					orderUpdate["return_status"] = 2
				}

				if _, err := g.DB().Update(ctx, "dataexport_order", orderUpdate, map[string]interface{}{"order_code": orderCode}); err != nil {
					return err
				}

				var (
					procedures  float64
					return_type int
				)
				if strings.Contains(payWay, "wx") {
					return_type = 1
					procedures = math.Round(gconv.Float64(returnMoney) * order.WxProceduresMoney / 100)
				} else {
					return_type = 2
					procedures = math.Round(gconv.Float64(returnMoney) * order.AliProceduresMoney / 100)
				}

				if _, err := g.DB().Update(ctx, "return_money_online", map[string]interface{}{
					"status": 2,
				}, map[string]interface{}{
					"id": rowId,
				}); err != nil {
					return err
				}

				if _, err := g.DB().Insert(ctx, "return_money_record", map[string]interface{}{
					"return_time":      payTime,
					"return_money":     returnMoney,
					"procedures_money": procedures,  //手续费
					"return_type":      return_type, //'回款方式，1-微信 2-支付宝 3-对公转账',
					"return_code":      transactionId,
					"order_code":       orderCode,
					"operate_person":   "系统自动",
					"operate_time":     time.Now().Format("2006-01-02 15:04:05"),
					"operate_type":     3,
					"flow_money":       returnMoney,
					"state":            1,
				}); err != nil {
					return err
				}

				if orderUpdate["return_status"] == 1 && consts.PhoneRegex.MatchString(gconv.String(orderData["user_phone"])) {
					productDetail, _ := g.DB().Ctx(ctx).Query(ctx, fmt.Sprintf(`SELECT * FROM jy_order_detail WHERE order_code ='%s' and returned_open =1 and returned_open = 0 and is_service_open = 0 and status =1`, orderCode))
					if !productDetail.IsEmpty() {
						//全额回款开通权益
						for _, o := range productDetail.List() {
							if !jyutil.IsServiceOpen(m) {
								continue
							}
							m["userMap"] = map[string]interface{}{
								"userData": uData, "entId": entId, "userPositionId": userPositionId,
							}
							//参数注入
							m["phone"] = o["user_phone"]
							m["order_code"] = orderCode
							m["amount"] = m["final_price"]
							m["reqCompanyName"] = o["company_name"]
							m["reqSubject"] = o["buy_subject"]
							productCode := gconv.String(m["product_code"])
							pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
							if err != nil {
								continue
							}
							pObj, err := pFunc(m)
							if err != nil {
								gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
								continue
							}
							if err = pObj.OpenService(ctx, time.Now()); err != nil {
								log.Println("自动回款 OpenService err ", err)
								continue
							}
						}
						if orderUserId := gconv.String(orderData.Map()["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(orderData.Map()["personPhone"]); personPhone != "" {
									jyutil.EndAddUser(ctx, entId, gconv.String(orderData.Map()["user_phone"]), personPhone, gconv.String(orderData.Map()["personName"]))
								}
							}
							//更新订单
							_, err = g.DB().Update(ctx, consts.OrderListTableName, upData, "order_code=?", orderCode)
							if err != nil {
								return err
							}
						}
					}
				}
				return nil
			}); err != nil {
				log.Println("回款更新失败", orderCode)
			}

		}
	}
	//关闭过期订单
	g.DB().Update(ctx, "return_money_online", map[string]interface{}{"state": 1}, " state=0 AND expire_time<=? ", time.Now().Format("2006-01-02 15:04:05"))
}