qmx_admin/src/order/otherOrderController.go

package order

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

	"github.com/baiy/Cadmin-server-go/admin"
	"go.mongodb.org/mongo-driver/bson"
)

/*20210517 订单补录需求增加
创建其他订单
添加回款信息
上传合同
*/

var AdSourceMap = map[int]string{
	1: "广告联盟",
	2: "微信流量主",
	3: "剑鱼广告位",
}

// 创建其他订单
type CreateOtherOrderParams struct {
	Phone                 string `form:"phone"`             //  手机号 必填
	ProductType           string `form:"productType"`       //  产品类型 必填
	SalesPerson           string `form:"salesPerson"`       //  销售人员 必填
	SalesPersonId         int    `form:"salesPersonId"`     //  销售人剑鱼后台id
	ContractTime          string `form:"contractTime"`      //  协议签订时间
	CustomerName          string `form:"customerName"`      //  客户名称
	ContractStatus        int    `form:"contractStatus"`    //  协议状态 1-已签协议 0-不签协议
	ContractMoney         int    `form:"contractMoney"`     //  合同金额 单位：分
	ContractCode          string `form:"contractCode"`      //  协议编号
	Product               string `form:"product"`           //  购买产品 增量数据、历史数据、增量+历史数据
	StartTime             string `form:"startTime"`         //  开始时间
	EndTime               string `form:"endTime"`           //  结束时间
	DataNum               int64  `form:"dataNum"`           //  数据条数
	DataType              string `form:"dataType"`          //  数据类型 高级、标准、自定义
	ContractFileUrl       string `form:"contract_file_url"` //  上传合同地址
	Remark                string `form:"remark"`            //  备注
	PersonNum             string `form:"personNum"`         //  人数
	CompanyName           string `form:"companyName"`       //公司名称
	Area                  string `form:"area"`              //超级订阅购买省份
	ChargeMode            int    `form:"chargeMode"`        //计费模式 0 免费 1 收费
	CycleCount            int    `form:"cycleCount"`        //周期
	CycleUnit             int    `form:"cycleUnit"`         //单位 (1:年 2:月 3:天 4:季)
	VipStartTime          string `form:"vipStartTime"`      //超级订阅开始时间
	IsOpen                int    `form:"isOpen"`            //0 暂不开通 1 开通
	OrderSource           int    `form:"orderSource"`       //订单来源
	AdSource              int    `form:"adSource"`          //广告来源 1:"广告联盟", 2:"微信流量主", 3:"剑鱼广告位",
	CreateTime            string `form:"createTime"`        // 创建时间
	VipType               int    `form:"vipType"`           //VIP类型 0 购买  1：续费 2：升级
	UserId                string `form:"userId"`            //用户标识
	OrderMoney            int    `form:"orderMoney"`
	DisCountPrice         int    `form:"disCountPrice"`
	Badge                 string `form:"badge"`
	PackId                string `form:"packId"`
	Commission            string `form:"commission"`              // 佣金
	ProceduresMoney       string `form:"proceduresMoney"`         // 手续费 单位分
	SalesChannel          string `form:"salesChannel"`            // 销售渠道
	OrderChannel          string `form:"orderChannel"`            // 下单渠道
	PaybackCompany        string `form:"paybackCompany"`          //签约主体  回款公司
	CourseId              string `form:"courseId"`                //课程标识
	OrderCode             string `form:"orderCode"`               //
	Transaction_id        string `form:"transaction_id"`          //
	Pay_time              string `form:"pay_time"`                //
	Pay_way               string `form:"pay_way"`                 //
	ReturnStatus          int    `form:"returnStatus"`            //
	OrderStatus           int    `form:"order_status"`            // 订单状态  0 未完成 1 已完成
	SaleTime              string `form:"sale_time"`               // 业务统计时间
	ContractArchiveStatus int    `form:"contract_archive_status"` // 协议归档状态 1 已归档 0 未归档
	ContractArchiveTime   string `form:"contract_archive_time"`   // 协议归档时间
	ContractArchiveNum    int    `form:"contract_archive_num"`    // 协议归档份数
	CreatePerson          string // 创建人
	UpdateType            int    `form:"updateType"` // 修改状态 0暂不开通修改 1开通修改
	OutTradeNo            string `form:"out_trade_no"`
	AuditStatus           int    // 审核状态 0：待提交  1：待审核  2：一审通过  3：审核通过 -2 一审退回  -3 二审退回
	Open                  bool   // 是否开通权限
	Save                  int    `form:"save"`       // 1-暂存 2-提交
	BuySubject            string `form:"buySubject"` //购买主体  1 个人， 2公司
	BuyCount              int    `form:"buyCount"`   //大会员、超级订阅购买数量
}
type UpdateReturnParams struct {
	Id                  int       `form:"id"`                  //订单id
	OrderCode           string    `form:"orderCode"`           //订单编号
	ReturnStatus        int       `form:"return_status"`       //回款状态
	ReturnTime          string    `form:"returnTime"`          //回款时间
	ReturnMoney         int       `form:"returnMoney"`         //回款金额 单位：分
	ReturnRemark        string    `form:"returnRemark"`        //回款说明 非必填
	ReturnType          int       `form:"returnType"`          //支付方式 1-微信 2-支付宝 3-对公转账',
	ReturnCode          string    `form:"returnCode"`          //回款单号
	ReturnInvoiceStatus int       `form:"returnInvoiceStatus"` //回款发票状态 回款发票状态,0-未申请 1-已申请 2-已开具
	ReturnVoucherUrl    string    `form:"returnVoucherUrl"`    //回款凭证地址
	OperateTime         time.Time `form:"operateTime"`         //操作时间
	OperatePerson       string    `form:"operate_person"`      //操作人
}

type Return struct {
	ReturnType       int                      `form:"returnType"`
	FlowType         int                      `form:"flowType"`
	ReturnCode       string                   `form:"returnCode"`
	TransactionId    int                      `form:"transactionId"`
	OrderArr         []map[string]interface{} `form:"orderArr"`
	ReturnVoucherUrl string                   `form:"returnVoucherUrl"`
	ReturnRemarks    string                   `form:"returnRemarks"`
	ReturnMoney      int                      `form:"returnMoney"`
	PayAccountName   string                   `form:"payAccountName"`
	BNKTIM           string                   `form:"BNKTIM"`
	BNKFLW           string                   `form:"BNKFLW"`
	BNKNAM           string                   `form:"BNKNAM"`
}

// 创建其他订单
func CreateOtherOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	//  根据url 判断是否是我的创建其他订单
	if context.Request.Call == "Baiy.Cadmin.Order.myCreateOtherOrder" {
		if param.Save == util.SAVE {
			// 暂存 订单审核状态为待提交
			param.AuditStatus = util.OrderUncommitted
		} else if param.Save == util.COMMIT {
			// 提交 我的创建订单 订单审核状态为待一审
			param.AuditStatus = util.OrderPending
		} else {
			return nil, errors.New("缺少提交类型")
		}
		// 订单状态为未完成
		param.OrderStatus = 0
		// 不开通权益
		param.Open = false
	} else {
		param.AuditStatus = util.OrderPassed // 0：待提交  1：待审核  2：一审通过  3：审核通过 -2 一审退回  -3 二审退回
		param.Open = true
	}
	param.CreateTime = qutil.NowFormat(qutil.Date_Full_Layout) // 取当前时间为创建时间
	if param.ProductType == "" {
		return nil, errors.New("缺少产品类型")
	}
	if param.ContractMoney < 0 {
		return nil, errors.New("缺少合同金额")
	}
	if param.SalesChannel == "" {
		return nil, errors.New("缺少销售渠道")
	}
	if param.OrderChannel == "" {
		return nil, errors.New("缺少下单渠道")
	}
	if param.PaybackCompany == "" {
		return nil, errors.New("缺少签约主体")
	}
	if param.BuySubject == "" {
		return nil, errors.New("缺少购买主体")
	}
	if param.BuySubject == "2" {
		if param.BuyCount == 0 && param.ProductType == "5" {
			return nil, errors.New("缺少购买数量")
		}
		if param.CompanyName == "" {
			return nil, errors.New("缺少公司名称")
		}
	}
	if param.ContractMoney != 0 { // 如果合同金额不为0 则计费模式为收费
		param.ChargeMode = 1
	}
	// 根据前端传过来的序号拿产品类型
	param.ProductType, err = GetProductTypeByIndex(param.ProductType, param.AdSource)
	if err != nil {
		return nil, err
	}
	param.CreatePerson = context.User.Username
	code := fmt.Sprintf("%s%s", time.Now().Format("150405"), qutil.GetRandom(6))

	if param.ProductType == "企业商机管理" {
		if !createEntnicheOrder(param, code) {
			return nil, errors.New("创建其他订单失败")
		}
	} else if param.ProductType == "VIP订阅" {
		if param.BuySubject != "2" {
			if ExistProcessOrder(param.Phone, SUPERSUB, "") {
				return nil, errors.New("该手机号存在未审核通过的单子")
			}
		}
		orderStatus, _ := createVipOrder(param, code)
		if !orderStatus {
			return nil, errors.New("创建VIP订单失败")
		}
	} else {
		if !createOtherOrder(param, code) {
			return nil, errors.New("创建其他订单失败")
		}
	}
	// 销售渠道为内部员工赠送及豁免用户赠送时更新用户人群分类
	var userId string
	if param.UserId != "" {
		userId = param.UserId
	} else {
		userId = GetUserIdByPhone(param.Phone)
	}
	if userId == "" {
		return nil, nil
	}
	if param.SalesChannel == util.SaleChannel052 || param.SalesChannel == util.SaleChannel053 {
		UpdateUserType(param.SalesChannel, userId)
	}
	// 如果是我的订单则新增审核轨迹 全部订单则新增为已通过  如果是暂存则不用新增
	if param.Save == util.SAVE {
		return nil, nil
	}
	saveData := map[string]interface{}{
		"operator":      context.User.Username,
		"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		"operator_type": util.OperateCreate,
		"audit_status":  param.AuditStatus,
		"order_code":    code,
		"audit_type":    util.AuditCreate,
	}
	if !InsertAudit(saveData) {
		return nil, errors.New("审核轨迹保存失败")
	}
	return nil, nil
}

// 修改其他订单
func UpdateOtherOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderCode == "" {
		return nil, errors.New("缺少订单编号")
	}
	if param.ProductType == "" {
		return nil, errors.New("缺少产品类型")
	}
	if param.ContractMoney < 0 {
		return nil, errors.New("缺少合同金额")
	}
	if param.SalesChannel == "" {
		return nil, errors.New("缺少销售渠道")
	}
	if param.OrderChannel == "" {
		return nil, errors.New("缺少下单渠道")
	}
	if param.PaybackCompany == "" {
		return nil, errors.New("缺少签约主体")
	}
	if param.BuySubject == "" {
		return nil, errors.New("缺少购买主体")
	}
	if param.BuySubject == "2" {
		if param.BuyCount == 0 && param.ProductType == "5" {
			return nil, errors.New("缺少购买数量")
		}
		if param.CompanyName == "" {
			return nil, errors.New("缺少公司名称")
		}
	}
	param.ProductType, err = GetProductTypeByIndex(param.ProductType, param.AdSource)
	if err != nil {
		return nil, err
	}
	if param.ContractMoney != 0 { // 如果合同金额不为0 则计费模式为收费
		param.ChargeMode = 1
	}
	param.CreatePerson = context.User.Username
	code := param.OrderCode
	//订单信息获取
	res := map[string]interface{}{}
	data := util.JysqlDB.SelectBySql("SELECT d.* FROM `dataexport_order` d WHERE d.order_code = ?", param.OrderCode)
	if data != nil && len(*data) > 0 {
		res = (*data)[0]
	} else {
		return nil, errors.New("查不到此订单")
	}

	// 全部订单-仅可编辑订单审核状态为已通过的订单
	auditStatus := res["audit_status"]
	saleChannel := qutil.ObjToString(res["distribution_channel"])
	if qutil.IntAll(auditStatus) != util.OrderPassed {
		return nil, errors.New("仅可编辑订单审核状态为已通过的订单")
	}
	//判断手机号是否修改
	userId, vipStatus := "", 0
	if res["user_phone"] != param.Phone {
		userData, ok := util.MQFW.FindOne("user", map[string]interface{}{"s_phone": param.Phone})
		if ok && userData != nil && len(*userData) > 0 {
			userId = mongodb.BsonIdToSId((*userData)["_id"])
			vipStatus = qutil.IntAll((*userData)["i_vip_status"])
		} else {
			userDatas, oks := util.MQFW.FindOne("user", map[string]interface{}{"s_m_phone": param.Phone})
			if oks && userDatas != nil && len(*userDatas) > 0 {
				userId = mongodb.BsonIdToSId((*userDatas)["_id"])
				vipStatus = qutil.IntAll((*userDatas)["i_vip_status"])
			}
		}
		if userId == "" {
			//没有用户需要新建用户
			data := map[string]interface{}{
				"i_appid":       2,
				"s_phone":       param.Phone,
				"s_password":    "",
				"l_registedate": time.Now().Unix(),
				"i_ts_guide":    2,
				"o_jy": map[string]interface{}{
					"i_apppush":    1,
					"i_ratemode":   2,
					"l_modifydate": time.Now().Unix(),
				},
				"s_regsource": "qmx_admin",
			}
			_id := util.MQFW.Save("user", data)
			log.Println("新增用户", _id)
			if _id != "" {
				userId = _id
				formdata := map[string]interface{}{
					"appid":    config.SysConfigs.AppId,
					"phone":    param.Phone,
					"password": "",
				}
				if !strings.HasPrefix(param.Phone, "9") {
					log.Println("addBaseUser start")
					ck := &http.Cookie{}
					usercenter.AddBaseUser(*util.MQFW, config.SysConfigs.UserCenterUrl, _id, formdata, ck)
					log.Println("addBaseUser end")
				} else {
					log.Println("prefix with 9")
				}

			}
		}
		if param.ProductType == "VIP订阅" && param.BuySubject != "2" {
			if vipStatus > 0 {
				return nil, errors.New("此手机号已有vip订阅权限，无法修改！")
			}
			//需要修改老用户上的订阅信息 企业用户不修改
			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{}{},   //设置行业
			}
			util.MQFW.UpdateById("user", qutil.ObjToString(res["user_id"]), bson.M{
				"$set": set,
			})
		}
		util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": qutil.ObjToString(param.OrderCode)}, map[string]interface{}{"user_phone": param.Phone, "user_id": userId})
	}

	//处理订单状态
	//原来实收金额
	payMoney := qutil.IntAll(qutil.If(res["pay_money"] == "", 0, res["pay_money"]))
	commission := qutil.IntAll(qutil.If(res["commission"] == "", 0, res["commission"]))
	proceduresMoney := qutil.IntAll(qutil.If(res["procedures_money"] == "", 0, res["procedures_money"]))
	originalPayMoney := payMoney - commission - proceduresMoney
	//修改后的金额
	nowPayMoney := param.ContractMoney - qutil.IntAll(param.Commission) - qutil.IntAll(param.ProceduresMoney)
	//查看是否需要修改
	returnStatus := qutil.IntAll(res["return_status"])
	if originalPayMoney != nowPayMoney {
		//价格变动了
		if returnStatus == 1 {
			returnStatus = 2
		}
	}

	if param.ProductType == "企业商机管理" {
		if !updateEntnicheOrder(param, code, returnStatus) {
			return nil, errors.New("编辑其他订单失败")
		}
	} else if param.ProductType == "VIP订阅" {
		orderStatus, _ := updateVipOrder(param, code, returnStatus)
		if !orderStatus {
			return nil, errors.New("编辑VIP订单失败")
		}
	} else {
		if !updateOtherOrder(param, code, returnStatus) {
			return nil, errors.New("编辑其他订单失败")
		}
	}
	// 判断是否需要修改用户类型
	// 销售渠道为内部员工赠送及豁免用户赠送时更新用户人群分类
	if (param.SalesChannel == util.SaleChannel052 || param.SalesChannel == util.SaleChannel053) && saleChannel != param.SalesChannel {
		UpdateUserType(param.SalesChannel, userId)
	}
	saveData := map[string]interface{}{
		"operator":      context.User.Username,
		"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		"operator_type": util.OperateEdit,
		"audit_status":  util.OrderPassed,
		"order_code":    code,
		"audit_type":    util.AuditCreate,
	}
	if !InsertAudit(saveData) {
		return nil, errors.New("审核轨迹保存失败")
	}
	return nil, nil
}

// 我的订单修改其他订单
func MyUpdateOtherOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderCode == "" {
		return nil, errors.New("缺少订单编号")
	}
	if param.ProductType == "" {
		return nil, errors.New("缺少产品类型")
	}
	if param.ContractMoney < 0 {
		return nil, errors.New("缺少合同金额")
	}
	if param.SalesChannel == "" {
		return nil, errors.New("缺少销售渠道")
	}
	if param.OrderChannel == "" {
		return nil, errors.New("缺少下单渠道")
	}
	if param.PaybackCompany == "" {
		return nil, errors.New("缺少签约主体")
	}
	if param.BuySubject == "" {
		return nil, errors.New("缺少购买主体")
	}
	if param.BuySubject == "2" {
		if param.BuyCount == 0 && param.ProductType == "5" {
			return nil, errors.New("缺少购买数量")
		}
		if param.CompanyName == "" {
			return nil, errors.New("缺少公司名称")
		}
	}
	param.ProductType, err = GetProductTypeByIndex(param.ProductType, param.AdSource)
	if err != nil {
		return nil, err
	}
	if param.ContractMoney != 0 { // 如果合同金额不为0 则计费模式为收费
		param.ChargeMode = 1
	}
	param.CreatePerson = context.User.Username
	code := param.OrderCode
	//订单信息获取
	res := map[string]interface{}{}
	data := GetOrderByCode(param.OrderCode)
	if data == nil || len(*data) == 0 {
		return nil, errors.New("查不到此订单")
	}
	res = *data
	auditStatus := qutil.IntAll(res["audit_status"])
	saleChannel := qutil.ObjToString(res["distribution_channel"])
	// 处理订单审核轨迹状态
	saveAuditStatus, err := SwitchAudit(auditStatus)
	if err != nil {
		return nil, err
	}
	//判断手机号是否修改
	userId, vipStatus := "", 0
	if res["user_phone"] != param.Phone {
		userData, ok := util.MQFW.FindOne("user", map[string]interface{}{"s_phone": param.Phone})
		if ok && userData != nil && len(*userData) > 0 {
			userId = mongodb.BsonIdToSId((*userData)["_id"])
			vipStatus = qutil.IntAll((*userData)["i_vip_status"])
		} else {
			userDatas, oks := util.MQFW.FindOne("user", map[string]interface{}{"s_m_phone": param.Phone})
			if oks && userDatas != nil && len(*userDatas) > 0 {
				userId = mongodb.BsonIdToSId((*userDatas)["_id"])
				vipStatus = qutil.IntAll((*userDatas)["i_vip_status"])
			}
		}
		if userId == "" {
			//没有用户需要新建用户
			userId = SaveUserInfo(param.Phone)
		}
		// 创建的时候  修改手机号需要移除原有账号权限、 升级续费的时候由于没有生成权限信息，所以不需要操作用户 企业用户无权限信息
		if param.ProductType == "VIP订阅" && param.VipType == 0 && param.BuySubject != "2" {
			if vipStatus > 0 {
				return nil, errors.New("此手机号已有vip订阅权限，无法修改！")
			}
			//需要修改老用户上的订阅信息
			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{}{},   //设置行业
			}
			util.MQFW.UpdateById("user", qutil.ObjToString(res["user_id"]), bson.M{
				"$set": set,
			})
		}
		util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": qutil.ObjToString(param.OrderCode)}, map[string]interface{}{"user_phone": param.Phone, "user_id": userId})
	}

	//处理订单状态
	//原来实收金额
	payMoney := qutil.IntAll(qutil.If(res["pay_money"] == "", 0, res["pay_money"]))
	commission := qutil.IntAll(qutil.If(res["commission"] == "", 0, res["commission"]))
	proceduresMoney := qutil.IntAll(qutil.If(res["procedures_money"] == "", 0, res["procedures_money"]))
	originalPayMoney := payMoney - commission - proceduresMoney
	//修改后的金额
	nowPayMoney := param.ContractMoney - qutil.IntAll(param.Commission) - qutil.IntAll(param.ProceduresMoney)
	//查看是否需要修改
	returnStatus := qutil.IntAll(res["return_status"])
	if originalPayMoney != nowPayMoney {
		//价格变动了
		if returnStatus == 1 {
			returnStatus = 2
		}
	}

	if param.ProductType == "企业商机管理" {
		if !updateEntnicheOrder(param, code, returnStatus) {
			return nil, errors.New("编辑其他订单失败")
		}
	} else if param.ProductType == "VIP订阅" {
		// 购买订单走原有编辑逻辑  开始时间为暂不开通
		if param.VipType == util.SuperSubCreate {
			param.VipStartTime = "2099-01-01"
			orderStatus, _ := updateVipOrder(param, code, returnStatus)
			if !orderStatus {
				return nil, errors.New("编辑VIP订单失败")
			}
		} else {
			// 升级和续费 只更新订单信息
			myUpdateSupSub(param, code, returnStatus)
		}

	} else {
		if !updateOtherOrder(param, code, returnStatus) {
			return nil, errors.New("编辑其他订单失败")
		}
	}
	// 判断是否需要修改用户类型
	// 销售渠道为内部员工赠送及豁免用户赠送时更新用户人群分类
	if (param.SalesChannel == util.SaleChannel052 || param.SalesChannel == util.SaleChannel053) && saleChannel != param.SalesChannel {
		UpdateUserType(param.SalesChannel, userId)
	}
	saveData := map[string]interface{}{
		"operator":      context.User.Username,
		"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		"operator_type": util.OperateEdit,
		"audit_status":  saveAuditStatus,
		"order_code":    code,
		"audit_type":    util.AuditCreate,
	}
	if !UpdateAudit(code, saveAuditStatus, saveData) {
		return nil, errors.New("更新订单审核状态及新增审核记录异常")
	}

	return nil, nil
}

// 修改订单
func UpdateOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderCode == "" {
		return nil, errors.New("缺少订单编号")
	}
	if param.SalesChannel == "" {
		return nil, errors.New("缺少销售渠道")
	}
	param.CreatePerson = context.User.Username
	insertData := map[string]interface{}{
		"salesperson":          param.SalesPerson,
		"salesperson_id":       param.SalesPersonId,
		"sale_time":            qutil.If(param.SaleTime == "", nil, param.SaleTime), // 业务统计时间,   // 业务统计时间
		"distribution_channel": param.SalesChannel,
		"last_update_person":   param.CreatePerson,
		"last_update_time":     qutil.NowFormat(qutil.Date_Full_Layout),
	}
	ok_1 := util.JysqlDB.Update("dataexport_order", map[string]interface{}{
		"order_code": param.OrderCode,
	}, insertData)
	if ok_1 {
		saveData := map[string]interface{}{
			"operator":      context.User.Username,
			"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
			"operator_type": util.OperateEdit,
			"audit_status":  util.OrderPassed,
			"order_code":    param.OrderCode,
			"audit_type":    util.AuditCreate,
		}
		if !InsertAudit(saveData) {
			return nil, errors.New("审核轨迹保存失败")
		}
		return nil, nil
	} else {
		return nil, errors.New("修改订单失败")
	}
}

// 编辑回款信息
func EditReturnMoneyInfo(context *admin.Context) (interface{}, error) {
	param := &UpdateReturnParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderCode == "" || param.ReturnMoney == 0 {
		return nil, errors.New("缺少关键参数")
	}
	//if param.ReturnVoucherUrl == "" {
	//	return nil, errors.New("缺少回款凭证")
	//}
	orderData := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"id": param.Id}, "", "")
	if orderData == nil || len(*orderData) == 0 {
		return nil, errors.New("未找到该订单")
	}
	return_status := qutil.IntAll((*orderData)["return_status"])
	if return_status == 1 {
		return nil, errors.New("订单已全额回款")
	}
	param.OperatePerson = context.User.Username
	status := UpdateReturnInfo(param, *orderData)
	return map[string]interface{}{"status": status}, nil
}

// 批量回款
func EditBatchReturnMoneyInfo(context *admin.Context) (interface{}, error) {
	param := &Return{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderArr == nil {
		return nil, errors.New("缺少关键参数")
	}
	status := false
	realPrice := 0
	orderArr := map[string]map[string]interface{}{}
	if param.FlowType == 0 {
		//cbs回款
		price := 0
		//查询回款流水记录
		transactionData := util.CbsDB.FindOne("transaction", map[string]interface{}{"id": param.TransactionId}, "return_id,BNKNAM,BNKFLW,id,ACTNBR,TRSBAL,BNKTIM,OTHNAM,NUSAGE", "")
		if transactionData == nil || len(*transactionData) == 0 || qutil.ObjToString((*transactionData)["return_id"]) != "" {
			return nil, errors.New("未找到该流水")
		}
		//查询订单金额
		for _, value := range param.OrderArr {
			orderData := util.JysqlDB.SelectBySql("select  (IFNULL( a.pay_money, 0 )-IFNULL(a.commission,0)-IFNULL(a.procedures_money,0))-(select  IFNULL(sum(b.return_money),0) from  return_money_record  b where b.order_code=a.order_code and  b.state=1) + (select  IFNULL(sum(c.refund_money),0) from refund_record c where c.order_code=a.order_code) as outstandingPayment, a.*  from  dataexport_order a where  a.id=?", value["orderId"])
			if orderData == nil {
				continue
			}
			if qutil.IntAll(value["money"]) > qutil.IntAll((*orderData)[0]["outstandingPayment"]) {
				return nil, errors.New(qutil.ObjToString((*orderData)[0]["order_code"]) + "回款金额过大")
			}
			(*orderData)[0]["realPrice"] = qutil.IntAll(value["money"]) //回款
			(*orderData)[0]["returnVoucherUrl"] = param.ReturnVoucherUrl
			realPrice += qutil.IntAll(value["money"])
			orderArr[qutil.ObjToString((*orderData)[0]["order_code"])] = (*orderData)[0]
			price = price + qutil.IntAll((*orderData)[0]["outstandingPayment"]) //剩余回款
		}
		if price == 0 {
			return nil, errors.New("订单回款失败，回款金额不符合")
		}
		money := int(math.Floor(float64(float64(qutil.Float64All((*transactionData)["TRSBAL"]))*100 + 0.5))) //流水
		if realPrice > price {
			return nil, errors.New("订单回款失败，回款金额不符合")
		}
		if money == realPrice {
			//回款操作
			operatePerson := context.User.Username
			status = UpdateBatchReturnInfo(transactionData, orderArr, operatePerson, param)
		} else {
			return nil, errors.New("订单回款失败，回款金额不符合")
		}
	} else {
		//手动录入回款
		//查询订单金额
		for _, value := range param.OrderArr {
			orderData := util.JysqlDB.SelectBySql("select  (IFNULL( a.pay_money, 0 )-IFNULL(a.commission,0)-IFNULL(a.procedures_money,0))-(select  IFNULL(sum(b.return_money),0) from  return_money_record  b where b.order_code=a.order_code and  b.state=1) + (select  IFNULL(sum(c.refund_money),0) from refund_record c where c.order_code=a.order_code) as outstandingPayment, a.*  from  dataexport_order a where  a.id=?", value["orderId"])
			if orderData == nil {
				continue
			}
			if qutil.IntAll(value["money"]) > qutil.IntAll((*orderData)[0]["outstandingPayment"]) {
				return nil, errors.New(qutil.ObjToString((*orderData)[0]["order_code"]) + "回款金额过大")
			}
			orderArr[qutil.ObjToString((*orderData)[0]["order_code"])] = (*orderData)[0]
			realPrice += qutil.IntAll(value["money"])
			(*orderData)[0]["realPrice"] = qutil.IntAll(value["money"]) //回款
			(*orderData)[0]["returnVoucherUrl"] = param.ReturnVoucherUrl
		}
		if param.ReturnMoney == realPrice {
			//回款操作
			operatePerson := context.User.Username
			status = ManualUpdateBatchReturnInfo(orderArr, operatePerson, param)
		} else {
			return nil, errors.New("订单回款失败，回款金额不符合")
		}
	}
	if status {
		return map[string]interface{}{"status": status}, nil
	} else {
		return nil, errors.New("订单回款失败")
	}
}

// 删除回款信息
func DeleteBatchReturnMoneyInfo(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Id string `form:"id"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.Id == "" {
		return nil, errors.New("缺少回款记录标识")
	}
	//先查看该回款是否存在
	returnData := util.JysqlDB.SelectBySql("select * from  return_money_record where  id =" + qutil.ObjToString(param.Id) + " and  state=1")
	if returnData == nil || len(*returnData) == 0 {
		return nil, errors.New("查不到该条回款记录信息")
	}
	status := util.JysqlDB.ExecTx("编辑回款信息", func(tx *sql.Tx) bool {
		//判断是cbs还是手动录入hffv
		if qutil.Int64All((*returnData)[0]["flow_type"]) == 0 {
			//cbs数据需要特殊处理
			cbsData := util.CbsDB.SelectBySql("select * from `transaction`  where  FIND_IN_SET(" + qutil.ObjToString(param.Id) + ",return_id)")
			if cbsData != nil && len(*cbsData) > 0 {
				//修改回款流水记录
				updateTransactionData := map[string]interface{}{
					"return_id":  "",
					"ISRELATION": 0,
				}
				ok_1 := util.CbsDB.Update("transaction", map[string]interface{}{"id": (*cbsData)[0]["id"]}, updateTransactionData)
				if !ok_1 {
					return false
				}
			}
			returnListData := &[]map[string]interface{}{}
			if qutil.ObjToString((*returnData)[0]["bank_flow"]) != "" {
				returnListData = util.JysqlDB.SelectBySql("select * from  return_money_record where  bank_flow ='" + qutil.ObjToString((*returnData)[0]["bank_flow"]) + "' and  state=1")
			} else {
				returnListData = returnData
			}
			for _, value := range *returnListData {
				//查看该订单是否还存在别的回款信息
				returnData = util.JysqlDB.SelectBySql("select * from  return_money_record where  order_code ='" + qutil.ObjToString(value["order_code"]) + "' and  state=1")
				if returnData == nil || len(*returnData) == 0 {
					return false
				}
				updateData := map[string]interface{}{
					"state": 0,
				}
				recordOk := util.JysqlDB.UpdateByTx(tx, "return_money_record", map[string]interface{}{"id": value["id"]}, updateData)
				if !recordOk {
					return false
				}
				orderData := map[string]interface{}{}
				if len((*returnData)) > 1 {
					//说明还有别的订单，订单回款需要改为部分回款
					orderData["return_status"] = 2
				} else if len((*returnData)) == 1 {
					//回款改为未回款
					orderData["return_status"] = 0
				}
				orderOk := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"order_code": value["order_code"]}, orderData)
				if !orderOk {
					return false
				}
			}
		} else {
			returnListData := &[]map[string]interface{}{}
			//手动录入处理简单,也会存在多个订单
			if qutil.Int64All((*returnData)[0]["return_type"]) == 3 {
				//回款方式，3-对公转账 通过银行流水号查找相同的
				returnListData = util.JysqlDB.SelectBySql("select * from  return_money_record where  bank_flow ='" + qutil.ObjToString((*returnData)[0]["bank_flow"]) + "' and  state=1 and return_type=3")
			} else {
				//回款方式，通过支付单号查找相同的
				returnListData = util.JysqlDB.SelectBySql("select * from  return_money_record where  return_code ='" + qutil.ObjToString((*returnData)[0]["return_code"]) + "' and  state=1 and  return_type!=3")
			}
			for _, value := range *returnListData {
				//查看该订单是否还存在别的回款信息
				returnData = util.JysqlDB.SelectBySql("select * from  return_money_record where  order_code ='" + qutil.ObjToString(value["order_code"]) + "' and  state=1")
				if returnData == nil || len(*returnData) == 0 {
					return false
				}
				updateData := map[string]interface{}{
					"state": 0,
				}
				recordOk := util.JysqlDB.UpdateByTx(tx, "return_money_record", map[string]interface{}{"id": value["id"]}, updateData)
				if !recordOk {
					return false
				}
				orderData := map[string]interface{}{}
				if len((*returnData)) > 1 {
					//说明还有别的订单，订单回款需要改为部分回款
					orderData["return_status"] = 2
				} else if len((*returnData)) == 1 {
					//回款改为未回款
					orderData["return_status"] = 0
				}
				orderOk := util.JysqlDB.UpdateByTx(tx, "dataexport_order", map[string]interface{}{"order_code": value["order_code"]}, orderData)
				if !orderOk {
					return false
				}
			}
		}
		return true
	})
	if status {
		return nil, err
	} else {
		return nil, errors.New("订单回款失败")
	}
}

// 回款流水
func CollectionFlow(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Offset        int    `form:"offset"`
		PageSize      int    `form:"pageSize"`
		CorporateName string `form:"corporateName"` //
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	status := true
	if param.CorporateName == "" {
		return map[string]interface{}{"status": status, "list": []map[string]interface{}{}, "total": 0}, nil
	}
	transactionList := util.CbsDB.SelectBySql("select NUSAGE,BNKNAM,BNKFLW,id,TRSBAL,BNKTIM,OTHNAM from  transaction where   OTHNAM=? and   ISRELATION =0  order by BNKTIM desc limit ? , ? ", param.CorporateName, param.Offset, param.PageSize)
	count := util.CbsDB.CountBySql("select count(id) from  transaction where   OTHNAM=? and   ISRELATION =0  ", param.CorporateName)

	return map[string]interface{}{"status": status, "list": transactionList, "total": count}, nil
}

// 订单剩余回款计算
func SurplusPrice(context *admin.Context) (interface{}, error) {
	param := new(struct {
		OrderArr []map[string]interface{} `form:"orderArr"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.OrderArr == nil {
		return nil, errors.New("请填入订单信息")
	}
	price := int(0)
	for key, value := range param.OrderArr {
		orderData := util.JysqlDB.SelectBySql("select  (IFNULL( a.pay_money, 0 )-IFNULL(a.commission,0)-IFNULL(a.procedures_money,0))-(select  IFNULL(sum(b.return_money),0) from  return_money_record  b where b.order_code=a.order_code and  b.state=1) + (select  IFNULL(sum(c.refund_money),0) from refund_record c where c.order_code=a.order_code) as outstandingPayment, a.*  from  dataexport_order a where  a.id=?", value["orderId"])
		if orderData == nil {
			continue
		}
		param.OrderArr[key]["money"] = qutil.IntAll((*orderData)[0]["outstandingPayment"])
		price += qutil.IntAll((*orderData)[0]["outstandingPayment"])
	}
	status := true
	return map[string]interface{}{"status": status, "orderArr": param.OrderArr, "price": price}, nil
}

// 上传合同
func UploadContractFile(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Id              int    `form:"contractId"`
		ContractFileUrl string `form:"contractFileUrl"`
		OrderCode       string `form:"orderCode"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	if param.ContractFileUrl == "" {
		return nil, errors.New("缺少合同文件")
	}
	orderData := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, "", "")
	contractData := util.JysqlDB.FindOne("contract", map[string]interface{}{"id": param.Id}, "", "")
	var status bool
	if contractData == nil || len(*contractData) == 0 {
		if orderData == nil || len(*orderData) == 0 {
			return nil, errors.New("未找到该订单")
		} else {
			status = insertContractFile(param.OrderCode, param.ContractFileUrl, qutil.IntAll((*orderData)["order_money"]), orderData)
		}
	} else {
		status = UpdateContractFile(param.Id, param.ContractFileUrl, orderData)
	}
	return map[string]interface{}{"status": status}, nil
}

// 更新订单内容
func UpdateSalesperson(context *admin.Context) (interface{}, error) {
	param := new(struct {
		OrderCode   string `form:"orderCode"`   //订单编号
		Salesperson string `form:"salesperson"` //销售人员名称
		Phone       string `form:"phone"`       //变更后手机号
		UserPhone   string `form:"userPhone"`   //变更前手机号
		UserId      string `form:"userId"`      //用户id
		StartTime   int64  `form:"startTime"`   //开始日期
		Cycle       int    `form:"cycle"`       //周期
		CycleType   int    `form:"cycleType"`   //周期类型
		SaleTime    string `form:"saleTime"`    //销售统计日期
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	log.Println(param)
	orderData := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, "filter,is_backstage_order,sale_time", "")
	if param.Phone == "" && param.Salesperson == "" && param.StartTime == 0 && param.SaleTime == "" {
		return nil, errors.New("输入内容不能为空")
	}
	if param.Phone != "" {
		userData, ok := util.MQFW.FindOne("user", map[string]interface{}{"s_phone": param.Phone})
		userId, memberStatus := "", 0
		if ok && userData != nil && len(*userData) > 0 {
			userId = mongodb.BsonIdToSId((*userData)["_id"])
			memberStatus = qutil.IntAll((*userData)["i_member_status"])
		} else {
			userDatas, oks := util.MQFW.FindOne("user", map[string]interface{}{"s_m_phone": param.Phone})
			if oks && userDatas != nil && len(*userDatas) > 0 {
				userId = mongodb.BsonIdToSId((*userDatas)["_id"])
				memberStatus = qutil.IntAll((*userDatas)["i_member_status"])
			}
		}
		if memberStatus > 0 {
			return nil, errors.New("此手机号已有大会员权限，无法修改！")
		}
		if userId == "" {
			datas, oks := util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
			memberState, bigStart, bigEnd, paySub, freeSub := 0, int64(0), int64(0), 0, 0
			if oks && datas != nil && len(*datas) > 0 {
				memberState = qutil.IntAll((*datas)["i_member_status"])
				bigStart = qutil.Int64All((*datas)["i_member_starttime"])
				bigEnd = qutil.Int64All((*datas)["i_member_endtime"])
				paySub = qutil.IntAll((*datas)["i_pay_sub_num"])
				freeSub = qutil.IntAll((*datas)["i_free_sub_num"])
			}
			if memberState > 0 {
				return nil, errors.New("订单大会员权益已经生效，无法修改！")
			}
			data := map[string]interface{}{
				"i_appid":       2,
				"s_phone":       param.Phone,
				"s_password":    "",
				"l_registedate": time.Now().Unix(),
				"i_ts_guide":    2,
				"o_jy": map[string]interface{}{
					"i_apppush":    1,
					"i_ratemode":   2,
					"l_modifydate": time.Now().Unix(),
				},
				"s_regsource":        "qmx_admin",
				"i_mainaccount":      1,
				"i_member_status":    memberState,
				"i_member_starttime": bigStart,
				"i_member_endtime":   bigEnd,
				"i_pay_sub_num":      paySub,
				"i_free_sub_num":     freeSub,
			}
			_id := util.MQFW.Save("user", data)
			log.Println("新增用户", _id)
			if _id != "" {
				userId = _id
				formdata := map[string]interface{}{
					"appid":    config.SysConfigs.AppId,
					"phone":    param.Phone,
					"password": "",
				}
				if !strings.HasPrefix(param.Phone, "9") {
					log.Println("addBaseUser start")
					ck := &http.Cookie{}
					usercenter.AddBaseUser(*util.MQFW, config.SysConfigs.UserCenterUrl, _id, formdata, ck)
					log.Println("addBaseUser end")
				} else {
					log.Println("prefix with 9")
				}

			}
		} else {
			datas, oks := util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
			memberState, bigStart, bigEnd, paySub, freeSub := 0, int64(0), int64(0), 0, 0
			if oks && datas != nil && len(*datas) > 0 {
				memberState = qutil.IntAll((*datas)["i_member_status"])
				bigStart = qutil.Int64All((*datas)["i_member_starttime"])
				bigEnd = qutil.Int64All((*datas)["i_member_endtime"])
				paySub = qutil.IntAll((*datas)["i_pay_sub_num"])
				freeSub = qutil.IntAll((*datas)["i_free_sub_num"])
			}
			if memberState > 0 {
				return nil, errors.New("大会员权益已经生效，无法修改！")
			}
			sets := map[string]interface{}{
				"i_member_status":    memberState,
				"i_member_starttime": bigStart,
				"i_member_endtime":   bigEnd,
				"i_mainaccount":      1,
			}
			if paySub > 0 || freeSub > 0 {
				sets["i_pay_sub_num"] = paySub
				sets["i_free_sub_num"] = freeSub
			}
			set := map[string]interface{}{
				"$set": sets,
			}
			util.MQFW.UpdateById("user", userId, set)
		}
		subData, okss := util.MQFW.Find("user", map[string]interface{}{"s_member_mainid": param.UserId}, nil, nil, false, -1, -1)
		if okss && subData != nil && len(*subData) > 0 {
			for _, v := range *subData {
				util.MQFW.UpdateById("user", mongodb.BsonIdToSId(v["_id"]), map[string]interface{}{"$set": map[string]interface{}{"s_member_mainid": userId}})
			}
		}
		oks := util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{"user_phone": param.Phone, "user_id": userId})
		oks = util.JysqlDB.Update("dataexport_order", map[string]interface{}{"user_phone": param.UserPhone}, map[string]interface{}{"user_phone": param.Phone, "user_id": userId})
		if oks {
			okss := util.JysqlDB.Update("bigmember_service_user", map[string]interface{}{"s_userid": param.UserId}, map[string]interface{}{"s_userid": userId})
			if okss {
				log.Println("用户服务表修改用户id成功", param.UserId, userId)
				if strings.HasPrefix(param.UserPhone, "9") {
					util.MQFW.Del("user", map[string]interface{}{"s_phone": param.UserPhone})
					util.JysqlDB.Delete("user", map[string]interface{}{"user_id": param.UserId})
				}
			} else {
				log.Println("用户服务表修改用户id失败", param.UserId, userId)
			}
		} else {
			log.Println("订单表修改用户手机号失败", param.OrderCode, param.Phone)
		}
		RedisDel(userId)
		ClearBigVipUserPower(userId)
		return map[string]interface{}{"status": ok}, nil
	}
	if param.Salesperson != "" {
		ok := util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{"salesperson": param.Salesperson})
		return map[string]interface{}{"status": ok}, nil
	}
	if param.StartTime != 0 {
		startdate := time.Unix(param.StartTime, 0)
		enddate := GetDATE(param.Cycle, param.CycleType, param.StartTime)
		filterMap := qutil.ObjToMap((*orderData)["filter"])
		(*filterMap)["effective_date"] = enddate.Format("2006/01/02")
		filter_map, _ := json.Marshal(filterMap)
		set := map[string]interface{}{
			"$set": map[string]interface{}{
				"i_member_starttime": param.StartTime,
				"i_member_endtime":   enddate.Unix(),
			},
		}
		_, max := GetDayMinMax(time.Now())
		datas, oks := util.MQFW.FindOne("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)})
		log.Println(datas, oks)
		memberState, buyStart := 0, int64(0)
		if oks && datas != nil && len(*datas) > 0 {
			memberState = qutil.IntAll((*datas)["i_member_status"])
			buyStart = qutil.Int64All((*datas)["i_member_starttime"])
		}
		log.Println(buyStart, time.Now().Unix())
		if time.Now().Unix() >= buyStart {

			if !strings.HasPrefix(param.UserPhone, "9") {
				return nil, errors.New("大会员权益已生效，不能修改开始时间！")
			}
		}
		if param.StartTime < max {
			set = map[string]interface{}{
				"$set": map[string]interface{}{
					"i_member_starttime": param.StartTime,
					"i_member_endtime":   enddate.Unix(),
					"i_member_status":    qutil.If(memberState > 0, memberState, -memberState),
				},
			}
			util.JysqlDB.Update("bigmember_service_user", map[string]interface{}{"s_userid": param.UserId}, map[string]interface{}{
				"l_starttime": qutil.FormatDate(&startdate, qutil.Date_Full_Layout),
				"l_endtime":   qutil.FormatDate(&enddate, qutil.Date_Full_Layout),
				"i_status":    0,
			})
		} else {
			util.JysqlDB.Update("bigmember_service_user", map[string]interface{}{"s_userid": param.UserId}, map[string]interface{}{
				"l_starttime": qutil.FormatDate(&startdate, qutil.Date_Full_Layout),
				"l_endtime":   qutil.FormatDate(&enddate, qutil.Date_Full_Layout),
			})
		}
		util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{
			"vip_starttime": qutil.FormatDate(&startdate, qutil.Date_Full_Layout),
			"vip_endtime":   qutil.FormatDate(&enddate, qutil.Date_Full_Layout),
			"filter":        string(filter_map),
		})
		// 同步修改子账号的有效时间  查询条件为大会员订单的创建时间同一天的和手机号。
		//1.   计算出当天的时间范围
		orderData2 := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, "filter,create_time,user_phone", "")
		today, _ := time.ParseInLocation(qutil.Date_Full_Layout, qutil.ObjToString((*orderData2)["create_time"]), time.Local)
		updateSubPhone := (*orderData2)["user_phone"]
		createMin, createMax := GetDayMinMax(today)
		//2. 根据查询条件查询出需要更新订单
		log.Println("userphone")
		subDataList := util.JysqlDB.SelectBySql("select * from dataexport_order where user_phone=? and create_time>=? and create_time<=?", updateSubPhone, qutil.FormatDateByInt64(&createMin, qutil.Date_Full_Layout), qutil.FormatDateByInt64(&createMax, qutil.Date_Full_Layout))
		if subDataList != nil && len(*subDataList) > 0 {
			//3. 执行更新操作
			for _, subData := range *subDataList {
				//	 拿出原来的filter
				filterMapSub := qutil.ObjToMap((subData)["filter"])
				// 修改有效周期
				(*filterMapSub)["effective_date"] = enddate.Format("2006/01/02")
				filter_map_sub, _ := json.Marshal(filterMapSub)
				// 执行更新
				util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": (subData)["order_code"]}, map[string]interface{}{
					"filter": string(filter_map_sub),
				})
			}
		} else {
			log.Println("未找到与之关联的订单", param.OrderCode, param.UserPhone, qutil.FormatDateByInt64(&createMin, qutil.Date_Full_Layout), qutil.FormatDateByInt64(&createMax, qutil.Date_Short_Layout))

		}

		util.MQFW.UpdateById("user", param.UserId, set)
		RedisDel(param.UserId)
		ClearBigVipUserPower(param.UserId)
	}

	// 订单补录需求0926 补充需求添加
	if param.SaleTime != "" {
		if orderData != nil {
			isBack := (*orderData)["is_backstage_order"]
			log.Println(isBack, (*orderData))
			if qutil.IntAll(isBack) == 1 {
				return nil, errors.New("后台创建订单不可修改销售统计时间")

			} else {
				orderSaleTime := (*orderData)["sale_time"]
				if orderSaleTime != nil {
					return nil, errors.New("线上的单子修改后不能再次修改")
				}
			}
		}
		ok := util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{"sale_time": param.SaleTime})
		return map[string]interface{}{"status": ok}, nil
	}
	return map[string]interface{}{"status": true}, nil
}

func GetDayMinMax(t time.Time) (int64, int64) {
	min := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local).Unix()
	return min, min + 86400
}

// 创建超级订阅订单选择升级、续费回显结束日期
func VipInfo(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Phone      string `form:"phone"`
		OrderCode  string `form:"orderCode"`
		BuySubject string `form:"buySubject"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	var willEffect bool
	//先判断用户是否有即将生效的超级订阅订单
	query := map[string]interface{}{
		"s_phone": param.Phone,
		"l_vip_starttime": map[string]interface{}{
			"$gt": time.Now().Unix(),
		},
	}
	log.Println(query)
	count1 := util.MQFW.Count("user", query)
	if count1 > 0 {
		willEffect = true
	} else {
		query2 := map[string]interface{}{
			"s_m_phone": param.Phone,
			"l_vip_starttime": map[string]interface{}{
				"$gt": time.Now().Unix(),
			},
		}
		count2 := util.MQFW.Count("user", query2)
		if count2 > 0 {
			willEffect = true
		}
	}
	if param.OrderCode != "" && willEffect == true { // 如果是编辑订单并且用户开始时间大于当前时间，需要再验证一下是否
		notStart := ExistNotStartOrder(param.Phone, SUPERSUB, param.OrderCode)
		if !notStart {
			willEffect = false
		}
	}
	// 增加如若存在订单审核状态为“待一审”、“待二审”、“已退回”的超级订阅订单的则不允许创建
	if ExistProcessOrder(param.Phone, SUPERSUB, param.OrderCode) {
		willEffect = true
	}
	if willEffect {
		return map[string]interface{}{
			"willEffect": true,
		}, nil
	}
	//判断用户购买过超级订阅并且在有效期内   i_vip_status 开启状态：0-暂不使用vip订阅 1-试用 2-正式 -1-试用到期 -2-正式到期
	userInfo := map[string]interface{}{}
	userData, ok := util.MQFW.FindOneByField("user", map[string]interface{}{"s_phone": param.Phone, "i_vip_status": 2}, `{"_id":1,"i_vip_expire_tip":1,"i_vip_status":1,"l_vip_endtime":1,"l_vip_starttime":1,"o_vipjy":1}`)
	if ok && userData != nil && len(*userData) > 0 {
		userInfo = *userData
	} else {
		userDatas, oks := util.MQFW.FindOneByField("user", map[string]interface{}{"s_m_phone": param.Phone, "i_vip_status": 2}, `{"_id":1,"i_vip_expire_tip":1,"i_vip_status":1,"l_vip_endtime":1,"l_vip_starttime":1,"o_vipjy":1}`)
		if oks && userDatas != nil && len(*userDatas) > 0 {
			userInfo = *userDatas
		} else {
			return map[string]interface{}{
				"willEffect": false,
				"userData":   nil,
				"vipExist":   false,
			}, nil
		}
	}
	if userInfo != nil && len(userInfo) > 0 {
		log.Println(userInfo)
		userId := mongodb.BsonIdToSId(userInfo["_id"])
		//查询订单信息获取客户名称
		orderInfo := util.JysqlDB.SelectBySql("SELECT c.customer_name,d.company_name FROM dataexport_order d LEFT JOIN contract c ON c.order_code = d.order_code WHERE product_type = 'VIP订阅' and user_id = ? ORDER BY d.id DESC", userId)
		if len(*orderInfo) == 0 && param.BuySubject != "2" {
			return nil, errors.New("查询订单表没有查到订单信息")
		}
		vipInfo := qutil.ObjToMap(userInfo["o_vipjy"])
		buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
		areaCount := qutil.IntAll((*buySet)["areacount"])
		//判断购买区域是否是全国
		nationwide := false
		//log.Println(area)
		if areaCount == -1 {
			nationwide = true
		}
		if areaCount == -1 {
			areaCount = 0
		}
		//area := qutil.ObjToMap((*vipInfo)["o_area"])
		userInfo["areaCount"] = areaCount
		//判断是新版超级订阅还是老版超级订阅
		newVip := false
		if qutil.IntAll((*buySet)["upgrade"]) == 1 {
			newVip = true
		}
		t := qutil.Int64All(userInfo["l_vip_endtime"])
		_t := time.Unix(t, 0)
		userInfo["vipStartTime"] = (_t.AddDate(0, 0, 1)).Format(qutil.Date_Short_Layout)
		data := map[string]interface{}{
			"willEffect": false,
			"vipExist":   true,
			"nationwide": nationwide,
			"userData":   userInfo,
			"newVip":     newVip,
		}
		if len((*orderInfo)) > 0 {
			data["orderInfo"] = (*orderInfo)[0]
		}
		return data, nil
	}
	return map[string]interface{}{
		"willEffect": false,
		"userData":   nil,
		"vipExist":   false,
		"nationwide": false,
		"new":        false,
	}, nil
	//return nil, nil
}

func CreateVipOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	param.Area = "北京"
	param.VipStartTime = time.Now().Format(qutil.Date_Short_Layout)
	param.CreateTime = time.Now().Format(qutil.Date_Full_Layout)
	param.ProductType = "VIP订阅"
	param.ChargeMode = 1
	param.VipType = 0
	param.ContractStatus = 0
	param.VipType = 0
	newCity := []int{}
	subvipBuySet := &util.SubvipBuySet{
		Upgrade:         0,
		AreaCount:       1,
		NewCitys:        newCity,
		BuyerclassCount: -1,
	}
	renew_price := 0
	if param.CycleUnit != 3 {
		renew_price = util.GetSubVipPriceByBuySet(subvipBuySet, param.CycleCount, param.CycleUnit, false)
	}

	param.ContractMoney = renew_price
	//查找之前是否开通超级订阅
	userInfo, oks := util.MQFW.FindOneByField("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId)}, `{"_id":1,"i_vip_expire_tip":1,"i_vip_status":1,"l_vip_endtime":1,"l_vip_starttime":1,"o_vipjy":1,"s_m_phone":1,"s_phone":1}`)
	if oks && userInfo != nil && len(*userInfo) > 0 {
		if (*userInfo)["s_phone"] == nil {
			param.Phone = fmt.Sprint((*userInfo)["s_m_phone"])
		} else {
			param.Phone = fmt.Sprint((*userInfo)["s_phone"])
		}
		//先判断用户是否有即将生效的超级订阅订单
		query := map[string]interface{}{
			"_id": mongodb.StringTOBsonId(param.UserId),
			"l_vip_starttime": map[string]interface{}{
				"$gt": time.Now().Unix(),
			},
		}
		count1 := util.MQFW.Count("user", query)
		if count1 > 0 {
			//有即将生效的
			//查询到截止时间
			//查询订单信息获取客户名称
			vipInfo := qutil.ObjToMap((*userInfo)["o_vipjy"])
			buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
			areaCount := qutil.IntAll((*buySet)["areacount"])
			if areaCount == -1 {
				//全国省份
			} else {
				//单个省份
				oArea := qutil.ObjToMap((*vipInfo)["o_area"])
				area := ""
				for key, _ := range *oArea {
					area += key + ","
				}
				if len(area) > 0 {
					area = area[:len(area)-1]
				}
				param.Area = area
			}
			t := qutil.Int64All((*userInfo)["l_vip_endtime"])
			_t := time.Unix(t, 0)
			vipStartTime := (_t.AddDate(0, 0, 1)).Format(qutil.Date_Short_Layout)
			param.StartTime = vipStartTime
			param.VipStartTime = vipStartTime
			param.VipType = 1
			newCity, _ := (*buySet)["newcitys"].([]interface{})
			subvipBuySet := &util.SubvipBuySet{
				Upgrade:         qutil.IntAll((*buySet)["upgrade"]),
				AreaCount:       qutil.IntAll((*buySet)["areacount"]),
				NewCitys:        util.ConfirmIntArr(newCity),
				BuyerclassCount: qutil.IntAll((*buySet)["buyerclasscount"]),
			}
			if param.CycleUnit != 3 {
				renew_price = util.GetSubVipPriceByBuySet(subvipBuySet, param.CycleCount, param.CycleUnit, false)
			}
			param.ContractMoney = renew_price
		}
		//查询是有是超级订阅的数据
		//判断用户购买过超级订阅并且在有效期内   i_vip_status 开启状态：0-暂不使用vip订阅 1-试用 2-正式 -1-试用到期 -2-正式到期
		userDatas, oks := util.MQFW.FindOneByField("user", map[string]interface{}{"_id": mongodb.StringTOBsonId(param.UserId), "i_vip_status": 2}, `{"_id":1,"i_vip_expire_tip":1,"i_vip_status":1,"l_vip_endtime":1,"l_vip_starttime":1,"o_vipjy":1}`)
		if oks && userDatas != nil && len(*userDatas) > 0 {
			//正在生效的
			if fmt.Sprint((*userInfo)["i_vip_status"]) == "2" {
				//查询订单信息获取客户名称
				vipInfo := qutil.ObjToMap((*userInfo)["o_vipjy"])
				buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
				areaCount := qutil.IntAll((*buySet)["areacount"])
				if areaCount == -1 {
					//全国省份
					param.Area = "全国"
				} else {
					//单个省份
					oArea := qutil.ObjToMap((*vipInfo)["o_area"])
					area := ""
					for key, _ := range *oArea {
						area += key + ","
					}
					if len(area) > 0 {
						area = area[:len(area)-1]
					}
					param.Area = area
				}
				t := qutil.Int64All((*userInfo)["l_vip_endtime"])
				_t := time.Unix(t, 0)
				vipStartTime := (_t.AddDate(0, 0, 1)).Format(qutil.Date_Short_Layout)
				param.StartTime = time.Now().Format(qutil.Date_Short_Layout)
				param.VipStartTime = vipStartTime
				param.VipType = 1
				newCity, _ := (*buySet)["newcitys"].([]interface{})
				subvipBuySet := &util.SubvipBuySet{
					Upgrade:         qutil.IntAll((*buySet)["upgrade"]),
					AreaCount:       qutil.IntAll((*buySet)["areacount"]),
					NewCitys:        util.ConfirmIntArr(newCity),
					BuyerclassCount: qutil.IntAll((*buySet)["buyerclasscount"]),
				}
				if param.CycleUnit != 3 {
					renew_price = util.GetSubVipPriceByBuySet(subvipBuySet, param.CycleCount, param.CycleUnit, false)
				}
				param.ContractMoney = renew_price
			}
		}
	}
	code := fmt.Sprintf("%s%s", time.Now().Format("150405"), qutil.GetRandom(6))
	//param.OrderMoney = param.ContractMoney
	param.DisCountPrice = param.ContractMoney
	param.Badge = "give"
	param.ChargeMode = 0
	param.ProceduresMoney = "0"
	param.OrderChannel = "xdqd02"
	param.Commission = "0"
	param.SalesChannel = util.SaleChannel051
	param.PaybackCompany = "h01"
	param.OrderStatus = 1
	param.AuditStatus = 3 // 0：待提交  1：待审核  2：一审通过  3：审核通过 -2 一审退回  -3 二审退回
	param.Open = true     // 开通权限
	fool, endTime := createVipOrder(param, code)
	if !fool {
		return nil, errors.New("创建VIP订单失败")
	}
	saveData := map[string]interface{}{
		"operator":      "_",
		"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		"operator_type": util.OperateCreate,
		"audit_status":  util.OrderPassed,
		"order_code":    code,
		"audit_type":    util.AuditCreate,
	}
	if !InsertAudit(saveData) {
		return nil, errors.New("审核轨迹保存失败")
	}
	return map[string]interface{}{
		"code":         code,
		"vipStartTime": param.VipStartTime,
		"vipEndTime":   endTime,
	}, nil
}

func CreateResourcesOrder(context *admin.Context) (interface{}, error) {
	param := &CreateOtherOrderParams{}
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	param.ProductType = "数据流量包"
	param.ProceduresMoney = "0"
	param.OrderChannel = "xdqd02"
	param.Commission = "0"
	param.SalesChannel = util.SaleChannel051
	param.PaybackCompany = "h01"
	param.OrderStatus = 1
	param.CreateTime = qutil.NowFormat(qutil.Date_Full_Layout) // 取当前时间为创建时间
	param.AuditStatus = 3                                      // 0：待提交  1：待审核  2：一审通过  3：审核通过 -2 一审退回  -3 二审退回
	param.Open = true                                          // 开通权限
	code := fmt.Sprintf("%s%s", time.Now().Format("150405"), qutil.GetRandom(6))
	if !createOtherOrder(param, code) {
		return nil, errors.New("创建数据流量包订单失败")
	}
	saveData := map[string]interface{}{
		"operator":      "_",
		"create_time":   qutil.NowFormat(qutil.Date_Full_Layout),
		"operator_type": util.OperateCreate,
		"audit_status":  util.OrderPassed,
		"order_code":    code,
		"audit_type":    util.AuditCreate,
	}
	if !InsertAudit(saveData) {
		return nil, errors.New("审核轨迹保存失败")
	}
	return map[string]interface{}{
		"code": code,
	}, nil

}
func NameList(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Name string `form:"name"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	rs := GetNameList(param.Name)
	var names []map[string]interface{}
	if rs != nil && len(*rs) > 0 {
		names = *rs
	}
	return map[string]interface{}{
		"lists": names,
		"total": len(names),
	}, nil
}