jyOrderManager/internal/logic/order/detail.go

package order

import (
	"app.yhyue.com/moapp/jybase/common"
	"context"
	"fmt"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"jyOrderManager/internal/jyutil"
	"jyOrderManager/internal/logic/user"
	"jyOrderManager/internal/model"
	"log"
	"strings"
	"time"
)

var (
	StampedInterest, SaleChangePower, SaleChangeReason []string
)

func init() {
	StampedInterest = g.Cfg().MustGet(context.Background(), "stampedInterest").Strings()
	SaleChangePower = g.Cfg().MustGet(context.Background(), "saleChangePower").Strings()
	SaleChangeReason = g.Cfg().MustGet(context.Background(), "saleChangeReason").Strings()
}

func Detail(ctx context.Context, param model.OrderDetailParams) (map[string]interface{}, error) {
	result := make(map[string]interface{})
	//订单 暂无备注字段
	orderData, err := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT d.*,d.pay_money+(select IFNULL(sum(payMoney),0) as return_money from moneyCorrection where orderCode='%s') as pay_money,(select a.item_name AS order_parent_name from dict_item a where  a.item_code=d.order_channel ) AS order_channel_new FROM  dataexport_order d WHERE order_code ='%s' `, param.OrderCode, param.OrderCode))
	if err != nil || orderData.IsEmpty() {
		return nil, err
	}
	orderMap := orderData.Map()
	payWay := gconv.String(orderData.Map()["pay_way"])
	switch {
	case strings.Contains(payWay, "wx"):
		orderMap["pay_way"] = "微信"
	case strings.Contains(payWay, "ali"):
		orderMap["pay_way"] = "支付宝"
	case strings.Contains(payWay, "trial"):
		orderMap["pay_way"] = "其他"
	case strings.Contains(payWay, "transferAccounts"):
		orderMap["pay_way"] = "对公转账"
	case strings.Contains(payWay, "测试使用"):
		orderMap["pay_way"] = "测试使用"
	}
	orderMap["pure_amount"] = common.If(gconv.Int(orderMap["pay_money"])-gconv.Int(orderMap["commission"]) > 0, gconv.Int(orderMap["pay_money"])-gconv.Int(orderMap["commission"]), 0)

	//产品
	productData, err := g.DB().Query(ctx, fmt.Sprintf(`SELECT * FROM  jy_order_detail WHERE order_code =%s `, param.OrderCode))
	var productArr []map[string]interface{}
	if err != nil || productData.IsEmpty() {
		return nil, err
	}
	for _, m := range productData.List() {
		if activityCode := gconv.String(m["activity_code"]); activityCode != "" {
			activityData, err := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT * FROM  jy_product_activity WHERE code ='%s' `, activityCode))
			if err == nil && !activityData.IsEmpty() {
				m["activityName"] = gconv.String(activityData.Map()["name"])
			}
		}
		productItem, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT jpi.name,jpc.auto,jpc.code FROM jy_product_item jpi
INNER JOIN jy_product_class jpc on jpi.product_class_id = jpc.id WHERE jpi.code = '%s'`, gconv.String(m["product_code"])))
		if !productItem.IsEmpty() {
			m["productName"] = productItem.Map()["name"]
			m["productItemCode"] = productItem.Map()["code"]
			m["auto"] = productItem.Map()["auto"]
		} else {
			m["productName"] = productItem.Map()["product_type"]
		}

		if gconv.String(m["product_type"]) == "大会员" && gconv.Int(gconv.Map(m["filter"])["comboId"]) == 0 {
			supMap := make(map[string]bool)
			for _, s := range gconv.Strings(gconv.Map(m["filter"])["supServiceIds"]) {
				supMap[s] = true
			}
			var ids []string
			serviceIds := gconv.Strings(gconv.Map(m["filter"])["serviceIds"])
			for _, id := range serviceIds {
				ids = append(serviceIds, gconv.String(id))
			}
			bigService, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT id,s_name FROM bigmember_service WHERE id in (%s) order by id`, strings.Join(ids, ",")))
			if !bigService.IsEmpty() {
				var (
					bigServiceNames    []string
					supBigServiceNames []string
				)
				for _, m1 := range bigService.List() {
					switch gconv.Int(m1["id"]) {
					case 1:
						m1["s_name"] = "基础服务"
					case 30051, 30052, 30053: //0分报告过滤
						continue
					}
					if supMap[gconv.String(m1["id"])] {
						supBigServiceNames = append(supBigServiceNames, gconv.String(m1["s_name"]))
					} else {
						bigServiceNames = append(bigServiceNames, gconv.String(m1["s_name"]))
					}
				}
				if len(supBigServiceNames) > 0 {
					m["bigServiceNames"] = fmt.Sprintf("[补充权益]: %s ;[原已购权益]:%s", strings.Join(supBigServiceNames, "、"), strings.Join(bigServiceNames, "、"))
				} else {
					m["bigServiceNames"] = strings.Join(bigServiceNames, "、")
				}
			}
		}

		if linkedDetailId := gconv.String(m["linked_detail_id"]); linkedDetailId != "" && linkedDetailId != "0" {
			var orderArr []map[string]interface{}
			//关联订单
			if gconv.String(m["product_type"]) != "大会员" && gconv.String(m["product_type"]) != "VIP订阅" {
				if linkedOrder := user.SpecialService(ctx, common.InterfaceToStr(orderData.Map()["user_id"]), gconv.String(m["product_type"])); linkedOrder != nil {
					m["linkedOrder"] = linkedOrder[0]
				}
			} else {
				switch gconv.Int(orderData.Map()["buy_subject"]) {
				case 1:
					userData, _ := jyutil.MG.DB().FindOne("user", map[string]interface{}{
						"$or": []map[string]interface{}{
							{"s_phone": orderData.Map()["user_phone"]},
							{"s_m_phone": orderData.Map()["user_phone"]},
						},
					})
					orderProduct, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT  b.id,b.service_type,b.order_code,c.create_time  FROM jy_order_detail  a
INNER JOIN dataexport_order b on a.order_code = b.order_code
WHERE a.status = 1 and a.is_service_open = 1 and b.user_id = '%s' and a.product_type like '%s' ORDER BY b.create_time desc `, gconv.String(m["user_id"]), common.If(gconv.String(m["product_type"]) == "VIP订阅", "%VIP订阅%", "%大会员%")))
					if !orderData.IsEmpty() {
						for _, m2 := range orderProduct.List() {
							orderArr = append(orderArr, map[string]interface{}{
								"order_code":      m2["order_code"],
								"create_time":     m2["create_time"],
								"service_type":    m2["service_type"],
								"order_detail_id": m2["id"],
							})
						}
					}
					if userData != nil && len(*userData) > 0 {
						var (
							areaCount, paySubNum int
							endTime              string
						)
						switch gconv.String(m["product_type"]) {
						case "VIP订阅":
							vipInfo := common.ObjToMap((*userData)["o_vipjy"])
							buySet := common.ObjToMap((*vipInfo)["o_buyset"])
							areaCount = common.IntAll((*buySet)["areacount"])
							//判断是新版超级订阅还是老版超级订阅
							if common.IntAll((*buySet)["upgrade"]) == 1 {
								//newVip = true
							}
							endTime = time.Unix(common.Int64All((*userData)["l_vip_endtime"]), 0).Format("2006-01-02 15:04:05")
						case "大会员":
							bigStart := common.Int64All((*userData)["i_member_starttime"])
							bigEnd := common.Int64All((*userData)["i_member_endtime"])
							memberStatus := common.IntAll((*userData)["i_member_status"])
							if memberJyMap, ok1 := ((*userData)["o_member_jy"]).(map[string]interface{}); ok1 {
								areaCount = common.IntAll(memberJyMap["i_areacount"])
							}
							if bigStart >= time.Now().Unix() {
								endTime = time.Unix(bigEnd, 0).Format("2006-01-02 15:04:05")
							} else if (time.Now().Unix() < bigEnd && memberStatus > 0) || bigStart >= time.Now().Unix() {
								endTime = time.Unix(bigEnd, 0).Format("2006-01-02 15:04:05")
							}
							paySubNum = common.IntAll((*userData)["i_pay_sub_num"]) + common.IntAll((*userData)["i_free_sub_num"]) + 1
						}
						m["linkedOrder"] = map[string]interface{}{
							"name":           gconv.String(m["product_type"]), //产品名称
							"serviceEndTime": endTime,                         //服务结束时间
							"empowerCount":   paySubNum,                       //服务授权数
							"provinceCount":  areaCount,                       //订阅省份
							"buySubject":     1,                               //个体
							"orderArr":       orderArr,                        //关联订单
						}
					}
				case 2:
					entService, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT a.id,a.product_type,a.end_time,a.start_time,a.empower_count,a.province_count FROM entniche_wait_empower a 
         INNER JOIN  entniche_order b on a.id = b.wait_empower_id
WHERE b.order_detail_id=%s`, linkedDetailId))
					if !entService.IsEmpty() {
						entOrderService, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT jod.*,do.create_time
FROM jy_order_detail jod
INNER JOIN entniche_order eo ON jod.id = eo.order_detail_id
INNER JOIN dataexport_order do on jod.order_code= do.order_code
WHERE eo.wait_empower_id = %s and jod.is_service_open =1 ORDER BY do.create_time desc`, gconv.String(entService.Map()["id"])))
						if !entOrderService.IsEmpty() {
							for _, m2 := range entOrderService.List() {
								orderArr = append(orderArr, map[string]interface{}{
									"order_code":      m2["order_code"],
									"create_time":     m2["create_time"],
									"service_type":    m2["service_type"],
									"order_detail_id": m2["id"],
								})
							}
							m["linkedOrder"] = map[string]interface{}{
								"name":             gconv.String(entService.Map()["product_type"]),   //产品名称
								"serviceEndTime":   gconv.String(entService.Map()["end_time"]),       //服务结束时间
								"serviceStartTime": gconv.String(entService.Map()["start_time"]),     //服务开始时间
								"empowerCount":     gconv.String(entService.Map()["empower_count"]),  //服务授权数
								"provinceCount":    gconv.String(entService.Map()["province_count"]), //订阅省份
								"buySubject":       2,                                                //个体
								"orderArr":         orderArr,                                         //关联订单
							}
						}
					}
				}
			}
			switch gconv.String(m["product_type"]) {
			case "大会员":
				BigFilterFmt(m)
			case "VIP订阅":
				VipFilterFmt(m)
			}

		}
		productArr = append(productArr, m)
	}
	result["productData"] = productArr
	//对公转账审核记录
	orderTransfer, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT * FROM jy_order_transfer WHERE order_code = '%s' order by create_time desc `, param.OrderCode))
	if !orderTransfer.IsEmpty() {
		result["orderTransfer"] = orderTransfer.List()
	}

	var (
		//佣金 手续费 合同金额 企业
		isCommission, isProceduresMoney, isCash, isEnt bool
		newEntName                                     string
		moneyCorrectionArr                             []map[string]interface{}
	)
	//红冲
	redPunch := make(map[string]interface{})
	subject := orderData.Map()["return_commpany"]
	moneyCorrectionData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT * FROM  moneyCorrection WHERE orderCode =%s `, param.OrderCode))
	if !moneyCorrectionData.IsEmpty() {
		for _, m := range moneyCorrectionData.List() {
			if common.InterfaceToStr(m["redType"]) == "金额红冲" {
				if common.IntAll(m["payMoney"]) != 0 {
					isCash = true
				}
				if common.IntAll(m["commission"]) != 0 {
					isCommission = true
				}
				if common.IntAll(m["proceduresMoney"]) != 0 {
					isProceduresMoney = true
				}
				if common.InterfaceToStr(m["signingSubject"]) == "" {
					m["signingSubject"] = subject
				}
			} else if strings.Contains(common.InterfaceToStr(m["redType"]), "主体") {
				isEnt = true
				if common.InterfaceToStr(m["newSigningSubject"]) != "" {
					m["signingSubject"] = m["newSigningSubject"]
				}
				if newSigningSubject := common.InterfaceToStr(m["newSigningSubject"]); newSigningSubject != "" && newEntName == "" {
					newEntName = newSigningSubject
				}
			}
			moneyCorrectionArr = append(moneyCorrectionArr, m)
		}
		if newEntName != "" {
			orderMap["return_commpany"] = newEntName
		}
	}
	result["orderData"] = orderMap
	redPunch["moneyCorrectionData"] = moneyCorrectionArr
	redPunch["isUpCash"] = isCash
	redPunch["isUpCommission"] = isCommission
	redPunch["isUpProceduresMoney"] = isProceduresMoney
	redPunch["isUpEnt"] = isEnt
	result["redPunchData"] = redPunch
	//合同
	contractData, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT * FROM  contract WHERE order_code =%s `, param.OrderCode))
	if !contractData.IsEmpty() {
		contractMap := contractData.Map()
		// 合同信息
		if contractMap["contract_file_url"] != nil && len(contractMap["contract_file_url"].(string)) > 0 {
			index_ := strings.LastIndex(contractMap["contract_file_url"].(string), "/")
			if index_ != -1 {
				contractMap["contract_file_name"] = contractMap["contract_file_url"].(string)[index_+1:]
			}
		}
		result["contractRes"] = contractMap
	}
	// 回款信息
	var (
		returnMoney, plantMoney int
		returnArr               []map[string]interface{}
	)

	returnInfo, _ := g.DB().Query(ctx, fmt.Sprintf("SELECT * from return_money_record  WHERE order_code=%s and  state=1", param.OrderCode))
	// 回款交易详情列表
	if !returnInfo.IsEmpty() {
		for _, d := range returnInfo.List() {
			returnMoney += gconv.Int(d["return_money"])
			if d["return_voucher_url"] != nil && len(d["return_voucher_url"].(string)) > 0 {
				index_ := strings.LastIndex(d["return_voucher_url"].(string), "/")
				if index_ != -1 {
					d["return_voucher_name"] = d["return_voucher_url"].(string)[index_+1:]
				}
			}
			returnArr = append(returnArr, d)
		}
	}
	result["returnRes"] = map[string]interface{}{
		"returnMoney":    returnMoney,
		"remainingMoney": gconv.Int(orderData.Map()["pay_money"]) - returnMoney,
		"returnInfo":     returnArr,
	}
	//回款计划
	returnMoneyPlant, err := g.DB().GetOne(ctx, "SELECT * from return_money_plant where order_code = ? order by create_time desc", param.OrderCode)
	if !returnMoneyPlant.IsEmpty() {
		for _, m2 := range gconv.Maps(returnMoneyPlant.Map()["plantList"]) {
			if gconv.String(m2["code"]) == "合计" {
				plantMoney = gconv.Int(m2["money"])
			}
		}
	}
	result["returnMoneyPlant"] = map[string]interface{}{
		"list":        returnMoneyPlant.Map(),
		"returnMoney": returnMoney,
		"plantMoney":  plantMoney,
	}
	//退款
	var refundMoney int
	refundData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT rr.*,jpi.name FROM  refund_record rr
LEFT JOIN jy_order_detail  jod on rr.refund_detail_id = jod.id
LEFT JOIN jy_product_item jpi on jod.product_code = jpi.code
WHERE rr.order_code =%s`, param.OrderCode))
	if !refundData.IsEmpty() {
		for _, datum := range refundData.List() {
			refundMoney += gconv.Int(datum["refund_money"])
		}
	}
	result["refundRes"] = map[string]interface{}{
		"refundMoney":    refundMoney,
		"remainingMoney": gconv.Int(orderData.Map()["pay_money"]) - refundMoney,
		"refundInfo":     refundData.List(),
	}
	//审核轨迹详情
	recordsData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT * FROM  audit_records WHERE order_code =%s and audit_type = 2 order by create_time desc `, param.OrderCode))
	if !recordsData.IsEmpty() {
		result["audit"] = recordsData.List()
	}

	//盖章记录
	sealData, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT  id,stamp_time,create_time,salesman_id,applicant_id FROM  order_seal WHERE order_code = '%s' and status = 0 order by create_time desc `, param.OrderCode))
	if !sealData.IsEmpty() {
		for _, m := range sealData.List() {
			var salesmanName, applicantName string
			if salesmanId := gconv.String(m["salesman_id"]); salesmanId != "" {
				salesman, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT GROUP_CONCAT(name SEPARATOR ',') as name FROM entniche_user  WHERE id IN (%s)`, salesmanId))
				if !salesman.IsEmpty() {
					salesmanName = gconv.String(salesman.Map()["name"])
				}
			}
			if applicantId := gconv.String(m["applicant_id"]); applicantId != "" {
				applicant, _ := g.DB().GetOne(ctx, fmt.Sprintf(`SELECT GROUP_CONCAT(username SEPARATOR ',') as name FROM entniche_user  WHERE id IN (%s)`, applicantId))
				if !applicant.IsEmpty() {
					applicantName = gconv.String(applicant.Map()["name"])
				}
			}
			m["salesperson_name"] = salesmanName
			m["applicant_name"] = applicantName
		}
		result["sealArr"] = sealData.List()
	}
	//配置盖章权益人
	result["stampedInterest"] = StampedInterest
	var saleData = map[string]interface{}{
		"saleEdit": SaleChangePower, //销售业绩变更展示
	}
	saleRes, _ := g.DB().Query(ctx, fmt.Sprintf("SELECT d.*,(select  CONCAT_WS('/', a.parent_name, a.item_name) AS order_parent_name from dict_item a where  a.item_code=d.distribution_channel ) AS order_channel_new FROM order_sale_record d WHERE d.ordercode='%s' and d.state in (1,-1,2) order by d.create_time asc", param.OrderCode))
	if !saleRes.IsEmpty() {
		var (
			//最终业绩
			finalArr      []map[string]interface{}
			finalShowTime string
			//记录
			record, recordTmp []map[string]interface{}
			repeatMapping     = map[string]bool{}
			zeroChannel       = map[string]bool{}
			//
		)
		for _, m := range saleRes.List() {
			var (
				status  = gconv.Int64(m["state"])
				money   = gconv.Int64(m["money"])
				salerId = gconv.Int64(m["saler_Id"])
			)
			if (status == 1 || status == 2) && money >= 0 { //最终合算
				if finalShowTime == "" {
					finalShowTime = gconv.String(m["statistics_time"])
				}
				finalArr = append(finalArr, map[string]interface{}{
					"id":                   salerId,
					"name":                 m["saler_name"],
					"saler_dept":           m["saler_dept"],
					"distribution_channel": m["distribution_channel"],
					"order_channel_new":    m["order_channel_new"],
					"money":                money,
				})
			}
			if status == 2 {
				continue
			}
			if gconv.Int(m["change_value"]) == 0 || gconv.Int(m["money"]) == 0 {
				zeroChannelKey := fmt.Sprintf("%d_%s", salerId, gconv.String(m["distribution_channel"]))
				if zeroChannel[zeroChannelKey] {
					continue
				}
				zeroChannel[zeroChannelKey] = true
			}
			key := fmt.Sprintf("%d_%s", salerId, gconv.String(m["statistics_time"]))
			if repeatMapping[key] {
				continue
			}
			repeatMapping[key] = true
			recordTmp = append(recordTmp, map[string]interface{}{
				"saler_dept":           m["saler_dept"],
				"name":                 m["saler_name"],
				"change_value":         m["change_value"],
				"statistics_time":      m["statistics_time"],
				"createtime":           m["create_time"],
				"operator":             m["operator"],
				"change_reason":        m["change_reason"],
				"distribution_channel": m["distribution_channel"],
				"order_channel_new":    m["order_channel_new"],
				"money":                money,
			})
		}
		for i := len(recordTmp) - 1; i >= 0; i-- {
			record = append(record, recordTmp[i])
		}

		saleData["saleFinal"] = map[string]interface{}{
			"list": finalArr,
			"time": finalShowTime,
		}
		saleData["reason"] = SaleChangeReason
		saleData["saleRecord"] = record
		result["saleDataRes"] = saleData
	}
	//发票信息
	var invoiceMoney int
	invoiceRes, _ := g.DB().Query(ctx, fmt.Sprintf(`SELECT *,(
  SELECT count(1) as count FROM invoice b WHERE b.order_code = a.order_code and  b.only_Identifying is not null and b.only_Identifying = a.only_Identifying
) as isChanged FROM invoice a WHERE order_code = '%s' and invoice_status != -2 and invoice_variety is not null and invoice_variety is not null and invoice_variety not  LIKE '%s' ORDER BY create_time DESC`, param.OrderCode, "%纸质%"))
	if !invoiceRes.IsEmpty() {
		for _, datum := range invoiceRes.List() {
			invoiceMoney += gconv.Int(datum["invoice_money"])
		}
	}
	result["invoiceData"] = map[string]interface{}{
		"invoiceMoney":   invoiceMoney,
		"remainingMoney": gconv.Int(orderData.Map()["pay_money"]) - invoiceMoney,
		"invoiceInfo":    invoiceRes.List(),
	}
	return result, nil
}

func BigFilterFmt(m map[string]interface{}) {
	var bigFilter model.JyBigProductFilter
	err := gconv.Struct(m["filter"], bigFilter)
	if err != nil {
		log.Println("filter err", err)
		return
	}
	productType := "大会员"
	switch bigFilter.ComboId {
	case 1:
		productType += "专家版"
	case 2:
		productType += "智慧版"
	case 3:
		productType += "商机版"
	case 4:
		productType += "试用版"
	case 6:
		productType += "商机版2.0"
	case 7:
		productType += "专家版2.0"
	default:
		//自定义获取每个服务名称
		productType += "自定义"
		if len(bigFilter.SupServiceIds) == 0 {
			m["all_service_name"] = ServiceName(bigFilter.ServiceIds)
		}
	}
	m["product_type"] = productType
	if len(bigFilter.SupServiceIds) > 0 { //补充服务 区分升级前 升级后分类
		var preUpgradeService []string
		//基础服务过滤
		for _, id := range bigFilter.ServiceIds {
			var isSup bool
			for _, serviceId := range bigFilter.SupServiceIds {
				if id == serviceId {
					isSup = true
					break
				}
			}
			if !isSup {
				preUpgradeService = append(preUpgradeService, id)
			}
		}
		if bigFilter.ComboId == 0 { //自定义获取下老服务名称 套餐不展示
			m["old_service_name"] = ServiceName(preUpgradeService)
		}
		m["new_service_name"] = ServiceName(bigFilter.SupServiceIds)
	}

}

func ServiceName(id []string) (serviceName []string) {
	bigService, _ := g.DB().Query(context.Background(), fmt.Sprintf(`SELECT id,s_new_name,i_class,s_count_year FROM bigmember_service WHERE id in (%s) ORDER BY i_class ASC,i_sort ASC`, strings.Join(id, ",")))
	if !bigService.IsEmpty() {
		for _, m2 := range bigService.List() {
			switch m2["i_class"] {
			case 1:
				serviceName = append(serviceName, "基础服务")
			case 2:
				serviceName = append(serviceName, fmt.Sprintf("%s%s", m2["s_new_name"],
					common.If(gconv.Int(m2["s_count_year"]) > 0, fmt.Sprintf("(%s)个", gconv.String(m2["s_count_year"])), "")))
			case 3:
				serviceName = append(serviceName, fmt.Sprintf("%s%s", m2["s_new_name"],
					common.If(gconv.Int(m2["s_count_year"]) > 0, fmt.Sprintf("(%s)份", gconv.String(m2["s_count_year"])), "")))
			case 4:
				serviceName = append(serviceName, fmt.Sprintf("%s%s", m2["s_new_name"],
					common.If(gconv.Int(m2["s_count_year"]) > 0, fmt.Sprintf(":%s/天", gconv.String(m2["s_count_year"])), "")))
			}
		}
	}
	return
}

func VipFilterFmt(m map[string]interface{}) {
	//升级订阅增购省份多少个
	var vipFilter model.VipCycleFilter
	gconv.Struct(m["filter"], vipFilter)
	productItem, _ := g.DB().GetOne(context.Background(), fmt.Sprintf(`SELECT * FROM jy_product_item WHERE code  = '%s'`, gconv.String(m["product_code"])))
	if !productItem.IsEmpty() {
		if gconv.Int(productItem.Map()["unit_num"]) < vipFilter.FinalAreaCount {
			if vipFilter.FinalAreaCount == -1 || vipFilter.FinalAreaCount > 16 {
				m["upgradesNumber"] = 16 - gconv.Int(productItem.Map()["unit_num"])
			}
		}
	}
}