package order

import (
	"config"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"math"
	"mongodb"
	m "mongodb"
	"net/http"
	qutil "qfw/util"
	"qfw/util/redis"
	"qfw/util/usercenter"
	"regexp"
	"strings"
	"time"
	"util"

	"go.mongodb.org/mongo-driver/bson"
)

const (
	NewOther                  = "newother"
	PowerCacheDb              = "other"
	PowerCacheKey             = "bigmember_power_3_%s"
	IsGetUserBaseInfoRedisKey = "baseinfo_%s"
	RedisMenuKeyPC            = "jy_workdesktopmenu_10000_PC_menu1_%s"  //剑鱼appid：10000
	RedisMenuKeyWX            = "jy_workdesktopmenu_10000_WX_menu1_%s"  //剑鱼appid：10000
	RedisMenuKeyAPP           = "jy_workdesktopmenu_10000_APP_menu1_%s" //剑鱼appid：10000
	UserPowerRedisKey         = "jy_userpowerredis_10000_%d_%s"         //工作桌面 用户功能缓存（类似bigmember_power_3_%s）

)

// 插入合同表信息和订单表信息
func createOtherOrder(param *CreateOtherOrderParams, code string) bool {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	filter_map := map[string]interface{}{
		"source":         "qmx",
		"product":        param.Product,
		"remark":         param.Remark,
		"contractStatus": contractStatus,
	}
	s_m_openid := ""
	s_nickname := ""
	price := 0
	packNum := 0
	if param.ProductType == "广告" {
		filter_map["adSource"] = AdSourceMap[param.AdSource]
	} else if param.ProductType == "数据流量包" {
		userData, ok := util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
		if ok && userData != nil && len(*userData) > 0 {
			if (*userData)["s_m_openid"] != nil {
				s_m_openid = fmt.Sprint((*userData)["s_m_openid"])
			} else if (*userData)["s_nickname"] != nil {
				s_nickname = fmt.Sprint((*userData)["s_nickname"])
			}
		}
		//根据id查询流量包价格
		packDetail, err := util.JyDataExportPack.GetPackDetailById(param.PackId)
		if err != nil {
			log.Println(err)
		}
		filter_map = map[string]interface{}{
			"pType":     packDetail.PackType,
			"pNum":      packDetail.PackNum,
			"validYear": packDetail.ValidYear,
			"price":     packDetail.Price,
			"badge":     "give",
		}
		if param.OrderChannel == "d03" {
			filter_map["badge"] = ""
		}
		price = packDetail.Price
		packNum = packDetail.PackNum
	}

	if param.DataType == "1" {
		param.DataType = "高级字段包"
	} else if param.DataType == "2" {
		param.DataType = "标准字段包"
	} else if param.DataType == "3" {
		param.DataType = "自定义字段包"
	}
	if param.OrderChannel == "d03" {
		filter_map["source"] = ""
		filter_map["canInvoice"] = false
	}
	return util.JysqlDB.ExecTx("创建其他订单生成订单信息和合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(filter_map)
		insertData := map[string]interface{}{
			"user_phone":           param.Phone,
			"product_type":         param.ProductType,
			"salesperson":          param.SalesPerson,
			"salesperson_id":       param.SalesPersonId, // 销售人员在剑鱼后台的id
			"filter":               string(filter),
			"order_code":           code,
			"create_time":          param.CreateTime, // 当前时间
			"prepay_time":          qutil.NowFormat(qutil.Date_Full_Layout),
			"create_person":        param.CreatePerson, // 创建人
			"order_money":          param.OrderMoney,
			"pay_money":            param.ContractMoney,
			"data_count":           param.DataNum,
			"data_spec":            param.DataType,
			"vip_starttime":        param.StartTime,
			"is_backstage_order":   1,
			"billingMode":          param.ChargeMode,
			"vip_endtime":          param.EndTime,
			"order_status":         param.OrderStatus,
			"user_id":              "",
			"return_status":        qutil.If(param.ContractMoney == 0, 1, 0),
			"refund_status":        0,
			"company_name":         param.CompanyName,
			"sale_time":            qutil.If(param.SaleTime == "", nil, param.SaleTime), // 业务统计时间
			"commission":           param.Commission,                                    // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":     param.ProceduresMoney,                               // 手续费 2021-12-29 订单优化需求新增字段
			"distribution_channel": param.SalesChannel,
			"order_channel":        param.OrderChannel,
			"out_trade_no":         param.OutTradeNo,
			"signing_subject":      param.PaybackCompany,
			"audit_status":         param.AuditStatus,
			"pay_way":              param.PayType,
			"saleDep":              param.SaleDep,
		}
		if param.BuySubject == "2" {
			insertData["buy_subject"] = 2
			entId, err, userPositionId := AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, param.UserId)
			if err != nil {
				log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
				return false
			} else {
				if entId != 0 {
					insertData["ent_id"] = entId
					param.UserId = fmt.Sprint(qutil.Int64All(userPositionId))
					insertData["user_id"] = userPositionId
				}
			}
		} else {
			insertData["buy_subject"] = 1
		}
		insertData["buy_count"] = param.BuyCount

		if param.Pay_time != "" {
			insertData["pay_time"] = param.Pay_time
		}
		if param.ProductType == "历史数据" {
			insertData["service_status"] = 1
		} else if param.ProductType == "数据流量包" || param.ProductType == "数据文件" {
			insertData["original_price"] = param.OrderMoney
			insertData["user_id"] = param.UserId
			insertData["user_nickname"] = s_nickname
			insertData["user_openid"] = s_m_openid
			if param.OrderChannel == "d03" {
				insertData["order_money"] = param.OrderMoney
				insertData["discount_price"] = 0
			} else {
				insertData["order_money"] = 0
				insertData["discount_price"] = price
			}
		}
		contractData := map[string]interface{}{
			"order_code":              code,
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}
		if param.ProductType == "广告" || param.ProductType == "线下课程培训" ||
			param.ProductType == "课程分销" || param.ProductType == "标书制作" || param.ProductType == "打赏" ||
			param.ProductType == "ISO体系认证" || param.ProductType == "3A信用认证" || param.ProductType == "权益码" {
			delete(insertData, "data_count")
			delete(insertData, "data_spec")

		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.StartTime == "" {
			delete(insertData, "vip_starttime")
		}
		if param.EndTime == "" {
			delete(insertData, "vip_endtime")
		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		//订单中台
		if param.ProductType == "数据流量包" || param.ProductType == "数据文件" {
			if param.OrderChannel == "d03" {
				filter_map["badge"] = ""
				delete(insertData, "return_status")
			}
		}
		ok_1 := util.JysqlDB.InsertByTx(tx, "dataexport_order", insertData)
		//资源中台
		var ok_2 int64
		ok_3 := true
		if param.ProductType != "数据流量包" {
			ok_2 = util.JysqlDB.InsertByTx(tx, "contract", contractData)
		} else {
			//待转化为时间戳的字符串 注意 这里的小时和分钟还要秒必须写 因为是跟着模板走的 修改模板的话也可以不写
			//转化为时间戳 类型是int64
			purchaseData := map[string]interface{}{
				"accountId": param.UserId,
				"number":    packNum,
				"spec":      "条",
				"appId":     "10000",
				"endTime":   param.EndTime[0:10],
				"remarks":   string(filter),
			}
			if param.DataType == "高级字段包" {
				purchaseData["name"] = "数据流包"
				purchaseData["resourceType"] = "高级字段包"

			} else {
				purchaseData["name"] = "数据流包"
				purchaseData["resourceType"] = "标准字段包"
			}
			ok_3 = util.PurchaseUserBalance(purchaseData)
		}
		return ok_1 != 0 && ok_2 != -1 && ok_3 != false
	})

}
func createEntnicheOrder(param *CreateOtherOrderParams, code string) bool {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	filterMap := map[string]interface{}{
		"source":         "qmx",
		"product":        param.Product,
		"remark":         param.Remark,
		"contractStatus": contractStatus,
		"personnum":      param.PersonNum,
	}
	return util.JysqlDB.ExecTx("创建商机管理生成订单信息和合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(filterMap)
		var insertData = map[string]interface{}{
			"user_phone":         param.Phone,
			"product_type":       param.ProductType,
			"salesperson":        param.SalesPerson,
			"salesperson_id":     param.SalesPersonId,
			"filter":             string(filter),
			"order_code":         code,
			"create_time":        param.CreateTime,   // 当前时间
			"create_person":      param.CreatePerson, // 创建人
			"prepay_time":        qutil.NowFormat(qutil.Date_Full_Layout),
			"order_money":        param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
			"pay_money":          param.ContractMoney,
			"data_spec":          param.DataType,
			"vip_starttime":      param.StartTime,
			"is_backstage_order": 1,
			"vip_endtime":        param.EndTime,
			"order_status":       param.OrderStatus,
			"user_id":            "",
			"pay_time":           qutil.NowFormat(qutil.Date_Full_Layout),
			"return_status":      qutil.If(param.ContractMoney == 0, 1, 0),
			"refund_status":      0,
			"company_name":       param.CompanyName,
			"sale_time":          param.SaleTime,        // 业务统计时间
			"commission":         param.Commission,      // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":   param.ProceduresMoney, // 手续费 2021-12-29 订单优化需求新增字段
			"salesChannel":       param.SalesChannel,
			"orderChannel":       param.OrderChannel,
			"paybackCompany":     param.PaybackCompany,
			"audit_status":       param.AuditStatus,
			"pay_way":            param.PayType,
			"saleDep":            param.SaleDep,
		}
		contractData := map[string]interface{}{
			"order_code":              code,
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.StartTime == "" {
			delete(insertData, "vip_starttime")

		}
		if param.EndTime == "" {
			delete(insertData, "vip_endtime")

		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		if param.BuySubject == "2" {
			insertData["buySubject"] = 2
			entId, err, userPositionId := AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, param.UserId)
			if err != nil {
				log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
				return false
			} else {
				if entId != 0 {
					insertData["entId"] = entId
					insertData["user_id"] = userPositionId
					param.UserId = userPositionId
				}

			}
		} else {
			insertData["buySubject"] = 1
		}
		insertData["buyCount"] = param.BuyCount

		//ok_1 := util.JysqlDB.InsertByTx(tx, "dataexport_order", insertData)
		ok1 := util.JyOrder("/CreateOrder", insertData)
		ok2 := util.JysqlDB.InsertByTx(tx, "contract", contractData)
		return ok1 != -1 && ok2 != -1
	})

}
func updateOtherOrder(oldFilter string, param *CreateOtherOrderParams, code string, returnStatus int) bool {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	var filterMap = map[string]interface{}{
		"source":         "qmx",
		"product":        param.Product,
		"remark":         param.Remark,
		"contractStatus": contractStatus,
	}
	sMOpenid := ""
	sNickname := ""
	price := 0
	packNum := 0
	if param.ProductType == "广告" {
		filterMap["adSource"] = AdSourceMap[param.AdSource]
	} else if param.ProductType == "数据流量包" {
		userData, ok := util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
		if ok && userData != nil && len(*userData) > 0 {
			if (*userData)["s_m_openid"] != nil {
				sMOpenid = fmt.Sprint((*userData)["s_m_openid"])
			} else if (*userData)["s_nickname"] != nil {
				sNickname = fmt.Sprint((*userData)["s_nickname"])
			}
		}
		//根据id查询流量包价格
		packDetail, err := util.JyDataExportPack.GetPackDetailById(param.PackId)
		if err != nil {
			log.Println(err)
		}
		filterMap = map[string]interface{}{
			"pType":     packDetail.PackType,
			"pNum":      packDetail.PackNum,
			"validYear": packDetail.ValidYear,
			"price":     packDetail.Price,
			"badge":     "give",
		}
		price = packDetail.Price
		packNum = packDetail.PackNum
	}
	if param.DataType == "1" {
		param.DataType = "高级字段包"
	} else if param.DataType == "2" {
		param.DataType = "标准字段包"
	} else if param.DataType == "3" {
		param.DataType = "自定义字段包"
	}
	// 如果本来就包含人工审核字段就在filter里面赋值人工审核字段
	if strings.Contains(oldFilter, "人工审核") {
		filterMap["audit_type"] = "人工审核"
	}
	return util.JysqlDB.ExecTx("修改订单信息和创建合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(filterMap)
		insertData := map[string]interface{}{
			"order_code":         param.OrderCode,
			"user_phone":         param.Phone,
			"product_type":       param.ProductType,
			"salesperson":        param.SalesPerson,
			"salesperson_id":     param.SalesPersonId, // 销售人员在剑鱼后台的id
			"filter":             string(filter),
			"order_money":        param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
			"pay_money":          param.ContractMoney,
			"data_count":         param.DataNum,
			"data_spec":          param.DataType,
			"vip_starttime":      param.StartTime,
			"vip_endtime":        param.EndTime,
			"order_status":       param.OrderStatus,
			"company_name":       param.CompanyName,
			"sale_time":          param.SaleTime,        // 业务统计时间
			"commission":         param.Commission,      // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":   param.ProceduresMoney, // 手续费 2021-12-29 订单优化需求新增字段
			"salesChannel":       param.SalesChannel,
			"orderChannel":       param.OrderChannel,
			"paybackCompany":     param.PaybackCompany,
			"last_update_person": param.CreatePerson,
			"last_update_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		}
		if param.BuySubject == "2" {
			insertData["buySubject"] = 2
			entId, err, userPositionId := AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, param.UserId)
			if err != nil {
				log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
				return false
			} else {
				if entId != 0 {
					insertData["entId"] = entId
					param.UserId = userPositionId
					insertData["user_id"] = userPositionId
				}
			}
		} else {
			insertData["buySubject"] = 1
		}
		insertData["buyCount"] = param.BuyCount

		if param.ProductType == "历史数据" {
			insertData["service_status"] = 1
		} else if param.ProductType == "数据流量包" {
			insertData["original_price"] = price
			insertData["order_money"] = 0
			insertData["discount_price"] = price
			insertData["user_id"] = param.UserId
			insertData["user_nickname"] = sNickname
			insertData["user_openid"] = sMOpenid
		}
		contractData := map[string]interface{}{
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}

		if param.ProductType == "广告" || param.ProductType == "线下课程培训" || param.ProductType == "课程分销" ||
			param.ProductType == "标书制作" || param.ProductType == "打赏" ||
			param.ProductType == "ISO体系认证" || param.ProductType == "3A信用认证" || param.ProductType == "权益码" {
			delete(insertData, "data_count")
			delete(insertData, "data_spec")
		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.StartTime == "" {
			delete(insertData, "vip_starttime")
		}
		if param.EndTime == "" {
			delete(insertData, "vip_endtime")
		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		//订单中台
		if param.ProductType == "数据流量包" {
			insertData["return_status"] = 1
		} else {
			insertData["return_status"] = returnStatus
		}
		ok_1 := util.JyOrder("/UpdateOrder", insertData)
		//资源中台
		ok_2 := false
		//ok_3 := true
		if param.ProductType != "数据流量包" {
			ok_2 = util.JysqlDB.UpdateByTx(tx, "contract", map[string]interface{}{
				"order_code": code,
			}, contractData)
		} else {
			//待转化为时间戳的字符串 注意 这里的小时和分钟还要秒必须写 因为是跟着模板走的 修改模板的话也可以不写
			//转化为时间戳 类型是int64
			purchaseData := map[string]interface{}{
				"accountId": param.UserId,
				"number":    packNum,
				"spec":      "条",
				"appId":     "10000",
				"endTime":   param.EndTime[0:10],
				"remarks":   string(filter),
			}
			if param.DataType == "高级字段包" {
				purchaseData["name"] = "数据流包"
				purchaseData["resourceType"] = "高级字段包"

			} else {
				purchaseData["name"] = "数据流包"
				purchaseData["resourceType"] = "标准字段包"
			}
			//ok_3 = util.PurchaseUserBalance(purchaseData)
		}
		//return ok_1 != 0 && ok_2 && ok_3 != false
		return ok_1 != 0 && ok_2
	})

}
func updateEntnicheOrder(oldFilter string, param *CreateOtherOrderParams, code string, returnStatus int) bool {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	filter_map := map[string]interface{}{
		"source":         "qmx",
		"product":        param.Product,
		"remark":         param.Remark,
		"contractStatus": contractStatus,
		"personnum":      param.PersonNum,
	}
	// 如果本来就包含人工审核字段就在filter里面赋值人工审核字段
	if strings.Contains(oldFilter, "人工审核") {
		filter_map["audit_type"] = "人工审核"
	}
	return util.JysqlDB.ExecTx("创建商机管理生成订单信息和合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(filter_map)
		insertData := map[string]interface{}{
			"user_phone":         param.Phone,
			"product_type":       param.ProductType,
			"salesperson":        param.SalesPerson,
			"salesperson_id":     param.SalesPersonId,
			"filter":             string(filter),
			"order_code":         code,
			"prepay_time":        qutil.NowFormat(qutil.Date_Full_Layout),
			"order_money":        param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
			"pay_money":          param.ContractMoney,
			"data_spec":          param.DataType,
			"vip_starttime":      param.StartTime,
			"vip_endtime":        param.EndTime,
			"order_status":       param.OrderStatus,
			"return_status":      returnStatus,
			"company_name":       param.CompanyName,
			"sale_time":          param.SaleTime,        // 业务统计时间
			"commission":         param.Commission,      // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":   param.ProceduresMoney, // 手续费 2021-12-29 订单优化需求新增字段
			"salesChannel":       param.SalesChannel,
			"orderChannel":       param.OrderChannel,
			"paybackCompany":     param.PaybackCompany,
			"last_update_person": param.CreatePerson,
			"last_update_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		}
		contractData := map[string]interface{}{
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.StartTime == "" {
			delete(insertData, "vip_starttime")

		}
		if param.EndTime == "" {
			delete(insertData, "vip_endtime")

		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		if param.BuySubject == "2" {
			insertData["buySubject"] = 2
			entId, err, userPositionId := AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, param.UserId)
			if err != nil {
				log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
				return false
			} else {
				if entId != 0 {
					insertData["entId"] = entId
					param.UserId = userPositionId
					insertData["user_id"] = userPositionId
				}
			}
		} else {
			insertData["buySubject"] = 1
		}
		insertData["buyCount"] = param.BuyCount

		ok_1 := util.JyOrder("/UpdateOrder", insertData)
		ok_2 := util.JysqlDB.UpdateByTx(tx, "contract", map[string]interface{}{
			"order_code": code,
		}, contractData)
		return ok_1 != -1 && ok_2
	})

}

// 创建VIP订单
func createVipOrder(param *CreateOtherOrderParams, code string) (bool, string) {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	month := 0
	if param.VipStartTime != "" {
		if param.CycleUnit == 1 {
			month = param.CycleCount * 12
		} else if param.CycleUnit == 2 {
			month = param.CycleCount
		} else if param.CycleUnit == 4 {
			month = param.CycleCount * 3
		}
	}
	//处理购买省份
	buyArea := map[string]interface{}{}
	if !strings.Contains(param.Area, "全国") {
		arr := strings.Split(param.Area, ",")
		for _, v := range arr {
			buyArea[v] = []interface{}{}
		}
	}
	var endTime time.Time
	vipStartTime, _ := time.ParseInLocation(qutil.Date_Short_Layout, param.VipStartTime, time.Local)
	if param.VipType == 1 {
		d, _ := time.ParseDuration("-24h")
		vipStartTime = vipStartTime.Add(d)
	}
	if param.CycleUnit == 3 {
		_endTime := vipStartTime.AddDate(0, 0, param.CycleCount)
		t := _endTime.Format(qutil.Date_Short_Layout) + " 23:59:59"
		endTime, _ = time.ParseInLocation(qutil.Date_Full_Layout, t, time.Local)
	} else {
		endTime = GetDATE1(month, vipStartTime.Unix())
	}

	//开通超级订阅权限
	areaCount := 0
	if strings.Contains(param.Area, "全国") {
		areaCount = -1
	} else {
		areaCount = len(buyArea)
	}
	dateType := 1
	if param.VipStartTime != "" {
		if vipStartTime.Unix() > time.Now().Unix() {
			dateType = 2
		}
	}
	//新购买简单详情
	newBuySet := SubvipBuySet{
		Upgrade:         1,
		AreaCount:       areaCount,
		NewCitys:        []int{},
		BuyerclassCount: -1,
	}
	vms := VipSimpleMsg{
		Area:           &buyArea,
		Industry:       []string{},
		Cyclecount:     param.CycleCount,
		Cycleunit:      param.CycleUnit,
		NewBuyset:      &newBuySet,
		OrderType:      1,
		DisWord:        "",
		ContractStatus: contractStatus,
		Source:         "qmx",
		Remark:         param.Remark,
	}

	if param.OrderChannel == "d03" {
		vms.Source = ""
	}
	if param.Badge != "" {
		vms.Badge = param.Badge
	}
	userData := &map[string]interface{}{}
	ok := false
	if param.UserId == "" {
		userData, ok = util.MQFW.FindOne("user", map[string]interface{}{"s_phone": param.Phone})
	} else {
		userData, ok = util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
	}
	userId := ""
	var vet string
	if ok && userData != nil && len(*userData) > 0 {
		userId = mongodb.BsonIdToSId((*userData)["_id"])
		// st := qutil.Int64All((*userData)["l_vip_starttime"])
		et := qutil.Int64All((*userData)["l_vip_endtime"])
		// vst = qutil.FormatDateByInt64(&st, qutil.Date_Full_Layout)
		vet = qutil.FormatDateByInt64(&et, qutil.Date_Full_Layout)
		if param.VipType == 1 {
			vipInfo := qutil.ObjToMap((*userData)["o_vipjy"])
			buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
			areaCount = qutil.IntAll((*buySet)["areacount"])
			// 超级订阅续费
			vms.NewBuyset.AreaCount = areaCount

		}
	} else {
		userDatas := &map[string]interface{}{}
		oks := false
		if param.UserId == "" {
			userDatas, oks = util.MQFW.FindOne("user", map[string]interface{}{"s_m_phone": param.Phone})
		} else {
			userDatas, oks = util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
		}
		if oks && userDatas != nil && len(*userDatas) > 0 {
			userId = mongodb.BsonIdToSId((*userDatas)["_id"])
			// st := qutil.Int64All((*userDatas)["l_vip_starttime"])
			et := qutil.Int64All((*userDatas)["l_vip_endtime"])
			// vst = qutil.FormatDateByInt64(&st, qutil.Date_Full_Layout)
			vet = qutil.FormatDateByInt64(&et, qutil.Date_Full_Layout)
			if param.VipType == 1 {
				vipInfo := qutil.ObjToMap((*userDatas)["o_vipjy"])
				buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
				areaCount = qutil.IntAll((*buySet)["areacount"])
				// 超级订阅续费
				vms.NewBuyset.AreaCount = areaCount
			}
		} else {
			if param.VipType == 0 {
				now := time.Now()
				data := map[string]interface{}{
					"i_appid":       2,
					"s_phone":       param.Phone,
					"s_password":    "",
					"l_registedate": now.Unix(),
					"i_ts_guide":    2,
					"o_jy": map[string]interface{}{
						"i_apppush":    1,
						"i_ratemode":   2,
						"l_modifydate": now.Unix(),
					},
					"s_regsource": "qmx_admin",
				}
				_id := util.MQFW.Save("user", data)
				if _id != "" {
					userId = _id
					formdata := map[string]interface{}{
						"appid":    config.SysConfigs.AppId,
						"phone":    param.Phone,
						"password": "",
					}
					if !strings.HasPrefix(param.Phone, "9") {
						ck := &http.Cookie{}
						usercenter.AddBaseUser(*util.MQFW, config.SysConfigs.UserCenterUrl, _id, formdata, ck)
					}
				}
			}
		}
	}
	// payWay := "wx_app"
	// // returnStatus := 1
	// if param.ChargeMode == 1 {
	// 	// returnStatus = 0
	// 	if param.Pay_way == "" {
	// 		payWay = "transferAccounts"
	// 	}
	// }
	// // if param.ReturnStatus == 1 {
	// // 	returnStatus = 1
	// // }
	// if param.Badge != "" {
	// 	payWay = ""
	// }
	var (
		entId          int
		err            error
		userPositionId string
	)
	if param.BuySubject == "2" {
		entId, err, userPositionId = AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, userId)
		if err != nil {
			log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
			return false, "自动创建企业信息失败"
		}
	}
	b := util.JysqlDB.ExecTx("创建超级订阅生成订单信息和合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(vms)
		if param.Badge != "" {
			param.ContractMoney = 0
		}
		insertData := map[string]interface{}{
			"user_phone":           param.Phone,
			"product_type":         param.ProductType,
			"salesperson":          param.SalesPerson,
			"salesperson_id":       param.SalesPersonId,
			"filter":               string(filter),
			"order_code":           code,
			"create_time":          param.CreateTime, // 当前时间
			"prepay_time":          qutil.NowFormat(qutil.Date_Full_Layout),
			"order_money":          param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
			"pay_money":            param.ContractMoney,
			"data_spec":            param.DataType, //数据规格 1-标准字段包 2-高级字段包
			"vip_starttime":        param.VipStartTime + " 00:00:00",
			"vip_endtime":          qutil.FormatDate(&endTime, qutil.Date_Full_Layout),
			"is_backstage_order":   1,
			"order_status":         param.OrderStatus,
			"user_id":              userId,
			"out_trade_no":         code,
			"return_status":        qutil.If(param.ContractMoney == 0, 1, 0),
			"refund_status":        0,
			"company_name":         param.CompanyName,
			"billingMode":          param.ChargeMode,                                    //计费模式 0 免费  1 收费
			"sale_time":            qutil.If(param.SaleTime == "", nil, param.SaleTime), // 业务统计时间
			"commission":           param.Commission,                                    // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":     param.ProceduresMoney,                               // 手续费 2021-12-29 订单优化需求新增字段
			"distribution_channel": param.SalesChannel,
			"order_channel":        param.OrderChannel,
			"signing_subject":      param.PaybackCompany,
			"create_person":        param.CreatePerson,
			"audit_status":         param.AuditStatus,
			"pay_way":              param.PayType,
			"saleDep":              param.SaleDep,
		}
		if param.Pay_time != "" {
			insertData["pay_time"] = param.Pay_time
		}
		if param.OrderMoney != 0 {
			insertData["order_money"] = param.OrderMoney
		}
		if param.DisCountPrice != 0 {
			insertData["discount_price"] = param.DisCountPrice
		}
		if param.VipType == 1 {
			insertData["vip_type"] = 1
		} else if param.VipType == 2 {
			insertData["vip_type"] = 2
			insertData["vip_starttime"] = qutil.NowFormat(qutil.Date_Full_Layout)
			insertData["vip_endtime"] = vet
		}
		if param.Badge != "" {
			insertData["original_price"] = param.DisCountPrice
			insertData["return_status"] = 1
			insertData["vip_type"] = 0
		}
		if param.OrderChannel == "d03" {
			insertData["original_price"] = param.OrderMoney
			delete(insertData, "return_status")
		}
		contractData := map[string]interface{}{
			"order_code":              code,
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		if param.BuySubject == "2" {
			insertData["buy_subject"] = 2
			if entId != 0 {
				insertData["ent_id"] = entId
				insertData["user_id"] = userPositionId
			}
		} else {
			insertData["buy_subject"] = 1
		}
		insertData["buy_count"] = param.BuyCount
		ok1 := util.JysqlDB.InsertByTx(tx, "dataexport_order", insertData)
		ok2 := util.JysqlDB.InsertByTx(tx, "contract", contractData)
		return ok1 != 0 && ok2 != -1
	})
	if b {
		// 销售渠道为内部员工赠送及豁免用户赠送时更新用户人群分类
		if param.SalesChannel == util.SaleChannel052 || param.SalesChannel == util.SaleChannel053 {
			UpdateUserType(param.SalesChannel, userId)
		}
		if param.BuySubject == "2" {
			var (
				entService bool
				userCount  int
				ss         int64
			)
			if strings.Contains(param.VipStartTime, "2099") {
				ss = 4070880000
			}
			_d := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": code}, "id,ent_id", "")
			if _d != nil && len(*_d) > 0 {
				entService, userCount = EntServiceOpen(qutil.IntAll((*_d)["ent_id"]), param.Phone, param.ProductType, ss)
				orderId := qutil.IntAll((*_d)["id"])
				if qutil.IntAll((*_d)["ent_id"]) != 0 && param.Open && param.VipStartTime != "2099-01-01" && param.BuyCount > 0 {
					regRuler := "^1[3456789]{1}\\d{9}$"
					reg := regexp.MustCompile(regRuler)
					if param.OrderStatus == 1 && reg.MatchString(param.Phone) && param.CompanyName != "" {
						err := EntLicense(qutil.IntAll((*_d)["ent_id"]), param.BuyCount, newBuySet.AreaCount, orderId, userCount, param.ProductType, param.VipStartTime+" 00:00:00", qutil.FormatDate(&endTime, qutil.Date_Full_Layout), param.Phone)
						if err != nil {
							log.Printf("EntLicense 创建企业授权信息失败：code:%s,err:%s", code, err.Error())
						}
					}
				}
			}
			if !entService {
				ClearBigVipUserPower(userId)
				return true, ""
			}
		}
		// 不开通权限、执行到这结束
		if param.Open == false {
			return true, ""
		}

		//0 购买  1 续费  2 升级
		if param.VipType == 0 {
			//为用户开通超级订阅权限
			//是否开通超级订阅 -1 试用到期 -2 正式到期 1 试用 2 开通
			isTrial := false
			if param.VipStartTime == "2099-01-01" || dateType == 2 {
				isTrial = true
			}
			isOk := false
			set := map[string]interface{}{
				"o_vipjy.i_trial":      -1,                       //已激活试用
				"o_vipjy.o_area":       buyArea,                  //设置地区
				"o_vipjy.o_buyset":     newBuySet,                //购买内容 城市、省份、行业数量
				"l_vip_starttime":      vipStartTime.Unix(),      //开始时间
				"l_vip_endtime":        endTime.Unix(),           //结束时间
				"i_vip_status":         qutil.If(isTrial, -2, 2), //1试用 2正式 -2 试用到期
				"i_vip_expire_tip":     0,                        //消息提示初始化
				"o_vipjy.a_buyerclass": []interface{}{},          //设置行业
			}
			if param.BuySubject == "1" {
				isOk = StartSubVip(set, userId)
			} else {
				isOk = UpdateRule(entId, map[string]interface{}{
					"$set": set,
				}, param.Phone)
			}
			return isOk, qutil.FormatDate(&endTime, qutil.Date_Full_Layout)
		}
		// 续费和升级 我的订单-创建订单只生成订单信息不开通权益
		if !param.Open {
			return true, qutil.FormatDate(&endTime, qutil.Date_Full_Layout)
		}
		if param.VipType == 1 { //续费
			set := map[string]interface{}{
				"l_vip_endtime":    endTime.Unix(),
				"i_vip_expire_tip": 0,
				"i_vip_status":     2,
			}
			if param.BuySubject != "2" {
				if !util.MQFW.UpdateById("user", userId,
					bson.M{"$set": set}) {
					log.Printf("%s更新结束%d日期出错\n", userId, endTime.Unix())
					return false, ""
				}
			}
			if !util.MQFW.UpdateById("user", userId,
				bson.M{"$set": set}) {
				log.Printf("%s更新结束%d日期出错\n", userId, endTime.Unix())
				return false, ""
			}
			return true, qutil.FormatDate(&endTime, qutil.Date_Full_Layout)
		} else { //2  升级
			//失效未执行续费
			if !util.MQFW.Update("vip_upgrade",
				&map[string]interface{}{"s_userid": userId, "i_isvalid": 0},
				&map[string]interface{}{
					"$set": map[string]interface{}{
						"i_isvalid": 1,
					},
				}, false, true) {
				log.Printf("%s vip_upgrade 更新失败  时间：%d\n", userId, endTime.Unix())
				return false, ""
			}
			updata := map[string]interface{}{
				"o_vipjy.o_buyset": newBuySet,
				"i_vip_expire_tip": 0,
				"i_vip_status":     2,
			}
			if vms.Area != nil {
				updata["o_vipjy.o_area"] = vms.Area //设置地区
			}
			if vms.Industry != nil {
				updata["o_vipjy.a_buyerclass"] = vms.Industry //设置行业
			}
			isOk := true
			if param.BuySubject != "2" {
				isOk = util.MQFW.UpdateById("user", userId, map[string]interface{}{
					"$set": updata,
				})
			}
			if !isOk {
				log.Printf("%s更新用户出错 %+v\n", userId, updata)
				return false, ""
			} else {
				go ClearBigVipUserPower(userId)
				return true, qutil.FormatDate(&endTime, qutil.Date_Full_Layout)
			}
		}
	}
	return false, ""
}
func updateVipOrder(oldFilter string, param *CreateOtherOrderParams, code string, returnStatus int) (bool, string) {
	var contractStatus int
	if param.ContractFileUrl != "" && len(param.ContractFileUrl) > 0 {
		contractStatus = 1
	} else {
		contractStatus = 0
	}
	month := 0
	if param.VipStartTime != "" {
		if param.CycleUnit == 1 {
			month = param.CycleCount * 12
		} else if param.CycleUnit == 2 {
			month = param.CycleCount
		} else if param.CycleUnit == 4 {
			month = param.CycleCount * 3
		}
	}
	//处理购买省份
	buyArea := map[string]interface{}{}
	if !strings.Contains(param.Area, "全国") {
		arr := strings.Split(param.Area, ",")
		for _, v := range arr {
			buyArea[v] = []interface{}{}
		}
	}
	var endTime time.Time
	vipStartTime, _ := time.ParseInLocation(qutil.Date_Short_Layout, param.VipStartTime, time.Local)
	if param.VipType == 1 {
		d, _ := time.ParseDuration("-24h")
		vipStartTime = vipStartTime.Add(d)
	}
	if param.CycleUnit == 3 {
		_endTime := vipStartTime.AddDate(0, 0, param.CycleCount)
		t := _endTime.Format(qutil.Date_Short_Layout) + " 23:59:59"
		endTime, _ = time.ParseInLocation(qutil.Date_Full_Layout, t, time.Local)
	} else {
		endTime = GetDATE1(month, vipStartTime.Unix())
	}
	//开通超级订阅权限
	areaCount := 0
	if strings.Contains(param.Area, "全国") {
		areaCount = -1
	} else {
		areaCount = len(buyArea)
	}
	dateType := 1
	if param.VipStartTime != "" {
		if vipStartTime.Unix() > time.Now().Unix() {
			dateType = 2
		}
	}
	//新购买简单详情
	newBuySet := SubvipBuySet{
		Upgrade:         1,
		AreaCount:       areaCount,
		NewCitys:        []int{},
		BuyerclassCount: -1,
	}
	vms := VipSimpleMsg{
		Area:           &buyArea,
		Industry:       []string{},
		Cyclecount:     param.CycleCount,
		Cycleunit:      param.CycleUnit,
		NewBuyset:      &newBuySet,
		OrderType:      1,
		DisWord:        "",
		ContractStatus: contractStatus,
		Source:         "qmx",
		Remark:         param.Remark,
	}

	if param.Badge != "" {
		vms.Badge = param.Badge
	}
	var vet string
	userId := ""
	userData := &map[string]interface{}{}
	ok := false
	if param.UserId == "" {
		userData, ok = util.MQFW.FindOne("user", map[string]interface{}{"s_phone": param.Phone})
	} else {
		userData, ok = util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
	}
	if ok && userData != nil && len(*userData) > 0 {
		userId = mongodb.BsonIdToSId((*userData)["_id"])
		// st := qutil.Int64All((*userData)["l_vip_starttime"])
		et := qutil.Int64All((*userData)["l_vip_endtime"])
		// vst = qutil.FormatDateByInt64(&st, qutil.Date_Full_Layout)
		vet = qutil.FormatDateByInt64(&et, qutil.Date_Full_Layout)
		if param.VipType == 1 {
			vipInfo := qutil.ObjToMap((*userData)["o_vipjy"])
			buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
			areaCount = qutil.IntAll((*buySet)["areacount"])
			// 超级订阅续费
			vms.NewBuyset.AreaCount = areaCount
		}
	} else {
		userDatas := &map[string]interface{}{}
		oks := false
		if param.UserId == "" {
			userDatas, oks = util.MQFW.FindOne("user", map[string]interface{}{"s_m_phone": param.Phone})
		} else {
			userDatas, oks = util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
		}
		if oks && userDatas != nil && len(*userDatas) > 0 {
			userId = mongodb.BsonIdToSId((*userDatas)["_id"])
			// st := qutil.Int64All((*userDatas)["l_vip_starttime"])
			et := qutil.Int64All((*userDatas)["l_vip_endtime"])
			// vst = qutil.FormatDateByInt64(&st, qutil.Date_Full_Layout)
			vet = qutil.FormatDateByInt64(&et, qutil.Date_Full_Layout)
			if param.VipType == 1 {
				vipInfo := qutil.ObjToMap((*userDatas)["o_vipjy"])
				buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
				areaCount = qutil.IntAll((*buySet)["areacount"])
				// 超级订阅续费
				vms.NewBuyset.AreaCount = areaCount
			}
		}
	}
	var (
		entId          int
		err            error
		userPositionId string
	)
	if param.BuySubject == "2" {
		entId, err, userPositionId = AutomaticallyCreatingEnt(param.CompanyName, param.Phone, code, param.OrderStatus, userId)
		if err != nil {
			log.Printf("AutomaticallyCreatingEnt 自动创建企业信息失败：code:%s,err:%s", code, err.Error())
			return false, "自动创建企业信息失败"
		}
		userId = userPositionId
	}
	// 如果本来就包含人工审核字段就在filter里面赋值人工审核字段
	if strings.Contains(oldFilter, "人工审核") {
		vms.AuditType = "人工审核"
	}
	b := util.JysqlDB.ExecTx("修改订单信息和合同信息", func(tx *sql.Tx) bool {
		filter, _ := json.Marshal(vms)
		if param.Badge != "" {
			param.ContractMoney = 0
		}
		insertData := map[string]interface{}{
			"user_phone":           param.Phone,
			"product_type":         param.ProductType,
			"salesperson":          param.SalesPerson,
			"salesperson_id":       param.SalesPersonId,
			"filter":               string(filter),
			"create_person":        param.CreatePerson, // 创建人
			"prepay_time":          qutil.NowFormat(qutil.Date_Full_Layout),
			"order_money":          param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
			"pay_money":            param.ContractMoney,
			"data_spec":            param.DataType, //数据规格 1-标准字段包 2-高级字段包
			"vip_starttime":        param.VipStartTime,
			"vip_endtime":          qutil.FormatDate(&endTime, qutil.Date_Full_Layout),
			"order_status":         param.OrderStatus,
			"user_id":              userId,
			"out_trade_no":         code,
			"return_status":        returnStatus,
			"company_name":         param.CompanyName,
			"billingMode":          param.ChargeMode,                                    //计费模式 0 免费  1 收费
			"sale_time":            qutil.If(param.SaleTime == "", nil, param.SaleTime), // 业务统计时间
			"commission":           param.Commission,                                    // 佣金 2021-12-29 订单优化需求新增字段
			"procedures_money":     param.ProceduresMoney,                               // 手续费 2021-12-29 订单优化需求新增字段
			"distribution_channel": param.SalesChannel,
			"order_channel":        param.OrderChannel,
			"signing_subject":      param.PaybackCompany,
			"last_update_person":   param.CreatePerson,
			"last_update_time":     qutil.NowFormat(qutil.Date_Full_Layout),
		}
		if param.Pay_time != "" {
			insertData["pay_time"] = param.Pay_time
		}
		if param.OrderMoney != 0 {
			insertData["order_money"] = param.OrderMoney
		}
		if param.DisCountPrice != 0 {
			insertData["discount_price"] = param.DisCountPrice
		}
		if param.VipType == 1 {
			insertData["vip_type"] = 1
		} else if param.VipType == 2 {
			insertData["vip_type"] = 2
			// insertData["vip_starttime"] = vst
			insertData["vip_starttime"] = param.CreateTime
			insertData["vip_endtime"] = vet
		}
		if param.Badge != "" {
			insertData["original_price"] = param.DisCountPrice
			insertData["return_status"] = 1
			insertData["vip_type"] = 0
		}
		contractData := map[string]interface{}{
			"customer_name":           param.CustomerName,
			"contract_code":           param.ContractCode,
			"contract_time":           param.ContractTime,
			"contract_status":         param.ContractStatus,
			"contract_money":          param.ContractMoney,
			"contract_file_url":       param.ContractFileUrl,
			"contract_archive_status": qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveStatus),
			"contract_archive_num":    qutil.If(param.ContractStatus == 0, nil, param.ContractArchiveNum),
		}
		if param.ContractArchiveTime != "" {
			contractData["contract_archive_time"] = param.ContractArchiveTime
		}
		if qutil.IntAll(param.ContractStatus) == 0 {
			delete(contractData, "contract_time")
			delete(contractData, "contract_code")
		}
		if param.ContractTime == "" {
			delete(contractData, "contract_time")
		}
		if param.BuySubject == "2" {
			if entId != 0 {
				insertData["ent_id"] = entId
				insertData["user_id"] = userPositionId
			}
			insertData["buy_subject"] = 2
		} else {
			insertData["buy_subject"] = 1
		}
		insertData["buy_count"] = param.BuyCount

		ok1 := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{
			"order_code": code,
		}, insertData)
		ok2 := util.JysqlDB.UpdateByTx(tx, "contract", map[string]interface{}{
			"order_code": code,
		}, contractData)
		return ok1 && ok2
	})
	if b {
		//企业主体不开通权益
		if param.BuySubject == "2" {
			var (
				userCount  int
				entService bool
				ss         int64
			)

			if strings.Contains(param.StartTime, "2099") {
				ss = 4070880000
			}
			_d := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": code}, "id,ent_id", "")
			if _d != nil && len(*_d) > 0 {
				entService, userCount = EntServiceOpen(qutil.IntAll((*_d)["ent_id"]), param.Phone, param.ProductType, ss)
				orderId := qutil.IntAll((*_d)["id"])
				if qutil.IntAll((*_d)["ent_id"]) != 0 && param.VipStartTime != "2099-01-01" && param.BuyCount > 0 {
					regRuler := "^1[3456789]{1}\\d{9}$"
					reg := regexp.MustCompile(regRuler)
					if param.OrderStatus == 1 && reg.MatchString(param.Phone) && param.CompanyName != "" {
						err := EntLicense(qutil.IntAll((*_d)["ent_id"]), param.BuyCount, newBuySet.AreaCount, orderId, userCount, param.ProductType, param.VipStartTime, qutil.FormatDate(&endTime, qutil.Date_Full_Layout), param.Phone)
						if err != nil {
							log.Printf("EntLicense 创建企业授权信息失败：code:%s,err:%s", code, err.Error())
						}
					}
				}
			}
			if !entService {
				ClearBigVipUserPower(userId)
				return true, ""
			}
		}
		//0 购买  1 续费  2 升级
		if param.VipType == 0 {
			if param.OrderStatus == -2 {
				set := map[string]interface{}{
					"o_vipjy.i_trial":      -1,                //已激活试用
					"o_vipjy.o_area":       "",                //设置地区
					"o_vipjy.o_buyset":     "",                //购买内容 城市、省份、行业数量
					"l_vip_starttime":      time.Now().Unix(), //开始时间
					"l_vip_endtime":        time.Now().Unix(), //结束时间
					"i_vip_status":         0,                 //1试用 2正式
					"i_vip_expire_tip":     0,                 //消息提示初始化
					"o_vipjy.a_buyerclass": []interface{}{},   //设置行业
				}
				if param.BuySubject == "1" {
					util.MQFW.UpdateById("user", userId, bson.M{
						"$set": set,
					})
					ClearBigVipUserPower(userId)
					return true, ""
				} else {
					UpdateRule(entId, map[string]interface{}{
						"$set": set,
					}, param.Phone)
					ClearBigVipUserPower(userId)
					return true, ""
				}
			}
			//为用户开通超级订阅权限
			//是否开通超级订阅 -1 试用到期 -2 正式到期 1 试用 2 开通
			isTrial := false
			if param.VipStartTime == "2099-01-01" || dateType == 2 {
				isTrial = true
			}
			if param.UpdateType == 0 {
				set := map[string]interface{}{
					"o_vipjy.i_trial":      -1,                       //已激活试用
					"o_vipjy.o_area":       buyArea,                  //设置地区
					"o_vipjy.o_buyset":     newBuySet,                //购买内容 城市、省份、行业数量
					"l_vip_starttime":      vipStartTime.Unix(),      //开始时间
					"l_vip_endtime":        endTime.Unix(),           //结束时间
					"i_vip_status":         qutil.If(isTrial, -2, 2), //1试用 2正式 -2 试用到期
					"i_vip_expire_tip":     0,                        //消息提示初始化
					"o_vipjy.a_buyerclass": []interface{}{},          //设置行业
				}
				isOk := false
				if param.BuySubject == "1" {
					isOk = StartSubVip(set, userId)
				} else {
					isOk = UpdateRule(entId, map[string]interface{}{
						"$set": set,
					}, param.Phone)
				}
				return isOk, qutil.FormatDate(&endTime, qutil.Date_Full_Layout)
			} else {
				return true, ""
			}

		}
		return true, ""
	}
	return false, ""
}

/*//当大会员状态改变时清除此状态
func ClearBigVipUserPower(userId string) bool {
	cacheKey := fmt.Sprintf(PowerCacheKey, userId)
	return redis.Del(NewOther, cacheKey)
}*/

// 当大会员状态改变时清除此状态
func ClearBigVipUserPower(userId string) {
	if mongodb.IsObjectIdHex(userId) {
		user_id := userId
		//大会员主账号清理
		userDatas, ok := util.MQFW.Find("user", map[string]interface{}{"s_member_mainid": user_id, "i_member_sub_status": 1}, nil, nil, false, -1, -1)
		if ok && userDatas != nil && len(*userDatas) > 0 {
			for _, v := range *userDatas {
				user_id := m.BsonIdToSId(v["_id"])
				userData, ok := util.MQFW.FindById("user", user_id, `"base_user_id":1`)
				if userData != nil && len(*userData) > 0 && ok {
					baseUserId := qutil.Int64All((*userData)["base_user_id"])
					positionData := util.BaseDB.FindOne(util.BasePosition, map[string]interface{}{
						"type":    0,
						"ent_id":  0,
						"user_id": baseUserId,
					}, "id", "")
					if positionData != nil && len(*positionData) > 0 {
						user_id = fmt.Sprint(qutil.Int64All((*positionData)["id"]))
						redis.Del("newother", config.SysConfigs.BigmemberKey+user_id)
					}
				}

			}
		}
		//通过mongo查找职位标识
		userData, ok := util.MQFW.FindById("user", userId, `"base_user_id":1`)
		if userData != nil && len(*userData) > 0 && ok {
			baseUserId := qutil.Int64All((*userData)["base_user_id"])
			positionData := util.BaseDB.FindOne(util.BasePosition, map[string]interface{}{
				"type":    0,
				"ent_id":  0,
				"user_id": baseUserId,
			}, "id", "")
			if positionData != nil && len(*positionData) > 0 {
				userId = fmt.Sprint(qutil.Int64All((*positionData)["id"]))
			}
		}
	}
	cacheKey := fmt.Sprintf(PowerCacheKey, userId)
	baseInfoCacheKey := fmt.Sprintf(IsGetUserBaseInfoRedisKey, userId)
	redisMenuKeyPC := fmt.Sprintf(RedisMenuKeyPC, userId)
	redisMenuKeyWX := fmt.Sprintf(RedisMenuKeyWX, userId)
	redisMenuKeyAPP := fmt.Sprintf(RedisMenuKeyAPP, userId)
	userPowerRedisKey := fmt.Sprintf(UserPowerRedisKey, time.Now().Day(), userId)
	redis.Del(NewOther, cacheKey)
	redis.Del("newother", config.SysConfigs.BigmemberKey+userId)
	redis.Del(NewOther, fmt.Sprintf("jy_workdesktopmenu_10000_menu1_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("jy_userpowerredis_10000_17_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("jy_workdesktopmenu_10000_menu2_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("jy_workdesktopmenu_10000_PC_menu2_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("jy_workdesktopmenu_10000_WX_menu2_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("jy_workdesktopmenu_10000_APP_menu2_%s", userId))
	redis.Del(NewOther, fmt.Sprintf("user_power_info_%s", userId))
	redis.Del(NewOther, baseInfoCacheKey)
	redis.Del(NewOther, redisMenuKeyPC)
	redis.Del(NewOther, redisMenuKeyWX)
	redis.Del(NewOther, redisMenuKeyAPP)
	redis.Del(NewOther, userPowerRedisKey)
	redis.Del(NewOther, "pl_indexMessage_"+userId)
}

// 开始使用超级订阅
func StartSubVip(set map[string]interface{}, userId string) bool {
	isOk := util.MQFW.UpdateById("user", userId, bson.M{
		"$set": set,
	})
	go func() {
		MergeKws(userId)
	}()
	ClearBigVipUserPower(userId)
	if isOk {
		return true
	} else {
		return false
	}
}

// 初始化vip订阅关键词
func MergeKws(userId string) {
	defer qutil.Catch()
	if userId == "" { //11-11 取消此操作
		return
	}
	data, ok := util.MQFW.FindById("user", userId, `{"o_jy":1,"o_vipjy":1}`)
	var o_vipjy map[string]interface{}
	if ok && data != nil && len(*data) > 0 {
		o_vipjy, _ = (*data)["o_vipjy"].(map[string]interface{})
		a_items, _ := o_vipjy["a_items"].([]interface{})
		if a_items == nil { //首次
			util.MQFW.UpdateById("user", userId, bson.M{
				"$set": bson.M{"o_vipjy.i_matchway": 1, "o_vipjy.i_ratemode": 1, "o_vipjy.i_wxpush": 1, "o_vipjy.i_apppush": 1, "o_vipjy.i_projectmatch": 0, "o_vipjy.a_infotype": []string{}, "o_vipjy.a_items": []string{}, "o_vipjy.l_modifydate": time.Now().Unix()},
			})
		}
	}
}

// 编辑回款信息
func UpdateReturnInfo(param *UpdateReturnParams, orderData map[string]interface{}) bool {
	returninvoceRes := util.JysqlDB.SelectBySql("SELECT DISTINCT return_invoice_status from return_money_record  where order_code=? and  state=1", param.OrderCode)
	//// 当回款交易详情中的发票状态全部为“未申请发票”或暂无回款交易详情信息时，此处默认显示“未申请”
	////当回款交易详情中的发票状态有“已申请发票”时，此处显示“已申请”
	////当回款交易详情中的发票状态为“已开具发票”和其他状态时，此处显示“部分开票”
	////当回款交易详情中的发票状态全部为“已开具发票”时，此处显示“已开具”
	////回款发票状态,0-未申请 1-已申请 2-已开具
	weishenqFlag := false
	yishenqFlag := false
	yikaijuFlag := false
	invoiceStatus := 0
	var invoiceMap []map[string]interface{}
	if returninvoceRes != nil {
		invoiceMap = *returninvoceRes
	}
	invoiceMap = append(invoiceMap, map[string]interface{}{"return_invoice_status": param.ReturnInvoiceStatus})
	for _, invoice := range invoiceMap {
		if invoice == nil || qutil.IntAll(invoice["return_invoice_status"]) == 0 {
			weishenqFlag = true
		}
		if invoice != nil && qutil.IntAll(invoice["return_invoice_status"]) == 1 {
			yishenqFlag = true
		}
		if invoice != nil && qutil.IntAll(invoice["return_invoice_status"]) == 2 {
			yikaijuFlag = true
		}
	}

	if weishenqFlag == true && yikaijuFlag == false && yishenqFlag == false {
		invoiceStatus = 0
	}
	if yishenqFlag == true {
		invoiceStatus = 1
	}
	if yikaijuFlag == true && yishenqFlag == false && weishenqFlag == false {
		invoiceStatus = 2
	}
	if yikaijuFlag == true && (yishenqFlag == true || weishenqFlag == true) {
		invoiceStatus = 3
	}
	return util.JysqlDB.ExecTx("编辑回款信息", func(tx *sql.Tx) bool {
		insertData := map[string]interface{}{
			"order_code":            param.OrderCode,
			"return_time":           param.ReturnTime,
			"return_money":          param.ReturnMoney,
			"return_type":           param.ReturnType,
			"return_remark":         param.ReturnRemark,
			"return_code":           param.ReturnCode,
			"return_invoice_status": param.ReturnInvoiceStatus,
			"return_voucher_url":    param.ReturnVoucherUrl,
			"operate_person":        param.OperatePerson,
			"operate_time":          qutil.NowFormat(qutil.Date_Full_Layout),
			"state":                 1,
		}
		filterMap := qutil.ObjToMap(orderData["filter"])
		if param.ReturnStatus == 1 {
			(*filterMap)["isAll"] = 1
		} else if param.ReturnStatus == 2 {
			(*filterMap)["isAll"] = 3
		}
		filter_map, _ := json.Marshal(filterMap)
		updateData := map[string]interface{}{
			"return_status":    param.ReturnStatus,
			"applybill_status": invoiceStatus,
			"filter":           string(filter_map),
			"pay_time":         qutil.NowFormat(qutil.Date_Full_Layout),
		}
		ok1 := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"id": param.Id}, updateData)
		ok2 := util.JysqlDB.InsertByTx(tx, "return_money_record", insertData)
		return ok1 && ok2 != -1
	})

}

// 编辑回款信息
func UpdateBatchReturnInfo(transactionData *map[string]interface{}, orderArr map[string]map[string]interface{}, operatePerson string, param *Return) bool {
	return util.JysqlDB.ExecTx("编辑回款信息", func(tx *sql.Tx) bool {
		return_id := ""
		money := int(math.Floor(float64(float32(qutil.Float64All((*transactionData)["TRSBAL"]))*100 + 0.5))) //流水
		for key, value := range orderArr {
			return_money := qutil.IntAll(value["realPrice"])
			insertData := map[string]interface{}{
				"order_code":            key,
				"return_time":           (*transactionData)["BNKTIM"],
				"return_money":          return_money,
				"return_type":           3,
				"return_remark":         (*transactionData)["NUSAGE"],
				"return_code":           "",
				"bank_flow":             (*transactionData)["BNKFLW"],
				"return_invoice_status": 0,
				"return_voucher_url":    value["returnVoucherUrl"],
				"flow_money":            money,
				"bank_name":             (*transactionData)["BNKNAM"],
				"operate_person":        operatePerson,
				"operate_time":          qutil.NowFormat(qutil.Date_Full_Layout),
				"flow_type":             param.FlowType,
				"pay_account_name":      param.PayAccountName,
				"state":                 1,
			}
			filterMap := qutil.ObjToMap(value["filter"])
			(*filterMap)["isAll"] = 1
			filter_map, _ := json.Marshal(filterMap)
			updateData := map[string]interface{}{
				"applybill_status": 0,
				"filter":           string(filter_map),
				"pay_time":         (*transactionData)["BNKTIM"],
			}
			returnData := util.JysqlDB.SelectBySql(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code=? and state=1`, key)
			refundData := util.JysqlDB.SelectBySql(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code=?`, key)
			return_moneys := qutil.IntAll((*returnData)[0]["return_money"])
			refund_money := qutil.IntAll((*refundData)[0]["refund_money"])
			if return_money+return_moneys == refund_money {
				updateData["refund_status"] = 1
			} else if return_money+return_moneys > refund_money && refund_money > 0 {
				updateData["refund_status"] = 2
			}
			if return_money == qutil.IntAll(value["outstandingPayment"]) {
				updateData["return_status"] = 1
			} else {
				updateData["return_status"] = 2
			}
			if qutil.IntAll(value["order_status"]) == 0 {
				updateData["order_status"] = 1
			}
			contract := util.JysqlDB.FindOne("contract", map[string]interface{}{"order_code": qutil.ObjToString(value["order_code"])}, "", "")
			count := util.JysqlDB.Count("return_money_record", map[string]interface{}{"order_code": qutil.ObjToString(value["order_code"])})
			if count < 1 && contract != nil && qutil.IntAll((*contract)["contract_archive_status"]) != 1 {
				updateData["sale_time"] = (*transactionData)["BNKTIM"]
			}
			ok_1 := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"id": value["id"]}, updateData)
			ok_2 := util.JysqlDB.InsertByTx(tx, "return_money_record", insertData)
			if ok_1 && ok_2 != -1 {
				return_id = return_id + fmt.Sprint(ok_2) + ","
			} else {
				break
				return false
			}
		}
		//修改回款流水记录
		updateTransactionData := map[string]interface{}{
			"return_id":  return_id[:len(return_id)-1],
			"ISRELATION": 1,
		}
		ok1 := util.CbsDB.Update("transaction", map[string]interface{}{"id": (*transactionData)["id"]}, updateTransactionData)
		return ok1
	})

}

// 手动录入编辑回款信息
func ManualUpdateBatchReturnInfo(orderArr map[string]map[string]interface{}, operatePerson string, param *Return) bool {
	return util.JysqlDB.ExecTx("编辑回款信息", func(tx *sql.Tx) bool {
		return_id := ""
		for key, value := range orderArr {
			returnMoney := qutil.IntAll(value["realPrice"])
			insertData := map[string]interface{}{
				"order_code":            key,
				"return_time":           param.BNKTIM,
				"return_money":          returnMoney,
				"return_type":           param.ReturnType,
				"return_remark":         param.ReturnRemarks,
				"return_code":           param.ReturnCode,
				"bank_flow":             param.BNKFLW,
				"return_invoice_status": 0,
				"return_voucher_url":    value["returnVoucherUrl"],
				"flow_money":            param.ReturnMoney,
				"bank_name":             param.BNKNAM,
				"operate_person":        operatePerson,
				"operate_time":          qutil.NowFormat(qutil.Date_Full_Layout),
				"flow_type":             param.FlowType,
				"pay_account_name":      param.PayAccountName,
				"state":                 1,
			}
			filterMap := qutil.ObjToMap(value["filter"])
			(*filterMap)["isAll"] = 1
			filter_map, _ := json.Marshal(filterMap)
			updateData := map[string]interface{}{
				"applybill_status": 0,
				"filter":           string(filter_map),
				"pay_time":         param.BNKTIM,
			}
			returnData := util.JysqlDB.SelectBySql(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code=? and state=1`, key)
			refundData := util.JysqlDB.SelectBySql(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code=?`, key)
			return_moneys := qutil.IntAll((*returnData)[0]["return_money"])
			refund_money := qutil.IntAll((*refundData)[0]["refund_money"])
			if returnMoney+return_moneys == refund_money {
				updateData["refund_status"] = 1
			} else if returnMoney+return_moneys > refund_money && refund_money > 0 {
				updateData["refund_status"] = 2
			}
			if returnMoney == qutil.IntAll(value["outstandingPayment"]) {
				updateData["return_status"] = 1
			} else {
				updateData["return_status"] = 2
			}
			if qutil.IntAll(value["order_status"]) == 0 {
				updateData["order_status"] = 1
			}
			contract := util.JysqlDB.FindOne("contract", map[string]interface{}{"order_code": qutil.ObjToString(value["order_code"])}, "", "")
			count := util.JysqlDB.Count("return_money_record", map[string]interface{}{"order_code": qutil.ObjToString(value["order_code"])})
			if count < 1 && contract != nil && qutil.IntAll((*contract)["contract_archive_status"]) != 1 {
				updateData["sale_time"] = param.BNKTIM
			}
			ok1 := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"id": value["id"]}, updateData)
			ok2 := util.JysqlDB.InsertByTx(tx, "return_money_record", insertData)
			if ok1 && ok2 != -1 {
				return_id = return_id + fmt.Sprint(ok2) + ","
			} else {
				return false
			}
		}
		return true
	})

}

// 上传合同
func UpdateContractFile(id int, contractFileUrl string, orderData *map[string]interface{}) bool {
	filterMap := qutil.ObjToMap((*orderData)["filter"])
	(*filterMap)["contractStatus"] = 1
	filter_map, _ := json.Marshal(filterMap)
	updateData := map[string]interface{}{
		"contract_file_url": contractFileUrl,
	}
	return util.JysqlDB.ExecTx("上传合同", func(tx *sql.Tx) bool {
		ok_1 := util.JysqlDB.UpdateByTx(tx, "contract", map[string]interface{}{"id": id}, updateData)
		status := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"id": (*orderData)["id"]}, map[string]interface{}{
			"filter": string(filter_map),
		})
		return ok_1 && status
	})
}

func insertContractFile(orderCode string, contractFileUrl string, contractMoney int, orderData *map[string]interface{}) bool {
	updateData := map[string]interface{}{
		"contract_file_url": contractFileUrl,
		"order_code":        orderCode,
		"contract_money":    contractMoney,
	}
	filterMap := qutil.ObjToMap((*orderData)["filter"])
	(*filterMap)["contractStatus"] = 1
	filter_map, _ := json.Marshal(filterMap)
	return util.JysqlDB.ExecTx("新增合同记录", func(tx *sql.Tx) bool {
		ok_1 := util.JysqlDB.InsertByTx(tx, "contract", updateData)
		status := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"id": (*orderData)["id"]}, map[string]interface{}{
			"filter": string(filter_map),
		})
		return ok_1 > 0 && status
	})
}

// 广告和结构化数据订单详情
func SupplementaryOrder(res *map[string]interface{}) map[string]interface{} {
	// 产品信息
	orderMoney := qutil.Float64All((*res)["order_money"]) / 100
	(*res)["order_money"] = orderMoney

	filterMap := map[string]interface{}{}
	filterData := (*res)["filter"]
	if err := json.Unmarshal([]byte(filterData.(string)), &filterMap); err == nil {
		(*res)["product_name"] = filterMap["product"] //产品信息里的产品名称
		(*res)["remark"] = filterMap["remark"]        //备注
	}
	if (*res)["product_type"] == "历史数据" {
		(*res)["product_type"] = "历史数据导出"
	}
	if (*res)["data_spec"] == "1" {
		(*res)["data_spec"] = "高级字段包"
	} else if (*res)["data_spec"] == "2" {
		(*res)["data_spec"] = "标准字段包"
	} else if (*res)["data_spec"] == "3" {
		(*res)["data_spec"] = "自定义字段包"
	}
	// 回款信息
	returnInfo := util.JysqlDB.SelectBySql("SELECT COUNT(*)  count,SUM(return_money) money from return_money_record  WHERE order_code=? and  state=1", (*res)["order_code"])
	// 回款交易详情列表
	returnRes := util.JysqlDB.Find("return_money_record", map[string]interface{}{"order_code": (*res)["order_code"], "state": 1}, "", "", 0, 0)

	applybill_status := qutil.IntAll((*res)["applybill_status"])

	// 发票信息
	//returninvoceRes := util.JysqlDB.SelectBySql("SELECT DISTINCT return_invoice_status from return_money_record WHERE order_code=? ", (*res)["order_code"])
	(*res)["invoice"] = []map[string]interface{}{}
	if applybill_status == 1 || applybill_status == 2 || applybill_status == 3 {
		//2020-4-22电子发票
		data := util.JysqlDB.Find("invoice", map[string]interface{}{"order_code": (*res)["order_code"]}, "", "create_time desc", 0, 0)
		if *data != nil && len(*data) != 0 {
			invoiceList := []map[string]interface{}{}
			for _, invoiceData := range *data {
				switch qutil.IntAll(invoiceData["invoice_status"]) {
				case -1:
					invoiceData["invoice_status"] = "失败"
				case 0:
					invoiceData["invoice_status"] = "已申请"
				case 1:
					invoiceData["invoice_status"] = "已开具"
				case -2:
					invoiceData["invoice_status"] = "已冲红"
				}
				switch qutil.IntAll(invoiceData["source"]) {
				case 1:
					{
						invoiceData["source"] = "线下开票"         // 开票渠道
						invoiceData["apply_invoice_date"] = "" // 线下申请开票日期为空 线上取创建时间
					}
				default:
					{
						// 判断历史数据是不是线下的
						if qutil.ObjToString(invoiceData["operator"]) != "" {
							invoiceData["source"] = "线下开票"         // 开票渠道
							invoiceData["apply_invoice_date"] = "" // 线下申请开票日期为空 线上取创建时间
						} else {
							applyInvoiceDate := qutil.Int64All(invoiceData["create_time"])
							invoiceData["apply_invoice_date"] = qutil.FormatDateByInt64(&applyInvoiceDate, qutil.Date_Full_Layout) // 申请开票日期
							invoiceData["source"] = "线上开票"                                                                         // 开票渠道
							invoiceData["invoice_variety"] = "普通发票（电子发票）"                                                          // 发票种类
						}

					}
				}
				invoiceData["order_company"] = (*res)["company_name"] //公司名称取订单中的公司名称
				// 开票时间 转换
				billTime := qutil.Int64All(invoiceData["billing_time"])
				if billTime != 0 {
					invoiceData["billing_time"] = qutil.FormatDateByInt64(&billTime, qutil.Date_Full_Layout)
				}
				invoiceList = append(invoiceList, invoiceData)
			}
			(*res)["invoice"] = invoiceList
		}
		if qutil.IntAll((*res)["order_status"]) == -3 {
			(*res)["applybill_status"] = "已冲红"
		} else {
			(*res)["applybill_status"] = "已申请"
		}
		if applybill_status == 2 {
			(*res)["applybill_status"] = "已开具"
		}
		if applybill_status == 3 {
			(*res)["applybill_status"] = "部分开票"
		}
	} else if applybill_status == 0 {
		(*res)["applybill_status"] = "未申请"
	}
	// 合同
	contractRes := util.JysqlDB.FindOne("contract", map[string]interface{}{"order_code": (*res)["order_code"]}, "", "")

	result := map[string]interface{}{}
	delete(*res, "filter")
	//delete(*res, "order_money")
	//合同金额
	if contractRes != nil && len(*contractRes) != 0 {
		if (*contractRes)["contract_file_url"] != nil && len((*contractRes)["contract_file_url"].(string)) > 0 {
			index_ := strings.LastIndex((*contractRes)["contract_file_url"].(string), "/")
			if index_ != -1 {
				(*contractRes)["contract_file_name"] = (*contractRes)["contract_file_url"].(string)[index_+1:]
			}
		}
		result["contractRes"] = *contractRes
	} else {
		result["contractRes"] = map[string]interface{}{}
	}
	if returnRes != nil && len(*returnRes) != 0 {
		for _, d := range *returnRes {
			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:]
				}
			}
		}
		result["returnRes"] = *returnRes
	} else {
		result["returnRes"] = []map[string]interface{}{}
	}
	//退款信息
	refundRes := util.JysqlDB.Find("refund_record", map[string]interface{}{"order_code": (*res)["order_code"]}, "", "", 0, 0)
	if refundRes != nil && len(*refundRes) > 0 {
		result["refundRes"] = *refundRes
	} else {
		result["refundRes"] = []map[string]interface{}{}
	}
	result["res"] = *res
	result["filterData"] = filterMap
	result["returnInfo"] = returnInfo
	return result
}

// 创建课程订单
func createCourseOrder(param *CreateOtherOrderParams, code string) (bool, string) {
	//订单创建
	data, _ := util.MQFW.FindById("jy_course", param.CourseId, false)
	price := qutil.IntAll((*data)["i_price"])
	//生成订单号
	detail := map[string]interface{}{
		"_id":          param.CourseId,
		"s_fileUrl":    (*data)["s_fileUrl"],
		"s_picUrl":     (*data)["s_picUrl"],
		"s_courseDate": (*data)["s_courseDate"],
		"l_endtime":    (*data)["l_endtime"],
		"i_price":      price,
		"phone":        param.Phone,
		"courseType":   "中标必听课",
		"i_exist":      (*data)["i_exist"],
		"i_num":        (*data)["i_num"],
		"i_drawer":     (*data)["i_drawer"],
		"out_trade_no": param.OutTradeNo,
		"s_name":       (*data)["s_name"], //此处传课程展示的信息；比如课程名称 结束时间 图片之类的（"_id"课程mgo库id），
	}
	filterStr, _ := json.Marshal(detail)
	payWay := "wx_app"
	if param.ChargeMode == 1 {
		if param.Pay_way == "" {
			payWay = "transferAccounts"
		}
	}
	insertData := map[string]interface{}{
		"user_phone":           param.Phone,
		"product_type":         "中标必听课",
		"salesperson":          "",
		"filter":               string(filterStr),
		"order_code":           code,
		"original_price":       price,
		"create_time":          param.CreateTime, // 当前时间
		"prepay_time":          param.CreateTime,
		"order_money":          param.OrderMoney, // 2021-12-29 订单优化需求改为录入字段
		"pay_money":            param.ContractMoney,
		"is_backstage_order":   1,
		"order_status":         1,
		"out_trade_no":         code,
		"user_id":              param.UserId,
		"refund_status":        0,
		"company_name":         param.CompanyName,
		"billingMode":          param.ChargeMode,                                    //计费模式 0 免费  1 收费
		"sale_time":            qutil.If(param.SaleTime == "", nil, param.SaleTime), // 订单补录需求20210926 补充需求 该字段取订单时间
		"pay_way":              payWay,
		"commission":           param.Commission,      // 佣金 2021-12-29 订单优化需求新增字段
		"procedures_money":     param.ProceduresMoney, // 手续费 2021-12-29 订单优化需求新增字段
		"distribution_channel": param.SalesChannel,
		"order_channel":        param.OrderChannel,
		"signing_subject":      param.PaybackCompany,
		"filter_id":            param.CourseId,
		"audit_status":         param.AuditStatus,
	}
	if param.Pay_time != "" {
		insertData["pay_time"] = param.Pay_time
	}
	ok_1 := util.JysqlDB.Insert("dataexport_order", insertData)
	return ok_1 > 0, ""
}
func GetNameList(name string) (rs *[]map[string]interface{}) {
	if name != "" {
		rs = util.AdminDB.SelectBySql(fmt.Sprintf("select id,username from admin_user where status =1 and username like '%%%v%%'", name))

	} else {
		rs = util.AdminDB.SelectBySql("select id,username from admin_user where status =1")

	}

	return rs

}

// 企业订阅时间修改
func UpdateRule(entId int, update map[string]interface{}, phone string) bool {
	ok := false
	if entId > 0 && phone != "" {
		//查找之前数据是否存在
		userData := util.JysqlDB.FindOne("entniche_user", map[string]interface{}{
			"ent_id": entId,
			"phone":  phone,
		}, `id`, "")
		if userData == nil {
			return false
		}
		up1, up2 := map[string]interface{}{}, map[string]interface{}{}
		var tp int
		for k, v := range update {
			vm, ok := v.(map[string]interface{})
			if !ok {
				return false
			}
			up11, up22 := map[string]interface{}{}, map[string]interface{}{}
			key := ""
			for kk, vv := range vm {
				if (key == "" || key == "o_jy") && (kk == "o_jy" || strings.HasPrefix(kk, "o_jy.")) {
					key = "o_jy"
					up22[strings.ReplaceAll(kk, key, "o_entniche")] = vv
					tp = 2
				} else if (key == "" || key == "o_vipjy") && (kk == "o_vipjy" || strings.HasPrefix(kk, "o_vipjy.")) {
					key = "o_vipjy"
					up22[strings.ReplaceAll(kk, key, "o_entniche")] = vv
					tp = 1
				} else if (key == "" || key == "o_member_jy") && (kk == "o_member_jy" || strings.HasPrefix(kk, "o_member_jy.")) {
					key = "o_member_jy"
					up22[strings.ReplaceAll(kk, key, "o_entniche")] = vv
					tp = 1
				} else if (key == "" || key == "o_entniche") && (kk == "o_entniche" || strings.HasPrefix(kk, "o_entniche.")) {
					key = "o_entniche"
					up22[strings.ReplaceAll(kk, key, "o_entniche")] = vv
					tp = 0
				} else {
					up11[kk] = vv
				}
			}
			if len(up11) > 0 {
				up1[k] = up11
			}
			if len(up22) > 0 {
				up2[k] = up22
			}
		}
		ok1, ok2 := false, false
		//查看之前是否有数据
		data, ok := util.MQFW.Find("entniche_rule", map[string]interface{}{
			"i_entid":  entId,
			"i_userid": (*userData)["id"],
			"i_type":   tp,
		}, `{"i_time":-1}`, nil, false, -1, -1)
		if ok && len(*data) == 0 {
			up3 := map[string]interface{}{
				"$set": map[string]interface{}{"o_entniche.i_matchway": 1, "o_entniche.i_ratemode": 1, "o_entniche.i_wxpush": 1, "o_entniche.i_apppush": 1, "o_entniche.i_projectmatch": 0, "o_entniche.a_infotype": []string{}, "o_entniche.a_items": []string{}, "o_entniche.l_modifydate": time.Now().Unix()},
			}
			util.MQFW.Update("entniche_rule", map[string]interface{}{
				"i_entid":  entId,
				"i_userid": (*userData)["id"],
				"i_type":   tp,
			}, up3, true, false)
		}
		if len(up1) > 0 {
			ok1 = util.MQFW.Update("ent_user", map[string]interface{}{
				"i_entid":  entId,
				"i_userid": (*userData)["id"],
			}, up1, true, false)
		}
		if len(up2) > 0 {
			ok2 = util.MQFW.Update("entniche_rule", map[string]interface{}{
				"i_entid":  entId,
				"i_userid": (*userData)["id"],
				"i_type":   tp,
			}, up2, true, false)
		}
		//默认数据处理

		return ok1 || ok2
	}
	return ok
}

var productMap = map[string]interface{}{
	"1":  "广告",
	"2":  "结构化数据",
	"3":  "企业商机管理",
	"4":  "历史数据",
	"5":  "VIP订阅",
	"6":  "线下课程培训",
	"7":  "课程分销",
	"8":  "标书制作",
	"9":  "打赏",
	"10": "数据流量包",
	"11": "数据文件",
	"12": "ISO体系认证",
	"13": "3A信用认证",
	"14": "权益码",
}

// GetProductTypeByIndex  创建其他订单获取对应产品类型
func GetProductTypeByIndex(pIndex string, adSource int) (productType string, err error) {
	if pIndex == "1" {
		if _, ok := AdSourceMap[adSource]; !ok {
			return "", errors.New("广告来源有误")
		}
	}
	if productType, ok := productMap[pIndex]; ok {
		return qutil.InterfaceToStr(productType), nil
	}
	return "", errors.New("产品类型有误")
}