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

internal/consts/consts.go

@@ -12,6 +12,7 @@ const (
 	OrderDetailTableName     = "jy_order_detail"  //订单明细表
 	MoneyCorrectionTableName = "moneyCorrection"  // 红冲记录
 	DBCBS                    = "cbs"              // cbs数据所在数据库名
+	RedTypeContractMoney     = "合同金额红冲"           // 红冲类型： 合同金额红冲
 )
 
 var (
@@ -19,3 +20,7 @@ var (
 
 	PhoneRegex = regexp.MustCompile("^1[3456789]{1}\\d{9}$")
 )
+
+const (
+	OrderStatusFinished = 1 // 订单状态-已完成
+)

internal/logic/order/redPunch.go

@@ -45,6 +45,9 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 			"detail_id":        param.Id,
 			"activity_code":    param.ActiveCode,
 		}
+		if params.IsRefundCall { // 退款自动生成的红冲记录  操作人为 系统字段
+			insertData["createPerson"] = "系统自动"
+		}
 		if strings.Contains(params.RedType, "签约主体") {
 			if param.PayMoney == 0 {
 				param.PayMoney = common.IntAll(orderData.Map()["pay_money"])
@@ -149,72 +152,90 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 		if refund_money >= params.PayMoney {
 			updateData["refund_status"] = 1
 		}
-		if return_money >= params.PayMoney {
-			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`, params.OrderCode))
-			if !productDetail.IsEmpty() {
-				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 {
-					return errors.New("用户创建失败")
+		//  定金=支付金额 开通权限 修改状态
+		// 如果不是全额回款查询已支付保证金金额是否和订单金额相等 如果相等也展示权限开通按钮
+		var isDepositFullReturn bool
+		if has, err := HasDepositOperate(ctx, params.OrderCode); !has && err == nil { // 验证保证金是否已经有操作记录
+			if depositPayMoney, err := GetDepositPayMoney(ctx, params.OrderCode); depositPayMoney > 0 && err == nil { // 判断已支付保证金
+				if depositPayMoney == int64(params.PayMoney) {
+					isDepositFullReturn = true
 				}
-				//全额回款开通权益
-				if !consts.PhoneRegex.MatchString(gconv.String(orderData["user_phone"])) {
-					return errors.New("手机号格式异常")
+			}
+		}
+
+		if return_money >= params.PayMoney || isDepositFullReturn {
+			updateData["return_status"] = 1
+			//  判断是否是退款调用  如果是退款调用生成红冲记录不要开权限 不改订单状态
+			if !params.IsRefundCall {
+				if isDepositFullReturn {
+					// 如果保证金金额==合同金额  更新订单状态为已完成
+					updateData["order_status"] = consts.OrderStatusFinished
 				}
-				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"] = orderData.Map()["user_phone"]
-						m["order_code"] = params.OrderCode
-						m["reqCompanyName"] = orderData.Map()["company_name"]
-						m["amount"] = m["final_price"]
-						m["reqSubject"] = orderData.Map()["buy_subject"]
-						m["linked_orderId"] = m["linked_detail_id"]
-						productCode := gconv.String(m["product_code"])
-						pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
-						if err != nil {
-							return err
-						}
-						pObj, err := pFunc(m)
-						if err != nil {
-							return gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
-						}
-						if err := pObj.OpenService(ctx, time.Now()); err != nil {
-							return err
-						}
+				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`, params.OrderCode))
+				if !productDetail.IsEmpty() {
+					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 {
+						return errors.New("用户创建失败")
 					}
-					if gconv.Int(orderData.Map()["buy_subject"]) == 2 {
-						uData["userId"] = userPositionId
+					//全额回款开通权益
+					if !consts.PhoneRegex.MatchString(gconv.String(orderData["user_phone"])) {
+						return errors.New("手机号格式异常")
 					}
-					if orderUserId := gconv.String(orderData.Map()["user_id"]); orderUserId == "" || orderUserId != gconv.String(uData["userId"]) || (gconv.Int(orderData.Map()["buy_subject"]) == 2 && gconv.Int64(orderData.Map()["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(orderData.Map()["personPhone"]); personPhone != "" {
-								jyutil.EndAddUser(ctx, entId, gconv.String(orderData.Map()["user_phone"]), personPhone, gconv.String(orderData.Map()["personName"]))
+					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"] = orderData.Map()["user_phone"]
+							m["order_code"] = params.OrderCode
+							m["reqCompanyName"] = orderData.Map()["company_name"]
+							m["amount"] = m["final_price"]
+							m["reqSubject"] = orderData.Map()["buy_subject"]
+							m["linked_orderId"] = m["linked_detail_id"]
+							productCode := gconv.String(m["product_code"])
+							pFunc, err := product.JyProFunc.GetProductInitFuncByCode(productCode)
+							if err != nil {
+								return err
+							}
+							pObj, err := pFunc(m)
+							if err != nil {
+								return gerror.Wrap(err, fmt.Sprintf("获取%s商品异常", productCode))
+							}
+							if err := pObj.OpenService(ctx, time.Now()); err != nil {
+								return err
 							}
 						}
-						//更新订单
-						_, err = g.DB().Update(ctx, consts.OrderListTableName, upData, "order_code=?", params.OrderCode)
-						if err != nil {
-							return err
+						if gconv.Int(orderData.Map()["buy_subject"]) == 2 {
+							uData["userId"] = userPositionId
+						}
+						if orderUserId := gconv.String(orderData.Map()["user_id"]); orderUserId == "" || orderUserId != gconv.String(uData["userId"]) || (gconv.Int(orderData.Map()["buy_subject"]) == 2 && gconv.Int64(orderData.Map()["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(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=?", params.OrderCode)
+							if err != nil {
+								return err
+							}
 						}
-					}
 
-					return nil
-				}); err != nil {
-					log.Println(err)
-					return err
+						return nil
+					}); err != nil {
+						log.Println(err)
+						return err
+					}
 				}
 			}
 		}

internal/logic/order/refund.go

@@ -61,23 +61,30 @@ func ConfirmRefund(ctx context.Context, param model.OrderRefundParams) error {
 					}
 				}
 			}
-			// 生一条红冲记录
-			insertData := map[string]interface{}{
-				"orderCode":        orderCode,
-				"correctionReason": "客户退款",
-				"createTime":       date.NowFormat(date.Date_Full_Layout),
-				"createPerson":     "系统自动",
-				"redType":          "合同金额红冲",
-				"detail_id":        param.RefundProduct[0].Id,
-				"activity_code":    param.RefundProduct[0].ActiveId,
-				"commission":       0,
-				"payMoney":         -param.RefundProduct[0].Money,
-				"signingSubject":   signingSubject,
+			redPunchParam := model.OrderRedPunchParams{
+				OrderCode: orderCode,
+				RedType:   consts.RedTypeContractMoney,
+				RedPunch: []model.RedPunch{{Id: param.RefundProduct[0].Id,
+					PayMoney:         int(param.RefundProduct[0].Money),
+					SigningSubject:   signingSubject,
+					ActiveCode:       param.RefundProduct[0].ActiveId,
+					CorrectionReason: "客户退款",
+				}},
+				IsRefundCall: true,
+			}
+			err = OperateOrderRedPunch(ctx, redPunchParam)
+			if err != nil {
+				log.Println("退款自动红冲调用失败：", err, redPunchParam)
 			}
-			g.DB().Insert(ctx, consts.MoneyCorrectionTableName, insertData)
 		}
 		return err
 	} else if param.IsOffline == 1 {
+		redPunchParam := model.OrderRedPunchParams{
+			OrderCode:    orderCode,
+			RedType:      consts.RedTypeContractMoney,
+			RedPunch:     []model.RedPunch{},
+			IsRefundCall: true,
+		}
 		oldReturnData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code='%s' and state=1`, orderCode))
 		oldRefundData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code='%s'`, orderCode))
 		return_money := common.IntAll(oldReturnData.Map()["return_money"])
@@ -87,7 +94,14 @@ func ConfirmRefund(ctx context.Context, param model.OrderRefundParams) error {
 		}
 		var refundMoney int
 		for _, product := range param.RefundProduct {
+			redPunchParam.RedPunch = append(redPunchParam.RedPunch, model.RedPunch{Id: product.Id,
+				PayMoney:         int(product.Money),
+				SigningSubject:   signingSubject,
+				ActiveCode:       product.ActiveId,
+				CorrectionReason: "客户退款",
+			})
 			refundMoney += gconv.Int(product.Money)
+
 		}
 		if refundMoney > return_money-old_refund_money {
 			return errors.New("退款金额大于剩余汇款金额")
@@ -113,20 +127,6 @@ func ConfirmRefund(ctx context.Context, param model.OrderRefundParams) error {
 					"pay_status": -1,
 				}, map[string]interface{}{"activity_code": product.ActiveId, "order_code": orderCode})
 			}
-			// 生一条红冲记录
-			insertData := map[string]interface{}{
-				"orderCode":        orderCode,
-				"correctionReason": "客户退款",
-				"createTime":       date.NowFormat(date.Date_Full_Layout),
-				"createPerson":     "系统自动",
-				"redType":          "合同金额红冲",
-				"detail_id":        product.Id,
-				"activity_code":    product.ActiveId,
-				"commission":       0,
-				"payMoney":         -product.Money,
-				"signingSubject":   signingSubject,
-			}
-			g.DB().Insert(ctx, consts.MoneyCorrectionTableName, insertData)
 		}
 		//returnData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code='%s' and state=1`, orderCode))
 		//refundData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code='%s'`, orderCode))
@@ -146,6 +146,13 @@ func ConfirmRefund(ctx context.Context, param model.OrderRefundParams) error {
 			"last_update_person": jyutil.GetUserMsgFromCtx(ctx).EntUserName,
 			"last_update_time":   date.NowFormat(date.Date_Full_Layout),
 		}, qMap)
+		if err != nil {
+			log.Println("更新订单表失败：", err)
+		}
+		err = OperateOrderRedPunch(ctx, redPunchParam)
+		if err != nil {
+			log.Println("退款自动红冲调用失败：", err, redPunchParam)
+		}
 		return err
 
 	}

internal/model/orderParams.go

@@ -180,10 +180,11 @@ type (
 		RefundType   string `json:"refundType"`
 	}
 	OrderRedPunchParams struct { //红冲
-		OrderCode string     `json:"orderCode"`
-		RedType   string     `json:"redType"`
-		PayMoney  int        `json:"payMoney"` //总支付金额
-		RedPunch  []RedPunch `json:"redPunch"`
+		OrderCode    string     `json:"orderCode"`
+		RedType      string     `json:"redType"`
+		PayMoney     int        `json:"payMoney"` //总支付金额
+		RedPunch     []RedPunch `json:"redPunch"`
+		IsRefundCall bool       `json:"isRefundCall,omitempty"` // 是否是退款那边接口调用的红冲记录
 	}
 	RedPunch struct {
 		Id         int64  `json:"id"`