workScript/run/orderFlush/main.go

package main

import (
	"app.yhyue.com/moapp/jybase/common"
	"context"
	_ "github.com/gogf/gf/contrib/drivers/mysql/v2"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"strings"
	"workScript/run/orderFlush/product"
)

func main() {
	//FlushReturnPlan(context.Background())
	//FlushReturnTransfer(context.Background())
	//FlushSale(context.Background())
	FlushOrder(context.Background())
}
func FlushOrder(ctx context.Context) error {
	res, err := g.DB().Query(ctx, "SELECT * FROM dataexport_order WHERE product_type=? order by id asc ", "VIP订阅")
	if err != nil {
		return err
	}
	var arr []g.Map
	for i, m := range res.List() {
		if i%1000 == 0 {
			g.Log().Info(ctx, "FlushOrder 进度 %d/%d", i, res.Len())
		}
		var (
			productType        = gconv.String(m["product_type"])
			orderCode          = gconv.String(m["order_code"])
			user_phone         = gconv.String(m["user_phone"])
			user_id            = gconv.String(m["user_id"])
			order_status       = gconv.Int(m["order_status"])
			buy_subject        = gconv.Int(m["buy_subject"])
			vip_type           = gconv.Int(m["vip_type"])
			original_price     = gconv.Int(m["original_price"])
			order_money        = gconv.Int(m["order_money"])
			pay_money          = gconv.Int(m["pay_money"])
			vip_starttime      = gconv.String(m["vip_starttime"])
			vip_endtime        = gconv.String(m["vip_endtime"])
			is_backstage_order = gconv.Int(m["is_backstage_order"])
			filter             = gconv.String(m["filter"])
			buy_count          = gconv.Int(m["buy_count"])
		)
		var (
			newData = g.Map{
				"order_code":   orderCode,
				"product_type": productType,
				"phone":        user_phone,
				"filter":       filter,
				"user_id":      user_id,
				"service_type": vip_type,
				"is_master":    1,
			}
			product_code    string
			newFilterMap    g.Map
			is_service_open int
			service_type    int
		)
		if vip_starttime != "" {
			newData["service_starttime"] = vip_starttime
		}
		if vip_endtime != "" {
			newData["service_endtime"] = vip_endtime
		}

		if is_backstage_order == 1 {
			newData["original_price"] = order_money
			newData["final_price"] = pay_money
		} else {
			newData["original_price"] = original_price
			newData["final_price"] = order_money
		}
		if order_status == 1 {
			is_service_open = 1
			if vip_starttime != "" {
				if strings.Index(vip_starttime, "2099") > -1 {
					is_service_open = 0
				}
			}
		}

		switch productType {
		case "VIP订阅":
			newFilterMap, product_code, err = product.GetVipFilter(filter, buy_count, buy_subject)
			if err != nil {
				g.Log().Error(ctx, "格式化超级订阅订单%s 异常%v", orderCode, err.Error())
			}
			service_type = vip_type + 1
		case "大会员", "大会员-子账号", "大会员-AI中标预测包", "大会员-招标文件解读", "大会员-补充包":
			newFilterMap, product_code, service_type, err = product.GetBigFilter(m)
		case "历史数据", "结构化数据":
			var (
				data_spec    = gconv.String(m["data_spec"])
				download_url = gconv.String(m["download_url"])
				filter_id    = gconv.String(m["filter_id"])
				data_count   = gconv.Int(m["data_count"])
			)
			if productType == "历史数据" {
				product_code = "lssj001"
			} else {
				product_code = "jghsj001"
			}
			newFilterMap, product_code, err = product.GetDataExportFilter(data_spec, filter_id, download_url, data_count, is_backstage_order)
			if err != nil {
				g.Log().Error(ctx, "格式化历史数据订单%s 异常%v", orderCode, err.Error())
			}
		case "剑鱼币":
			product_code = "jyb001"
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				newFilterMap = g.Map{
					"num":    filterMap["score"],
					"source": "pc",
				}
			}
		case "数据流量包":
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				pType := gconv.Int(filterMap["pType"])
				product_code = common.If(pType == 1, "sjllb002", "sjllb001").(string)
				newFilterMap = g.Map{
					"num":   filterMap["pNum"],
					"pType": pType,
				}
			}
		case "省份订阅包":
			service_type = vip_type + 1
			product_code = "sfdyb001"
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				var (
					unit   = gconv.Int(filterMap["cycleunit"])
					num    = gconv.Int(filterMap["num"])
					OldNum = gconv.Int(filterMap["OldNum"])
				)
				newFilterMap = g.Map{
					"buy_cycle":      1,
					"buyerAreaCount": num - OldNum,
					"finalAreaCount": num,
					"buy_type": func() int {
						switch unit { //1月 2季 3年
						case 1:
							return 2
						case 2:
							return 4
						default:
							return unit
						}
					}(), //购买周期 类型 1天 2月 3年 4季度
				}
			}
		case "附件下载包":
			product_code = "fjxzb001"
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				num := gconv.Int(filterMap["num"])
				newFilterMap = g.Map{
					"num": num,
				}
			}
		case "采购单位画像包":
			product_code = "cgdwhxb001"
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				num := gconv.Int(filterMap["num"])

				newFilterMap = g.Map{
					"num": num,
				}
			}
		case "剑鱼文库会员":
			service_type = vip_type + 1
			product_code = "jywkhy001"
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				cycleunit := gconv.Int(filterMap["cycleunit"])
				cyclecount := gconv.Int(filterMap["cyclecount"])

				newFilterMap = g.Map{
					"buy_cycle": cyclecount,
					"buy_type": func() int {
						switch cycleunit { //(1:年 2:月 3:天 4:季)
						case 1:
							return 3
						case 3:
							return 1
						default:
							return cycleunit
						}
					}(),
				}
			}
		case "企业中标分析报告下载包", "业主采购分析报告下载包", "市场分析定制报告下载包":
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				switch gconv.Int(filterMap["pType"]) {
				case 1:
					product_code = "zbqyxzb001"
				case 2:
					product_code = "yzcgxzb001"
				case 3:
					product_code = "scfxxzb001"
				}
				newFilterMap = g.Map{
					"num": filterMap["pNum"],
				}
			}
		case "中标必听课", "数据报告", "招投标课程":
			newFilterMap = gconv.Map(filter)
		case "企业商机管理", "打赏", "数据文件", "3A信用认证", "ISO体系认证", "权益码", "课程分销", "标书制作", "线下课程培训":
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				if productType == "企业商机管理" && is_backstage_order == 0 {
					newFilterMap = filterMap
				} else {
					newFilterMap = g.Map{
						"remark": filterMap["remark"],
					}
				}
			}
		case "广告":
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				newFilterMap = g.Map{
					"remark":   filterMap["remark"],
					"adSource": filterMap["adSource"],
				}
			}
		case "招标文件解读":
			if filterMap := gconv.Map(filter); filterMap != nil && len(filterMap) > 0 {
				newFilterMap = g.Map{
					"count": filterMap["count"],
				}
			}
		default:
			newFilterMap = gconv.Map(filter)
		}
		if product_code == "" {
			product_code = codeMapping[productType]
		}
		newData["filter"] = gconv.String(newFilterMap)
		newData["product_code"] = product_code
		newData["is_service_open"] = is_service_open
		newData["service_type"] = service_type

		arr = append(arr, newData)

		if len(arr) > 500 {
			SaveToDB(ctx, arr)
			arr = []g.Map{}
		}
	}
	if len(arr) > 0 {
		SaveToDB(ctx, arr)
	}
	g.Log().Info(ctx, "FlushOrder 已完成")
	return nil
}

var codeMapping = map[string]string{
	"结构化数据":   "jghsj001",
	"3A信用认证":  "3axyrz001",
	"人脉管理":    "rmgl001",
	"阳光采购":    "ygcg001",
	"企业商机管理":  "qysjgl001",
	"医械通":     "xyt001",
	"物业数字化营销": "wyszhyx001",
	"运营商专版":   "yyszb001",
	"ISO体系认证": "iostxrz001",
	"广告":      "gg001",
	"打赏":      "ds001",
	"数据文件":    "sjwn001",
	"权益码":     "qym001",
	"标书制作":    "bszz001",
	"线下课程培训":  "xskcpx001",
	"课程分销":    "kcfx001",
	"中标必听课":   "zbbtk001",
	"数据报告":    "sjbg001",
}

func SaveToDB(ctx context.Context, data []g.Map) error {
	_, err := g.DB("jianyu2").Save(ctx, "jy_order_detail", data, 100)
	if err != nil {
		g.Log().Error(ctx, "批量插入异常 %s", err.Error())
		return err
	}
	return nil
}