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

internal/cmd/cmd.go

@@ -59,6 +59,7 @@ var (
 					orderGroup.POST("/detail", controller.OrderDetail)                         //订单详情
 					orderGroup.POST("/cancellation", controller.OrderCancellation)             //订单作废
 					orderGroup.POST("/editBatchReturn", controller.OrderEditBatchReturn)       //订单回款
+					orderGroup.POST("/deleteBatchReturn", controller.OrderDeleteReturn)        //订单回款删除
 					orderGroup.POST("/surplusPrice", controller.OrderSurplusPrice)             //订单剩余回款计算
 					orderGroup.POST("/orderRedPunch", controller.OrderRedPunch)                //订单红冲
 					orderGroup.POST("/refund", controller.OrderRefund)                         //订单退款

internal/consts/consts.go

@@ -11,6 +11,7 @@ const (
 	OrderListTableName       = "dataexport_order" //订单表
 	OrderDetailTableName     = "jy_order_detail"  //订单明细表
 	MoneyCorrectionTableName = "moneyCorrection"  // 红冲记录
+	DBCBS                    = "cbs"              // cbs数据所在数据库名
 )
 
 var (

internal/controller/deleteReturnInfo.go

@@ -0,0 +1,29 @@
+package controller
+
+import (
+	. "app.yhyue.com/moapp/jybase/api"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/pkg/errors"
+	"jyOrderManager/internal/logic/order"
+	"jyOrderManager/internal/model"
+)
+
+func OrderDeleteReturn(r *ghttp.Request) {
+	rData, err := func() (interface{}, error) {
+		var param model.OrdersDeleteReturn
+		err := r.Parse(param)
+		if err != nil {
+			return nil, errors.Wrap(err, "数据校验异常")
+		}
+		err = order.DeleteBatchReturnMoneyInfo(r.Context(), param)
+		if err != nil {
+			return nil, errors.Wrap(err, "删除订单回款失败")
+		}
+		return nil, err
+	}()
+	if err != nil {
+		g.Log().Errorf(r.Context(), "删除订单回款异常 %v", err)
+	}
+	r.Response.WriteJson(NewResult(rData, err))
+}

internal/logic/order/deleteReturn.go

@@ -0,0 +1,143 @@
+package order
+
+import (
+	"app.yhyue.com/moapp/jybase/common"
+	"context"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/pkg/errors"
+	"jyOrderManager/internal/consts"
+	"jyOrderManager/internal/model"
+	"log"
+)
+
+func DeleteBatchReturnMoneyInfo(ctx context.Context, param model.OrdersDeleteReturn) error {
+
+	//先查看该回款是否存在
+	returnData, _ := g.DB().Ctx(ctx).GetOne(ctx, "select * from  return_money_record where  id =? and  state=1", param.Id)
+	if returnData == nil || returnData.IsEmpty() {
+		return errors.New("查不到该条回款记录信息")
+	}
+	returnDataMap := returnData.Map()
+	err := g.DB().Transaction(context.TODO(), func(ctx context.Context, tx gdb.TX) error {
+		//判断是cbs还是手动录入hffv
+		if common.Int64All(returnDataMap["flow_type"]) == 0 {
+			//cbs数据需要特殊处理
+			cbsData, err := g.DB(consts.DBCBS).GetOne(ctx, "select * from `transaction`  where  FIND_IN_SET(?,return_id)", param.Id)
+			if err != nil {
+				log.Println("transaction 查询失败:", param.Id, err)
+				return err
+			}
+			if cbsData != nil {
+				//修改回款流水记录
+				updateTransactionData := map[string]interface{}{
+					"return_id":  "",
+					"ISRELATION": 0,
+				}
+				_, err := g.DB(consts.DBCBS).Update(ctx, "transaction", updateTransactionData, map[string]interface{}{"id": (cbsData)["id"]})
+				if err != nil {
+					log.Println("transaction 更新失败", updateTransactionData, map[string]interface{}{"id": (cbsData)["id"]}, err)
+					return err
+				}
+
+			}
+			returnListData := []map[string]interface{}{}
+			if common.ObjToString(returnDataMap["bank_flow"]) != "" {
+				var err error
+				returnListData_, err := tx.Query("select * from  return_money_record where  bank_flow =? and  state=1", returnDataMap["bank_flow"])
+				if err != nil {
+					log.Println("查询回款记录失败 return_money_record", returnDataMap["bank_flow"], " bank_flow =? and  state=1")
+					return err
+				}
+				returnListData = returnListData_.List()
+			} else {
+				returnListData = append(returnListData, returnDataMap)
+			}
+			for _, value := range returnListData {
+				//查看该订单是否还存在别的回款信息
+				returnData, err := tx.Query("select * from  return_money_record where  order_code =? and  state=1", value["order_code"])
+				if returnData == nil || returnData.Len() == 0 || err != nil {
+					log.Println("根据订单号查询回款记录失败：", err, value["order_code"], " order_code =? and  state=1")
+					return errors.New("没查到")
+				}
+				updateData := map[string]interface{}{
+					"state": 0,
+				}
+				_, err = tx.Update("return_money_record", updateData, map[string]interface{}{"id": value["id"]})
+				if err != nil {
+					log.Println("更新回款记录失败：", err, updateData, map[string]interface{}{"id": value["id"]})
+					return err
+				}
+				orderData := map[string]interface{}{}
+				if returnData.Len() > 1 {
+					//说明还有别的订单，订单回款需要改为部分回款
+					orderData["return_status"] = 2
+				} else if returnData.Len() == 1 {
+					//回款改为未回款
+					orderData["return_status"] = 0
+				}
+				_, err = tx.Update("dataexport_order", orderData, map[string]interface{}{"order_code": value["order_code"]})
+				if err != nil {
+					log.Println("更新dataexport_order失败：", orderData, map[string]interface{}{"order_code": value["order_code"]}, err)
+					return err
+				}
+			}
+		} else {
+			returnListData := []map[string]interface{}{}
+			//手动录入处理简单,也会存在多个订单
+			if common.Int64All(returnDataMap["return_type"]) == 3 {
+				//回款方式，3-对公转账 通过银行流水号查找相同的
+				returnListData_, err := tx.Query("select * from  return_money_record where  bank_flow =? and  state=1 and return_type=3", returnDataMap["bank_flow"])
+				if err != nil {
+					log.Println("对公转账 流水号查询回款记录失败 return_money_record", returnDataMap["bank_flow"], "bank_flow =? and  state=1 and return_type=3")
+					return err
+				}
+				returnListData = returnListData_.List()
+
+			} else {
+				//回款方式，通过支付单号查找相同的
+				returnListData_, err := tx.Query("select * from  return_money_record where  return_code =? and  state=1 and  return_type!=3", returnDataMap["return_code"])
+				if err != nil {
+					log.Println("回款单号查询回款记录失败 return_money_record", returnDataMap["return_code"], " return_code =? and  state=1 and  return_type!=3")
+					return err
+				}
+				returnListData = returnListData_.List()
+			}
+			for _, value := range returnListData {
+				//查看该订单是否还存在别的回款信息
+				returnData, err := tx.Query("select * from  return_money_record where  order_code =? and  state=1", value["order_code"])
+				if returnData == nil || len(returnData) == 0 || err != nil {
+					log.Println("根据订单号查询回款记录失败：", err, value["order_code"], " order_code =? and  state=1")
+					return errors.New("没查到")
+				}
+				updateData := map[string]interface{}{
+					"state": 0,
+				}
+				_, err = tx.Update("return_money_record", updateData, map[string]interface{}{"id": value["id"]})
+				if err != nil {
+					log.Println("更新回款记录失败：", err, updateData, map[string]interface{}{"id": value["id"]})
+					return err
+				}
+				orderData := map[string]interface{}{}
+				if returnData.Len() > 1 {
+					//说明还有别的订单，订单回款需要改为部分回款
+					orderData["return_status"] = 2
+				} else if returnData.Len() == 1 {
+					//回款改为未回款
+					orderData["return_status"] = 0
+				}
+				_, err = tx.Update("dataexport_order", orderData, map[string]interface{}{"order_code": value["order_code"]})
+				if err != nil {
+					log.Println("更新dataexport_order失败：", orderData, map[string]interface{}{"order_code": value["order_code"]}, err)
+					return err
+				}
+			}
+
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}

internal/logic/order/deposit.go

@@ -1,6 +1,7 @@
 package order
 
 import (
+	"app.yhyue.com/moapp/jybase/common"
 	"context"
 	"fmt"
 	"github.com/gogf/gf/v2/database/gdb"
@@ -9,6 +10,7 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 	"jyOrderManager/internal/jyutil"
 	"jyOrderManager/internal/model"
+	"log"
 	"time"
 )
 
@@ -230,3 +232,27 @@ func FenToYuanString(fen int64) string {
 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
+}

internal/logic/order/detail.go

@@ -400,9 +400,20 @@ where edu.dept_id in (%s)`, strings.Join(ids, ",")))
 		}
 
 	}
+	// 如果不是全额回款查询已支付保证金金额是否和订单金额相等 如果相等也展示权限开通按钮
+	var isDepositFullReturn bool
+	if !isReturnStatus {
+		if has, err := HasDepositOperate(ctx, param.OrderCode); !has && err == nil { // 验证保证金是否已经有操作记录
+			if depositPayMoney, err := GetDepositPayMoney(ctx, param.OrderCode); depositPayMoney > 0 && err == nil { // 判断已支付保证金
+				if depositPayMoney == orderMap["pay_money"] {
+					isDepositFullReturn = true
+				}
+			}
+		}
+	}
 	var isSupportOpen bool
 	if autoAndAttribute {
-		if isReturnStatus { //全额回款 是销售本人订单||部门管理员|| 销管&超级管理员
+		if isReturnStatus || isDepositFullReturn { //全额回款 是销售本人订单||部门管理员|| 销管&超级管理员
 			if isAdmin || salespersonEntUserId == userCtx.EntUserId || departmentMap[userCtx.EntUserId] {
 				isSupportOpen = true //是否可以权益开通
 			}

internal/logic/order/redPunch.go

@@ -33,8 +33,9 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 		proceduresMoney int
 	)
 	params.PayMoney = gconv.Int(orderData.Map()["pay_money"])
-
+	reasonList := []string{}
 	for _, param := range params.RedPunch {
+		reason := param.CorrectionReason
 		insertData := map[string]interface{}{
 			"orderCode":        params.OrderCode,
 			"correctionReason": param.CorrectionReason,
@@ -100,19 +101,21 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 			var pMoney int
 			switch {
 			case param.Id > 0:
-				activeData, _ := g.DB().GetOne(ctx, `SELECT final_price+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and detail_id = ?) as final_price FROM jy_order_detail WHERE id = ? and status =1`, params.OrderCode, param.Id, param.Id)
+				activeData, _ := g.DB().GetOne(ctx, `SELECT final_price+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and detail_id = ?) as final_price,product_type FROM jy_order_detail WHERE id = ? and status =1`, params.OrderCode, param.Id, param.Id)
 				if !activeData.IsEmpty() {
 					pMoney = gconv.Int(activeData.Map()["final_price"])
 				}
 				insertData["payMoney"] = param.PayMoney - pMoney
 				params.PayMoney += gconv.Int(insertData["payMoney"])
+				reason = fmt.Sprintf("%v", activeData["product_type"])
 			case param.ActiveCode != "" && param.PayMoney > 0:
-				activeData, _ := g.DB().GetOne(ctx, `SELECT sum(final_price)+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and activity_code = ?) as final_price FROM jy_order_detail WHERE activity_code = ? and order_code = ? and status =1`, params.OrderCode, param.ActiveCode, param.ActiveCode, params.OrderCode)
+				activeData, _ := g.DB().GetOne(ctx, `SELECT sum(final_price)+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode=? and activity_code = ?) as final_price,product_type FROM jy_order_detail WHERE activity_code = ? and order_code = ? and status =1`, params.OrderCode, param.ActiveCode, param.ActiveCode, params.OrderCode)
 				if !activeData.IsEmpty() {
 					pMoney = gconv.Int(activeData.Map()["final_price"])
 				}
 				insertData["payMoney"] = param.PayMoney - pMoney
 				params.PayMoney += gconv.Int(insertData["payMoney"])
+				reason = fmt.Sprintf("%v", activeData["product_type"])
 			case param.Commission > 0:
 				insertData["commission"] = param.Commission - common.IntAll(orderData.Map()["commission"])
 				commission = param.Commission
@@ -125,6 +128,7 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 			//insertData["proceduresMoney"] = param.ProceduresMoney - common.IntAll(orderData.Map()["procedures_money"])
 			insertDataArr = append(insertDataArr, insertData)
 		}
+		reasonList = append(reasonList, reason)
 	}
 	if !isSubject {
 		g.DB().Update(ctx, "contract", map[string]interface{}{"contract_money": params.PayMoney}, map[string]interface{}{"order_code": params.OrderCode})
@@ -215,7 +219,7 @@ func OperateOrderRedPunch(ctx context.Context, params model.OrderRedPunchParams)
 			}
 		}
 		//红冲金额新增销售业绩
-		if err := OrderMoneyMakeRed(ctx, params.OrderCode, int64(params.PayMoney-proceduresMoney-commission)); err != nil {
+		if err := OrderMoneyMakeRed(ctx, params.OrderCode, int64(params.PayMoney-proceduresMoney-commission), strings.Join(reasonList, ",")); err != nil {
 			log.Printf("业绩红冲 %s 业绩变更异常 %v\n", params.OrderCode, err)
 			return err
 		}

internal/logic/order/saleRecord.go

@@ -165,7 +165,7 @@ func SaveOrUpdateSaleMoneyTmp(ctx context.Context, orderCode, createPerson strin
 }
 
 // OrderMoneyMakeRed 订单红冲 销售业绩更改
-func OrderMoneyMakeRed(ctx context.Context, orderCode string, final int64) error {
+func OrderMoneyMakeRed(ctx context.Context, orderCode string, final int64, reason string) error {
 	var (
 		oldTotal                        int64 = 0
 		emptyMoneyRow, notEmptyMoneyRow []map[string]interface{}
@@ -227,7 +227,7 @@ func OrderMoneyMakeRed(ctx context.Context, orderCode string, final int64) error
 		m["create_time"] = nowTime
 		m["statistics_time"] = nowTime
 		m["money"] = newMoney
-		m["change_reason"] = "订单红冲"
+		m["change_reason"] = reason
 		m["change_value"] = newMoney - money
 		if _, err := g.DB().Save(ctx, "order_sale_record", m); err != nil {
 			return errors.Wrap(err, "业绩红冲 插入非空业绩记录异常")

internal/model/orderParams.go

@@ -112,7 +112,9 @@ type (
 		BNKFLW           string                   `json:"BNKFLW"`
 		BNKNAM           string                   `json:"BNKNAM"`
 	}
-
+	OrdersDeleteReturn struct { //回款
+		Id int `p:"username"  v:"required"`
+	}
 	OrderListParams struct { //列表
 		ListSource     int      `json:"listSource"`               //列表来源
 		SearchContent  string   `json:"searchContent,omitempty"`  //订单编号 or  手机号 or 公司名称