seller-api/service/order.go

package service

import (
	"bkb-seller/global"
	"bkb-seller/initialize/api"
	"bkb-seller/model"
	"bkb-seller/model/request"
	"bkb-seller/utils"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"mime/multipart"
	"os"
	"sync/atomic"
	"time"

	"github.com/360EntSecGroup-Skylar/excelize/v2"
	"github.com/w3liu/go-common/constant/timeformat"
)

func GetUserOrderList(storeNo string, info *request.SearchOrderList) (error, interface{}, int64) {
	var (
		err       error
		result    []model.OrderList
		total     int64
		orderIds  []string
		customers []string
	)

	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	db := global.MG_DB.Model(&model.Order{}).Where("`order`.store_no = ?", storeNo)
	if info.Status != 0 {
		db = db.Where("`order`.status = ?", info.Status)
	}
	if info.OrderID != "" {
		db = db.Where("`order`.order_id = ?", info.OrderID)
	}
	if info.GoodsID != 0 {
		db = db.Where("`order`.commod_id=?", info.GoodsID)
	}
	if info.Name != "" {
		db = db.Joins("INNER JOIN order_address on order_address.order_id=`order`.order_id").Where("CONCAT(order_address.first_name,order_address.last_name) LIKE ? OR CONCAT(order_address.first_name,' ',order_address.last_name) LIKE ?", "%"+info.Name+"%", "%"+info.Name+"%")
	}
	if info.Phone != "" {
		db = db.Joins("inner join order_address b on b.phone=? and b.order_id=`order`.order_id", info.Phone)
	}
	if info.CreatedAtStart != "" {
		db.Where("`order`.created_at >= ?", info.CreatedAtStart)
	}
	if info.CreatedAtEnd != "" {
		db.Where("`order`.created_at < ?", info.CreatedAtEnd)
	}
	if info.Code != "" {
		db = db.Where("`order`.code=?", info.Code)
	}
	if info.CreatedAt != "" {
		db = db.Where("`order`.created_at>=?", info.CreatedAt)
	}
	if info.UserId != "" {
		db = db.Where("`order`.user_id = ?", info.UserId)
	}
	if info.InfluenceId != "" {
		db = db.Joins("INNER JOIN mission_claim ON mission_claim.claim_no = `order`.`code`").Where("mission_claim.create_by = ?", info.InfluenceId)
	}
	if info.SpuNo != "" {
		db = db.Joins("INNER JOIN order_goods ON order_goods.order_id = `order`.order_id").Where("order_goods.spu_no = ?", info.SpuNo)
	}
	_ = db.Count(&total).Error
	err = db.Order("`order`.id desc").Offset(offset).Limit(limit).Find(&result).Error
	if err != nil {
		return errors.New("获取订单失败"), result, total
	}
	if len(result) == 0 {
		return nil, result, total
	}
	for v := range result {
		orderIds = append(orderIds, result[v].OrderID)
	}
	var (
		orderGoodsList []model.OrderGoodsDetail
		goodsMap       = make(map[string]model.OrderGoodsDetail)
	)
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id IN (?)", orderIds).Find(&orderGoodsList).Error
	if err != nil {
		return errors.New("获取订单商品信息失败"), result, total
	}
	for _, goods := range orderGoodsList {
		goodsMap[goods.OrderID] = goods
	}
	var (
		addressList []model.OrderAddress
		addressMap  = make(map[string]model.OrderAddress)
	)
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id in (?)", orderIds).Find(&addressList).Error
	if err != nil {
		return errors.New("获取订单商品信息失败"), result, total
	}
	for _, address := range addressList {
		addressMap[address.OrderID] = address
	}
	var (
		delivers   []model.OrderDeliver
		deliverMap = make(map[string]model.OrderDeliver)
	)
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id in (?)", orderIds).Find(&delivers).Error
	if err != nil {
		return errors.New("获取订单发货信息失败"), result, total
	}
	for _, deliver := range delivers {
		deliverMap[deliver.OrderID] = deliver
	}
	var codes []string
	for v := range result {
		if val, ok := goodsMap[result[v].OrderID]; ok {
			result[v].Goods = val
		}
		if val, ok := addressMap[result[v].OrderID]; ok {
			result[v].Address = val
		}

		if val, ok := deliverMap[result[v].OrderID]; ok {
			result[v].Deliver = val
		}
		if result[v].Code != "" {
			codes = append(codes, result[v].Code)
		}
		customers = append(customers, result[v].UserID)
	}
	var (
		missionMap    = make(map[string]model.MissionClaimInfo)
		influencerMap = make(map[string]model.InfluencerUserClaimView)
	)
	if len(codes) > 0 {
		var (
			missions       []model.MissionClaimInfo
			influencerList []model.InfluencerUserClaimView
		)
		err = global.MG_DB.Select("mission_claim.claim_no,mission_claim.mission_id,b.hire_type,b.hire_money,b.hire_ratio").Model(&model.MissionClaim{}).Joins("inner join mission b on mission_claim.mission_id=b.id").Where("claim_no in (?)", codes).Scan(&missions).Error
		if err != nil {
			return errors.New("获取任务详情失败"), result, total
		}
		for _, mission := range missions {
			missionMap[mission.ClaimNo] = mission
		}
		err = global.MG_DB.Select("`user`.uuid,`user`.nick_name,`user`.phone,mission_claim.claim_no").Model(&model.MissionClaim{}).Joins("inner join `user` on mission_claim.create_by=`user`.uuid").Where("`user`.`type` = 'influencer' AND mission_claim.claim_no in (?)", codes).Scan(&influencerList).Error
		if err != nil {
			return errors.New("获取任务网红失败"), result, total
		}
		for _, influencer := range influencerList {
			influencerMap[influencer.ClaimNo] = influencer
		}
	}
	var customerMap = make(map[string]model.UserSimple)
	if len(customers) > 0 {
		var customerList []model.UserSimple
		customerList, err = getUserSimpleList("customer", customers)
		if err != nil {
			return errors.New("获取买家详情失败"), result, total
		}
		for _, user := range customerList {
			customerMap[user.UUID.String()] = user
		}
	}
	for v := range result {
		if result[v].Code != "" {
			if val, ok := missionMap[result[v].Code]; ok {
				if val.HireType == 1 {
					amount := val.HireMoney * float64(result[v].Number)
					result[v].InfluencerAmount = utils.FormatFloatToString(amount)
					result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice - amount)
				} else {
					amount := result[v].PaidPrice * val.HireRatio / 100
					result[v].InfluencerAmount = utils.FormatFloatToString(amount)
					result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice - amount)
				}
			}
			if val, ok := influencerMap[result[v].Code]; ok {
				result[v].InfluencerUser = val
			}
		} else {
			result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice)
		}
		if val, ok := customerMap[result[v].UserID]; ok {
			if val.Phone != "" {
				result[v].CustomerPhone = utils.HideStar(val.Phone)
			}
		}
	}
	return nil, result, total
}

func GetUserOrderDetail(storeNo string, info *request.SearchOrderDetail) (error, interface{}) {
	var (
		err      error
		result   model.OrderDetail
		missions model.MissionClaimInfo
	)
	err = global.MG_DB.Model(&model.Order{}).Where("`order`.store_no = ? AND `order`.order_id = ?", storeNo, info.OrderID).First(&result).Error
	if err != nil {
		return errors.New("获取订单失败"), result
	}
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id = ?", info.OrderID).Find(&result.Address).Error
	if err != nil {
		return errors.New("获取订单地址失败"), result
	}
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id = ?", info.OrderID).Find(&result.Goods).Error
	if err != nil {
		return errors.New("获取订单商品信息失败"), result
	}
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id = ?", info.OrderID).Find(&result.Deliver).Error
	if err != nil {
		return errors.New("获取发货信息失败"), result
	}
	if result.Code != "" {
		err = global.MG_DB.Select("mission_claim.claim_no,mission_claim.mission_id,b.hire_type,b.hire_money,b.hire_ratio").Model(&model.MissionClaim{}).Joins("inner join mission b on mission_claim.mission_id=b.id").Where("claim_no=?", result.Code).Scan(&missions).Error
		if err != nil {
			fmt.Println(err)
			return errors.New("获取任务详情失败"), result
		}
		if missions.HireType == 1 {
			amount := missions.HireMoney * float64(result.Number)
			result.InfluencerAmount = utils.FormatFloatToString(amount)
			result.SellerAmount = utils.FormatFloatToString((result.PaidPrice - amount))
		} else {
			amount := result.PaidPrice * missions.HireRatio / 100
			result.InfluencerAmount = utils.FormatFloatToString(amount)
			result.SellerAmount = utils.FormatFloatToString(result.PaidPrice - amount)
		}
	}
	result.Chain = model.Chain{Address: "b714e5508531a7b50d0696abdc83d2333bd896db24f68eb1470bb9529390ef3e"}
	return nil, result
}

func SendOrder(storeNo string, info *request.SendOrder) error {
	var (
		err     error
		courier model.Courier
		order   model.Order
	)
	// 校验物流信息
	err = global.MG_DB.Model(&model.Courier{}).Where("`name` = ?", info.Courier).First(&courier).Error
	if err != nil {
		return errors.New("courier company name is failed or not currently supported")
	}
	err = global.MG_DB.Model(&model.Order{}).Where("order_id=?", info.OrderID).Find(&order).Error
	if err != nil {
		return errors.New("获取订单数据失败")
	}
	if order.Status != 2 {
		return errors.New("订单状态不允许发货")
	}
	var trackId uint
	trackId, err = CreateTrack(info.CourierNumber, courier.Code)
	if err != nil {
		fmt.Println("提交物流单号:", err.Error())
		return errors.New("物流单号有误，发货失败")
	}
	tx := global.MG_DB.Begin()
	var deliver model.OrderDeliver
	deliver.OrderID = info.OrderID
	deliver.Courier = info.Courier
	deliver.CourierNumber = info.CourierNumber
	deliver.CourierLink = info.CourierLink
	err = tx.Create(&deliver).Error
	if err != nil {
		tx.Rollback()
		return errors.New("发货失败")
	}
	err = tx.Model(&model.Order{}).Where("order_id = ?", info.OrderID).Updates(map[string]interface{}{"send_time": time.Now(), "status": 3}).Error
	if err != nil {
		tx.Rollback()
		return errors.New("发货失败")
	}
	err = tx.Model(&model.OrderDeliver{}).Where("order_id = ?", info.OrderID).Update("track_id", trackId).Error
	if err != nil {
		tx.Rollback()
		return nil
	}
	tx.Commit()
	global.MG_DB.Model(&model.BatchDeliver{}).Where("user_id=? and order_id=?", storeNo, info.OrderID).Update("status", 1)
	return nil
}

func SendOrderBatch(storeNo string, info model.PutDeliver) error {
	var (
		err          error
		order        model.Order
		orderIds     []string
		courierNames []string
		couriers     []model.Courier
		courierMap   = make(map[string]string)
	)
	//删除批量发货记录
	for _, val := range info.Data {
		orderIds = append(orderIds, val.OrderID)
		courierNames = append(courierNames, val.Courier)
	}
	err = global.MG_DB.Model(&model.Courier{}).Where("`name` IN (?)", courierNames).Select("`name`,`code`").Find(&couriers).Error
	if err != nil {
		return errors.New("get courier info error")
	}
	for _, courier := range couriers {
		courierMap[courier.Name] = courier.Code
	}
	global.MG_DB.Model(&model.BatchDeliver{}).Where("order_id in (?)", orderIds).Delete(&model.BatchDeliver{})
	for _, val := range info.Data {
		var courierCode string
		// 校验物流信息
		if v, ok := courierMap[val.Courier]; ok {
			courierCode = v
		} else {
			var bDeliver model.BatchDeliver
			bDeliver.UserID = storeNo
			bDeliver.Courier = val.Courier
			bDeliver.CourierNumber = val.CourierNumber
			bDeliver.CourierLink = val.CourierLink
			bDeliver.OrderID = val.OrderID
			bDeliver.Status = 2
			bDeliver.Remark = "物流公司暂不支持或输入错误"
			global.MG_DB.Create(&bDeliver)
			continue
		}
		err = global.MG_DB.Model(&model.Order{}).Where("order_id = ?", val.OrderID).Find(&order).Error
		if err != nil {
			var bDeliver model.BatchDeliver
			bDeliver.UserID = storeNo
			bDeliver.Courier = val.Courier
			bDeliver.CourierNumber = val.CourierNumber
			bDeliver.CourierLink = val.CourierLink
			bDeliver.OrderID = val.OrderID
			bDeliver.Status = 2
			bDeliver.Remark = "获取订单失败"
			global.MG_DB.Create(&bDeliver)
			continue
		}
		if order.Status != 2 || order.CaptureID == "" {
			var bDeliver model.BatchDeliver
			bDeliver.UserID = storeNo
			bDeliver.Courier = val.Courier
			bDeliver.CourierNumber = val.CourierNumber
			bDeliver.CourierLink = val.CourierLink
			bDeliver.OrderID = val.OrderID
			bDeliver.Status = 2
			bDeliver.Remark = "订单状态不允许发货"
			global.MG_DB.Create(&bDeliver)
			continue
		}
		var trackId uint
		trackId, err = CreateTrack(val.CourierNumber, courierCode)
		if err != nil {
			return errors.New("物流单号：" + val.CourierNumber + "有误，发货失败。")
		}
		tx := global.MG_DB.Begin()
		err = tx.Model(&model.OrderDeliver{}).Where("order_id = ?", val.OrderID).Delete(&model.OrderDeliver{}).Error
		if err != nil {
			tx.Rollback()
			continue
		}
		var deliver model.OrderDeliver
		deliver.OrderID = val.OrderID
		deliver.Courier = val.Courier
		deliver.CourierNumber = val.CourierNumber
		deliver.CourierLink = val.CourierLink
		err = tx.Create(&deliver).Error
		if err != nil {
			tx.Rollback()
			var bDeliver model.BatchDeliver
			bDeliver.UserID = storeNo
			bDeliver.Courier = deliver.Courier
			bDeliver.CourierNumber = deliver.CourierNumber
			bDeliver.CourierLink = val.CourierLink
			bDeliver.OrderID = deliver.OrderID
			bDeliver.Status = 2
			bDeliver.Remark = "订单发货失败"
			global.MG_DB.Create(&bDeliver)
			continue
		}
		err = tx.Model(&model.Order{}).Where("order_id=?", val.OrderID).Updates(map[string]interface{}{"send_time": time.Now(), "status": 3}).Error
		if err != nil {
			tx.Rollback()
			var bDeliver model.BatchDeliver
			bDeliver.UserID = storeNo
			bDeliver.Courier = deliver.Courier
			bDeliver.CourierNumber = deliver.CourierNumber
			bDeliver.CourierLink = val.CourierLink
			bDeliver.OrderID = deliver.OrderID
			bDeliver.Status = 2
			bDeliver.Remark = "订单发货失败"
			global.MG_DB.Create(&bDeliver)
			continue
		}
		var bDeliver model.BatchDeliver
		bDeliver.UserID = storeNo
		bDeliver.Courier = deliver.Courier
		bDeliver.CourierNumber = deliver.CourierNumber
		bDeliver.CourierLink = val.CourierLink
		bDeliver.OrderID = deliver.OrderID
		bDeliver.Status = 1
		tx.Create(&bDeliver)
		err = tx.Model(&model.OrderDeliver{}).Where("order_id = ?", val.OrderID).Update("track_id", trackId).Error
		if err != nil {
			tx.Rollback()
			continue
		}
		tx.Commit()
	}
	return nil
}

// 生成24位订单号
// 前面17位代表时间精确到毫秒，中间3位代表进程id，最后4位代表序号
var num int64

func Generate() string {
	t := time.Now()
	s := t.Format(timeformat.Continuity)
	m := t.UnixNano()/1e6 - t.UnixNano()/1e9*1e3
	ms := sup(m, 3)
	p := os.Getpid() % 1000
	ps := sup(int64(p), 3)
	i := atomic.AddInt64(&num, 1)
	r := i % 10000
	rs := sup(r, 4)
	n := fmt.Sprintf("%s%s%s%s", s, ms, ps, rs)
	return n
}

// 对长度不足n的数字前面补0
func sup(i int64, n int) string {
	m := fmt.Sprintf("%d", i)
	for len(m) < n {
		m = fmt.Sprintf("0%s", m)
	}
	return m
}

func ImportSendOrderExcel(fileBuf multipart.File, fileName string) (error, interface{}) {
	var (
		err    error
		flag   bool
		orderD []model.OrderDeliver
	)
	f, err := excelize.OpenReader(fileBuf)
	if err != nil {
		return err, nil
	}
	// Get all the rows in the Sheet1.
	list := f.GetSheetList()
	rows, err := f.GetRows(list[0])
	if err != nil {
		return err, nil
	}
	for i, row := range rows {
		flag = false
		for _, cell := range row {
			fmt.Println(cell)
		}
		if i >= 1 {
			var deliver model.OrderDeliver
			for j, cell := range row {
				switch j {
				case 0:
					if cell == "" {
						flag = true
					}
					deliver.OrderID = cell
				case 1:
					if cell == "" {
						flag = true
					}
					deliver.CourierNumber = cell
				case 2:
					if cell == "" {
						flag = true
					}
					deliver.Courier = cell
				case 3:
					if cell == "" {
						flag = true
					}
					deliver.CourierLink = cell
				}
				if flag {
					break
				}
				// fmt.Print(cell)
			}
			if !flag {
				orderD = append(orderD, deliver)
			}
		}
		if flag {
			break
		}
	}
	return nil, orderD
}

func GetBatchSendList(storeNo string, info *request.SearchBatchList) (error, interface{}, int64) {
	var (
		err    error
		data   []model.BatchDeliverList
		limit  int
		offset int
		total  int64
	)
	limit = info.PageSize
	offset = info.PageSize * (info.Page - 1)
	db := global.MG_DB.Model(&model.BatchDeliver{})
	if info.Status != 0 {
		db = db.Where("status=?", info.Status)
	}
	db = db.Where("user_id = ?", storeNo)
	err = db.Count(&total).Error
	if err != nil {
		return errors.New("获取总数失败"), data, total
	}
	err = db.Offset(offset).Limit(limit).Find(&data).Error
	if err != nil {
		return errors.New("获取订单失败"), data, total
	}
	return nil, data, total
}

func GetBatchSendListTotal(storeNo string) (error, interface{}) {
	var (
		err  error
		data model.BatchDeliverTotal
	)
	db := global.MG_DB.Model(&model.BatchDeliver{})
	db = db.Select("count(*) total,sum(case when status=1 then 1 else 0 end) status1,sum(case when status=2 then 1 else 0 end) status2")
	err = db.Where("user_id=?", storeNo).Scan(&data).Error
	if err != nil {
		return errors.New("获取发货统计失败"), data
	}
	return nil, data
}

func getOrderDetail(id string) (model.OrderDetail, error) {
	var (
		err    error
		result model.OrderDetail
	)
	err = global.MG_DB.Model(&model.Order{}).Where("order_id = ?", id).Find(&result).Error
	if err != nil {
		return result, err
	}
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id = ?", id).Find(&result.Goods).Error
	if err != nil {
		return result, errors.New("获取订单商品信息失败")
	}
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id = ?", id).Find(&result.Address).Error
	if err != nil {
		return result, errors.New("获取订单商品信息失败")
	}
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id = ?", id).Find(&result.Deliver).Error
	if err != nil {
		return result, errors.New("获取订单发货信息失败")
	}
	//result.Customer, _ = getUserSimple("customer", result.UserID)
	{
		statistics, _ := getStatisticsOrderGoods(result.Goods.SkuNo, "", nil)
		result.Goods.Sales = statistics.SaleVolume
	}
	{
		var timeArea = make([]string, 2)
		now := time.Now()
		timeArea[0] = now.AddDate(0, 0, -29).Format(utils.DateFormat)
		timeArea[1] = now.AddDate(0, 0, 1).Format(utils.DateFormat)
		statistics, _ := getStatisticsOrderGoods(result.Goods.SkuNo, "", timeArea)
		result.Goods.Sales30 = statistics.SaleVolume
	}
	return result, nil
}
func getOrderDetailList(ids []string) ([]model.OrderDetail, error) {
	var (
		err    error
		result []model.OrderDetail
	)
	err = global.MG_DB.Model(&model.Order{}).Where("order_id IN (?)", ids).Find(&result).Error
	if err != nil {
		return nil, err
	}
	var (
		orderGoodsList []model.OrderGoodsDetail
		orderGoodsMap  = make(map[string]model.OrderGoodsDetail)
		addressList    []model.OrderAddress
		addressMap     = make(map[string]model.OrderAddress)
		delivers       []model.OrderDeliver
		deliverMap     = make(map[string]model.OrderDeliver)
	)
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id IN (?)", ids).Find(&orderGoodsList).Error
	if err != nil {
		return nil, errors.New("获取订单商品信息失败")
	}
	for _, goodsDetail := range orderGoodsList {
		orderGoodsMap[goodsDetail.OrderID] = goodsDetail
	}
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id in (?)", ids).Find(&addressList).Error
	if err != nil {
		return nil, errors.New("获取订单商品信息失败")
	}
	for _, address := range addressList {
		addressMap[address.OrderID] = address
	}
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id in (?)", ids).Find(&delivers).Error
	if err != nil {
		return nil, errors.New("获取订单发货信息失败")
	}
	for _, deliver := range delivers {
		deliverMap[deliver.OrderID] = deliver
	}
	var (
		uuids   []string
		userMap = make(map[string]model.UserSimple)
	)
	for i := 0; i < len(result); i++ {
		uuids = append(uuids, result[i].UserID)
		if val, ok := orderGoodsMap[result[i].OrderID]; ok {
			result[i].Goods = val
		}
		if val, ok := addressMap[result[i].OrderID]; ok {
			result[i].Address = val
		}
		if val, ok := deliverMap[result[i].OrderID]; ok {
			result[i].Deliver = val
		}
	}
	{
		userList, _ := getUserSimpleList("customer", uuids)
		for _, user := range userList {
			userMap[user.UUID.String()] = user
		}
	}
	for i := 0; i < len(result); i++ {
		if val, ok := userMap[result[i].UserID]; ok {
			result[i].Customer = val
		}
	}
	return result, nil
}

func GetOrderPostSale(storeNo string, info *request.IdReq) (error, model.OrderPostSaleDetail) {
	var (
		err    error
		result model.OrderPostSaleDetail
	)
	err = global.MG_DB.Model(&model.OrderPostSale{}).Where("store_no = ? AND id = ?", storeNo, info.ID).
		First(&result).Error
	if err != nil {
		return err, result
	}
	result.Order, err = getOrderDetail(result.OrderID)
	return err, result
}

func GetOrderPostSaleList(storeNo string, info *request.SearchOrderPostSale) (error, []model.OrderPostSaleDetail, int64) {
	var (
		err    error
		total  int64
		result []model.OrderPostSaleDetail
	)
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	db := global.MG_DB.Model(&model.OrderPostSale{}).Joins("INNER JOIN `order` ON `order`.order_id = order_post_sale.order_id").Where("order_post_sale.store_no = ?", storeNo)
	if info.OrderId != "" {
		db = db.Where("`order`.order_id = ?", info.OrderId)
	}
	switch info.Status {
	case 1:
		db = db.Where("order_post_sale.status = 1")
	case 2:
		db = db.Where("order_post_sale.status = 2 AND order_post_sale.refund_status = 0")
	case 3:
		db = db.Where("order_post_sale.status = 2 AND order_post_sale.refund_status = 1")
	case 4:
		db = db.Where("order_post_sale.status = 2 AND order_post_sale.refund_status = 2")
	}
	if info.ConfirmTimeStart != "" {
		db = db.Where("`order`.confirm_time >= ?", info.ConfirmTimeStart)
	}
	if info.ConfirmTimeEnd != "" {
		db = db.Where("`order`.confirm_time < ?", info.ConfirmTimeEnd)
	}
	_ = db.Count(&total).Error
	err = db.Order("order_post_sale.id desc").Offset(offset).Limit(limit).Find(&result).Error
	if err != nil {
		return err, nil, 0
	}
	var (
		orderIds     []string
		reasonValues []string
		orderList    []model.OrderDetail
		orderMap     = make(map[string]model.OrderDetail)
	)
	for _, detail := range result {
		reasonValues = append(reasonValues, detail.Reason)
		orderIds = append(orderIds, detail.OrderID)
	}
	orderList, err = getOrderDetailList(orderIds)
	if err != nil {
		return err, result, total
	}
	for _, detail := range orderList {
		orderMap[detail.OrderID] = detail
	}
	dictDataMap, _ := getSysDictDataMap("return_goods_reason", reasonValues...)
	for i := 0; i < len(result); i++ {
		if val, ok := orderMap[result[i].OrderID]; ok {
			result[i].Order = val
		}
		if val, ok := dictDataMap[result[i].Reason]; ok {
			result[i].ReasonDesc = val
		}
	}
	return err, result, total
}

func ExamineOrderPostSale(storeNo string, info *request.ExamineOrderPostSale) error {
	var (
		err      error
		updateM  = make(map[string]interface{})
		postSale model.OrderPostSale
	)
	err = global.MG_DB.Model(&model.OrderPostSale{}).Where("store_no = ? AND id = ?", storeNo, info.Id).First(&postSale).Error
	if err != nil {
		return errors.New("get post sale record error")
	}
	updateM["examine_time"] = time.Now()
	if info.Status == 1 { // 审核通过
		updateM["status"] = 2        // 已审核
		updateM["refund_status"] = 1 // 退款中
	} else if info.Status == 2 { // 审核不通过
		updateM["status"] = 3 // 已拒绝
		updateM["remark"] = info.Remark
	} else {
		return errors.New("status incorrect value")
	}
	tx := global.MG_DB.Begin()
	err = tx.Model(&model.OrderPostSale{}).Where("id = ?", info.Id).Updates(&updateM).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	// 将订单状态更改为已取消
	err = tx.Model(&model.Order{}).Where("order_id = ?", postSale.OrderID).Update("status", "5").Error
	if err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	if info.Status == 1 {
		if orderCancelSettle(postSale.OrderID) != nil {
			fmt.Println("退款审核结算失败：", err.Error())
		}
	}
	return nil
}

func orderCancelSettle(orderId string) error {
	var (
		err   error
		order model.Order
	)
	err = global.MG_DB.Model(&model.Order{}).Where("order_id = ?", orderId).First(&order).Error
	if err != nil {
		return err
	}
	if order.Status == 2 || order.Status == 3 { // 已付款且未确认收货
		// 查询订单相关 网红及商家收益
		var billList []model.Bill
		err = global.MG_DB.Model(&model.Bill{}).Where("order_id = ? AND (platform = 'influencer' OR platform = 'seller') AND status = 2", orderId).Find(&billList).Error
		if err != nil {
			return err
		}
		tx := global.MG_DB.Begin()
		for _, bill := range billList {
			var tmpBill model.Bill
			tmpBill.UserID = bill.UserID
			tmpBill.Type = "1"
			tmpBill.OrderID = bill.OrderID
			tmpBill.Price = bill.Price
			tmpBill.Status = 1
			tmpBill.Receipt = 1
			tmpBill.Platform = bill.Platform
			switch bill.Platform {
			case "influencer":
				// 扣除网红佣金
				var wallet model.Wallet
				err, wallet = getWallet("influencer", bill.UserID)
				if err != nil {
					tx.Rollback()
					return errors.New("获取网红钱包失败")
				}
				err = tx.Model(&model.Wallet{}).Where("id = ?", wallet.ID).Update("transit_balance", gorm.Expr("transit_balance - ?", bill.Price)).Error
				if err != nil {
					tx.Rollback()
					return err
				}
				tmpBill.Balance = wallet.Balance
				tmpBill.Title = "退回-" + bill.Title
				tmpBill.TransactionId = "T" + Generate()
				err = tx.Create(&tmpBill).Error
				if err != nil {
					tx.Rollback()
					return err
				}
			case "seller":
				// 扣除商家收入
				var wallet model.Wallet
				err, wallet = getWallet("seller", bill.UserID)
				if err != nil {
					tx.Rollback()
					return errors.New("获取商家钱包失败")
				}
				err = tx.Model(&model.Wallet{}).Where("id = ?", wallet.ID).Update("transit_balance", gorm.Expr("transit_balance - ?", bill.Price)).Error
				if err != nil {
					tx.Rollback()
					return err
				}
				tmpBill.Balance = wallet.Balance
				tmpBill.Title = "退回-" + bill.Title
				tmpBill.TransactionId = "T" + Generate()
				err = tx.Create(&tmpBill).Error
				if err != nil {
					tx.Rollback()
					return err
				}
			}
			err = tx.Create(&tmpBill).Error
			if err != nil {
				tx.Rollback()
				return errors.New("添加网红账单失败")
			}
		}
		tx.Commit()
	} else if order.Status == 4 { // 已确认收货

	}
	return nil
}

func RefundOrderPostSale(storeNo string, info *request.IdReq) error {
	var (
		err      error
		postSale model.OrderPostSale
	)
	err = global.MG_DB.Model(&model.OrderPostSale{}).Where("store_no = ? AND id = ?", storeNo, info.ID).First(&postSale).Error
	if err != nil {
		return errors.New("get post sale record error")
	}
	if postSale.Status != 2 { // 未审核通过
		return errors.New("post sale examine not passed")
	}
	if postSale.RefundStatus != 1 { // 是否未退款
		return errors.New("post sale in progress")
	}
	ok, err := global.MG_REDIS.SetNX("postSaleRefund-"+storeNo, "used", 0).Result()
	if !ok || err != nil {
		return errors.New("post sale refund in progress")
	}
	var (
		order model.Order
		bill  model.Bill
	)
	err = global.MG_DB.Model(&model.Order{}).Where("order_id = ?", postSale.OrderID).First(&order).Error
	if err != nil {
		return errors.New("get order record error")
	}
	tx := global.MG_DB.Begin()
	bill.UserID = order.UserID
	bill.Type = "2"
	bill.Title = "订单退款-" + order.OrderID
	bill.OrderID = order.OrderID
	bill.Price = postSale.Amount
	bill.Status = 2
	bill.Receipt = 2
	bill.Platform = "customer"
	bill.TransactionId = "R" + Generate()
	err = tx.Create(&bill).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	attach, _ := json.Marshal(map[string]string{"order_id": order.OrderID, "transaction_id": bill.TransactionId})
	params := api.RefundRequest{
		Appid:       "bkb5918273465092837",
		Mchid:       "11000001",
		OutTradeNo:  postSale.OrderID,
		PayId:       order.PaypalID,
		Attach:      string(attach),
		NotifyUrl:   global.MG_CONFIG.Paypal.NotifyUrl + "/base/payment/payback",
		Amount:      postSale.Amount,
		Description: "订单申请退款-" + order.OrderID,
	}
	_, err = api.NewGreeterClient(global.PAY_CONN).RefundBill(context.Background(), &params)
	if err != nil {
		fmt.Println(err.Error())
		return errors.New("refund failed:" + postSale.OrderID)
	}
	tx.Commit()
	return nil
}

func calculateFinishMissionClaimStatistics(info request.OrderStatistic) error {
	var err error
	now := time.Now().Format("060102") + "0000"
	tx := global.MG_DB.Begin()
	if info.ClaimNo != "" {
		// 网红维度统计
		var influenceOrder model.DtStatisticOrder
		_ = global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`value` = ? AND relation_id = ? AND `type` = 2", now, info.ClaimNo).First(&influenceOrder).Error
		if influenceOrder.ID == 0 {
			influenceOrder.Value = now
			influenceOrder.Unit = ""
			influenceOrder.Type = 2
			influenceOrder.RelationId = info.ClaimNo
			influenceOrder.SettleReward = info.Reward
			err = tx.Model(&model.DtStatisticOrder{}).Create(&influenceOrder).Error
			if err != nil {
				tx.Rollback()
				return err
			}
		} else {
			var updateMap = make(map[string]interface{})
			updateMap["settle_reward"] = gorm.Expr("settle_reward + ?", info.Reward)
			err = tx.Model(&model.DtStatisticOrder{}).Where("id = ?", influenceOrder.ID).Updates(&updateMap).Error
			if err != nil {
				tx.Rollback()
				return err
			}
		}
	}
	tx.Commit()
	return nil
}

func getStatisticsOrder(value, unit, relationId string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`value` = ? AND `unit` = ?", value, unit)
	if relationId != "" {
		db = db.Where("`relation_id` = ?", relationId)
	}
	err = db.First(&result).Error
	return result, err
}

func getStatisticsOrderList(values []string, unit, relationId string) ([]model.DtStatisticOrder, error) {
	var (
		err    error
		result []model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`value` IN (?) AND `unit` = ?", values, unit)
	if relationId != "" {
		db = db.Where("`relation_id` = ?", relationId)
	}
	err = db.Find(&result).Error
	return result, err
}

// 累计销量 "all","all","goods_id"
// 30天销量 "day","30","goods_id"
func GetStatisticsOrderByValues(unit string, value int, relationId string) (model.DtStatisticOrder, error) {
	if value < 0 {
		return model.DtStatisticOrder{}, errors.New("value error")
	}
	var values = make([]string, 0)
	now := time.Now()
	switch unit {
	case "day":
		if value == 0 {
			values = append(values, now.Format("20060102"))
		} else {
			tmp := now.AddDate(0, 0, -value)
			for i := 0; i < value; i++ {
				values = append(values, tmp.Format("20060102"))
				tmp = tmp.AddDate(0, 0, 1)
			}
		}
	case "month":

	}
	return getStatisticsOrderByValues(values, "day", relationId)
}

func getStatisticsOrderByValues(values []string, unit, relationId string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`value` IN (?) AND `unit` = ?", values, unit).
		Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward")
	if relationId != "" {
		db = db.Where("`relation_id` = ?", relationId)
	}
	err = db.First(&result).Error
	return result, err
}

// 获取订单统计数据-任务维度
func getStatisticsOrderClaim(claimNo, unit string, timeArea []string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("dt_statistic_order.`type` = 2 AND dt_statistic_order.relation_id = ? AND dt_statistic_order.`unit` = ?", claimNo, unit)
	if len(timeArea) == 2 {
		db = db.Where("dt_statistic_order.created_at >= ? AND dt_statistic_order.created_at < ?", timeArea[0], timeArea[1])
	}
	err = db.Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward,SUM(order_cancel_num) as order_cancel_num,SUM(order_cancel_money) as order_cancel_money").First(&result).Error
	return result, err
}

// 获取订单统计数据-网红维度
func getStatisticsOrderInfluence(uuid, unit string, timeArea []string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Joins("INNER JOIN mission_claim ON mission_claim.claim_no = dt_statistic_order.relation_id").
		Where("dt_statistic_order.`type` = 2 AND mission_claim.create_by = ? AND dt_statistic_order.`unit` = ?", uuid, unit)
	if len(timeArea) == 2 {
		db = db.Where("dt_statistic_order.created_at >= ? AND dt_statistic_order.created_at < ?", timeArea[0], timeArea[1])
	}
	err = db.Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward,SUM(order_cancel_num) as order_cancel_num,SUM(order_cancel_money) as order_cancel_money").First(&result).Error
	return result, err
}

// 获取订单统计数据-商品维度
func getStatisticsOrderGoods(spuNo, unit string, timeArea []string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Joins("INNER JOIN tb_goods_specs ON tb_goods_specs.sku_no = dt_statistic_order.relation_id INNER JOIN tb_goods ON tb_goods.id = tb_goods_specs.goods_id").
		Where("dt_statistic_order.`type` = 4 AND tb_goods.spu_no = ? AND dt_statistic_order.`unit` = ?", spuNo, unit)
	if len(timeArea) == 2 {
		db = db.Where("dt_statistic_order.created_at >= ? AND dt_statistic_order.created_at < ?", timeArea[0], timeArea[1])
	}
	err = db.Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward,SUM(order_cancel_num) as order_cancel_num,SUM(order_cancel_money) as order_cancel_money").First(&result).Error
	return result, err
}