back/internal/api/mobile/order_preview/normal_create.go

package order_preview

import (
	"fmt"
	"git.oa00.com/go/mysql"
	"math"
	"recook/configs"
	"recook/internal/back"
	"recook/internal/dbc"
	"recook/internal/model/coupon"
	"recook/internal/model/freight"
	"recook/internal/model/goods"
	"recook/internal/model/order_preview"
	"recook/internal/model/promotion"
	"recook/internal/model/user"
	"recook/internal/model/vend"
	"recook/internal/service/baseCode"
	"recook/internal/v2/controller/all/rate"
	"recook/internal/v2/controller/task"
	"recook/internal/v2/lib/jcook"
	"recook/internal/v2/model/flashsale"
	"recook/internal/v2/model/gys/enterprise"
	goods3 "recook/internal/v2/model/recook/goods"
	"recook/tools"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	"github.com/shopspring/decimal"
)

/*普通订单预览的参数*/
type previewNormalOrderParam struct {
	UserID       uint   `json:"userId" validate:"required"`
	SkuID        uint   `json:"skuId" validate:"required"`
	Quantity     uint   `json:"quantity"  validate:"required"`
	ParentID     uint   `json:"parentId"` // 可选字段 如果是链接分享 则传入该字段，代表分享者的id。 没有的话。就是上级的id，顶级用户没有
	UseCoin      int    `json:"useCoin"`  //默认0 开启 1 关闭
	LiveId       uint   `json:"liveId"`   //直播间id
	Address      string `json:"address"`
	InvitationNo string `json:"invitation_no"`
}

// CreatePreviewNormalOrder 创建普通订单，从商品详情页直接点击《立即购买》按钮进入购买页面，客户端不计算价格，服务端进行计算。
// 明天参加活动的商品不允许购买
func CreatePreviewNormalOrder(c *gin.Context) {
	var p previewNormalOrderParam
	err := tools.ParseParams(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	if p.UserID <= 0 {
		back.Fail(c, "游客无法使用该功能，请先登录")
		return
	}

	if p.Quantity > 50 {
		back.Fail(c, "单件最多拍50件")
		return
	}

	now := time.Now()

	var ancestorID uint = 0
	var myInfo user.Information
	if err := dbc.DB.First(&myInfo, p.UserID).Error; err != nil {
		back.Err(c, err.Error())
		return
	}
	ancestorID = myInfo.AncestorID

	//todo
	//  店主、店铺可以分享商品，通过分享链接直接下单的，商品佣金返还给分享者瑞币
	sharerId := myInfo.ID
	if p.InvitationNo != "" {
		sharerId = uint(baseCode.Decode(p.InvitationNo))
	}
	preOrderInfo := &order_preview.Information{}
	preOrderUniversalCoupon := &order_preview.CouponDetail{}
	preOrderAddr := &order_preview.Addr{}
	preOrderBrandCoupon := &order_preview.CouponDetail{}
	preOrderGoods := &order_preview.GoodsDetail{}

	actualAmount := decimal.NewFromFloat(0.0)
	unitPrice := decimal.NewFromFloat(0.0)  // 单价
	expressFee := decimal.NewFromFloat(0.0) // 快递费
	commission := decimal.NewFromInt(0)
	brandCouponReducePrice := decimal.NewFromFloat(0.0)    // 品牌优惠券抵扣的价格
	universeCouponReducePrice := decimal.NewFromFloat(0.0) // 通用优惠券抵扣的价格
	coinReducePrice := decimal.NewFromFloat(0.0)           // 使用瑞币的价格
	mainPhotoURL := ""
	// 首先检测库存
	var sku goods.Sku
	cost := decimal.Zero
	{
		err = dbc.DB.First(&sku, "id = ?", p.SkuID).Error
		if err != nil {
			back.Err(c, err.Error())
			return
		}
		cost = cost.Add(cost.Add(sku.PurchasePrice.Mul(decimal.NewFromInt(int64(p.Quantity)))))
	}

	var promotionGoods promotion.Goods
	var promotionSku promotion.Sku
	dbc.DB.First(&promotionGoods, "goods_id = ? AND start_time <= ? AND end_time > ?", sku.GoodsID, time.Now(), time.Now())
	if promotionGoods.ID == 0 {
		dbc.DB.First(&promotionGoods, "goods_id = ? AND start_time > ?", sku.GoodsID, time.Now())
	}

	// 仅考虑商品的库存
	dbc.DB.First(&promotionSku, "promotion_goods_id = ? AND sku_id = ?", promotionGoods.ID, p.SkuID)
	if p.Quantity > sku.Inventory {
		back.Fail(c, "库存不足")
		return
	}
	unitPrice = sku.DiscountPrice
	commission = sku.Commission

	mainPhotoURL = sku.PicURL
	if len(sku.PicURL) == 0 { // 使用主图
		var mainPhoto goods.MainPhoto
		err := dbc.DB.First(&mainPhoto, "goods_id = ? AND is_master = 1", sku.GoodsID).Error
		if err != nil {
			back.Fail(c, err.Error())
			return
		}
		mainPhotoURL = mainPhoto.URL
	}

	if unitPrice.LessThan(decimal.NewFromFloat(0.01)) {
		back.Err(c, "当前商品价格太低。内部错误")
		return
	}

	var defaultAddr user.Addr
	{
		err = dbc.DB.First(&defaultAddr, "user_id = ? AND is_default = 1", p.UserID).Error
		if err != nil && false == gorm.IsRecordNotFoundError(err) {
			back.Err(c, err.Error())
			return
		}
	}
	if sku.ThirdPartyType == 3 && p.Address == "" && defaultAddr.ID == 0 {
		back.Err(c, "请填写默认收货地址")
		return
	}

	var goodsInfo goods.Information
	{
		err = dbc.DB.First(&goodsInfo, "id = ?", sku.GoodsID).Error
		if err != nil {
			back.Err(c, err.Error())
			return
		}
		if goodsInfo.PublishStatus == 0 {
			back.Fail(c, "商品已下架："+goodsInfo.GoodsName)
			return
		}
	}
	if (goodsInfo.ThirdPartyType == 3 && defaultAddr.ID > 0) || p.Address != "" {
		// 京东商品查询物流信息
		client := jcook.GetClient()
		if len(p.Address) == 0 {
			p.Address = defaultAddr.GetAddress()
		}
		req := jcook.SkuStockReq{
			Address: p.Address,
			SkuList: []jcook.SkuQuantity{
				{
					goodsInfo.ThirdPartyId,
					p.Quantity,
				},
			},
		}
		var resp []jcook.SkuStockResp
		if err = client.Exec(req, &resp); err != nil {
			back.Err(c, err.Error())
			return
		}
		for _, v := range resp {
			if v.StockState == 0 {
				back.Err(c, "该地区该商品无货")
				return
			}
		}
		var sku goods3.RecookGoodsSkuModel
		mysql.Db.First(&sku, "goods_id = ?", goodsInfo.ID)

		req1 := jcook.LogisticsFeeReq{
			Address: p.Address,
			SkuList: []jcook.LogisticsInfo{
				{
					goodsInfo.ThirdPartyId,
					p.Quantity,
					sku.PurchasePrice,
				},
			},
			OrderFee: sku.PurchasePrice.Mul(decimal.NewFromInt(int64(p.Quantity))),
		}
		var resp2 jcook.LogisticsFeeResp
		if err := client.Exec(req1, &resp2); err != nil {
			back.Err(c, err.Error())
			return
		}
		expressFee = resp2.Fee
		preOrderAddr.IsDeliveryArea = 1

	} else if defaultAddr.ID > 0 {
		canDelivery, expFee, err := computeExpressFeeWithGoods(p.Quantity, &goodsInfo, defaultAddr.Province, defaultAddr.City)
		if err != nil {
			back.Err(c, err.Error())
			return
		}

		if canDelivery {
			expressFee = expFee
			preOrderAddr.IsDeliveryArea = 1
		}
	}

	var brandInfo goods.Brand
	{
		err = dbc.DB.First(&brandInfo, "id = ?", goodsInfo.BrandID).Error
		if err != nil {
			back.Err(c, err.Error())
			return
		}
	}

	var firCate goods.Category
	var secCate goods.Category
	dbc.DB.Select("name").First(&firCate, goodsInfo.FirstCategoryID)
	dbc.DB.Select("name").First(&secCate, goodsInfo.SecondCategoryID)

	vendorName := "自营"
	var vendor vend.Information
	{
		if goodsInfo.VendorID > 0 {
			err = dbc.DB.Select("id, username").First(&vendor, "id = ?", goodsInfo.VendorID).Error
			if err != nil {
				back.Err(c, err.Error())
				return
			}
			vendorName = vendor.Username
		}
	}

	// 品牌券  快递费不计入优惠券门槛
	var maxBrandCouponReceiverMid coupon.ReceiverMid
	dbc.DB.Select("id, coupon_id, user_id, status, name, threshold, MAX(cash) AS cash, scope, brand_id, start_time, end_time").
		First(&maxBrandCouponReceiverMid, "user_id = ? AND status = 0 AND threshold <= ? "+
			"AND scope = 1 AND brand_id = ? "+
			"AND start_time < ? AND end_time > ?", p.UserID, unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity))), brandInfo.ID, now, now)

	if maxBrandCouponReceiverMid.ID > 0 {
		brandCouponReducePrice = decimal.NewFromInt(int64(maxBrandCouponReceiverMid.Cash))
	}

	// 购物券
	var maxUniversalCouponReceiverMid coupon.ReceiverMid
	dbc.DB.Select("id, coupon_id, user_id, status, name, threshold, MAX(cash) AS cash, scope, brand_id, start_time, end_time").First(&maxUniversalCouponReceiverMid, "user_id = ? AND status = 0 AND threshold <= ? "+
		"AND scope = 0 "+
		"AND start_time < ? AND end_time > ?", p.UserID, unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity))).Sub(brandCouponReducePrice), now, now)

	if maxUniversalCouponReceiverMid.ID > 0 {
		universeCouponReducePrice = decimal.NewFromInt(int64(maxUniversalCouponReceiverMid.Cash))
	}

	// todo 做判断，每次只能用一张优惠券，这里哪张面额大，用哪张减免

	//新增秒杀模块
	//判别是否是秒杀中的商品
	var stock, _ = IfSecKill(time.Now(), p.SkuID)
	if stock.Id > 0 {
		//该商品在本次秒杀活动中
		//判断库存
		num := stock.SecKillStock.Sub(stock.SaleNum)
		if num.IsZero() || num.LessThan(decimal.NewFromInt(0)) || num.LessThan(decimal.NewFromInt(int64(p.Quantity))) {
			back.Err(c, "该秒杀商品库存不足")
			return
		}
	}
	//新增结束

	/*
		计算实际价格
	*/
	actualAmount = unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity))).Add(expressFee).Sub(brandCouponReducePrice).Sub(universeCouponReducePrice)
	if stock.Id > 0 {
		actualAmount = stock.SecKillDiscountPrice.Mul(decimal.NewFromInt(int64(p.Quantity))).Add(expressFee).Sub(brandCouponReducePrice).Sub(universeCouponReducePrice)
	}

	var wallet user.Wallet
	{
		err = dbc.DB.First(&wallet, "user_id = ?", p.UserID).Error
		if err != nil {
			back.Err(c, err.Error())
			return
		}
		if p.UseCoin < 1 && (&goods3.RecookGoodsInfoModel{}).HasCoin(goodsInfo.Storehouse) {
			//coinAmount := decimal.NewFromInt(int64(wallet.Coin)).Div(decimal.NewFromInt(100)) // 将瑞币折算为实际金额
			coinAmount := wallet.Coin                        // 瑞币折算按照 1：1
			if actualAmount.GreaterThanOrEqual(coinAmount) { // 保证不过量抵扣
				actualAmount = actualAmount.Sub(coinAmount)
				coinReducePrice = coinAmount
			} else {
				// 瑞比足够支付时 将瑞币直接使用掉 订单金额为0
				coinReducePrice = actualAmount
				actualAmount = decimal.NewFromFloat(0.0)
			}
		}

	}

	tx := dbc.DB.Begin()
	{
		{
			preOrderInfo.AncestorID = ancestorID
			preOrderInfo.ParentID = uint(myInfo.ParentID)
			preOrderInfo.SharerID = sharerId
			preOrderInfo.LiveId = p.LiveId
			preOrderInfo.UserID = p.UserID
			//preOrderInfo.UserRole = myInfo.Role
			preOrderInfo.Title = goodsInfo.GoodsName
			preOrderInfo.BrandCouponTotalAmount = brandCouponReducePrice
			preOrderInfo.UniverseCouponTotalAmount = universeCouponReducePrice
			preOrderInfo.CoinTotalAmount = coinReducePrice
			preOrderInfo.ExpressTotalFee = expressFee
			preOrderInfo.GoodsTotalAmount = unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity)))
			// preOrderInfo.GoodsTotalCommission = commission.Mul(decimal.NewFromInt(int64(p.Quantity)))
			//allAmount := unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity)))
			// 单笔收益 * 数量 * （总价价 - 优惠券 / 总价)
			//preOrderInfo.GoodsTotalCommission = commission.Mul(decimal.NewFromInt(int64(p.Quantity))).
			//	Mul(allAmount).Sub(universeCouponReducePrice.Add(brandCouponReducePrice)).Div(allAmount)
			preOrderInfo.GoodsTotalCommission = commission.Mul(decimal.NewFromInt(int64(p.Quantity)))
			// beego.Info("commission", commission, "Quantity", p.Quantity, "allAmount", allAmount, "universeCouponReducePrice", universeCouponReducePrice, "brandCouponReducePrice", brandCouponReducePrice, "allAmount", allAmount)
			preOrderInfo.ActualTotalAmount = actualAmount
			preOrderInfo.Cost = cost
			//若该商品在秒杀中，重新赋值
			if stock.Id > 0 {
				preOrderInfo.GoodsTotalAmount = stock.SecKillDiscountPrice.Mul(decimal.NewFromInt(int64(p.Quantity)))
				preOrderInfo.GoodsTotalCommission = stock.SecKillCommission.Mul(decimal.NewFromInt(int64(p.Quantity)))
			}
			//赋值结束
			err = tx.Create(&preOrderInfo).Error
			if err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
		}

		// 地址
		{
			preOrderAddr.OrderID = preOrderInfo.ID
			preOrderAddr.Province = defaultAddr.Province
			preOrderAddr.City = defaultAddr.City
			preOrderAddr.District = defaultAddr.District
			preOrderAddr.ReceiverName = defaultAddr.Name
			preOrderAddr.Mobile = defaultAddr.Mobile
			preOrderAddr.AddressID = defaultAddr.ID
			preOrderAddr.Address = defaultAddr.Address
			err = tx.Create(&preOrderAddr).Error
			if err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
		}

		// 保存优惠券
		{
			if maxBrandCouponReceiverMid.ID > 0 {
				preOrderBrandCoupon.OrderID = preOrderInfo.ID
				preOrderBrandCoupon.DeductedAmount = brandCouponReducePrice
				preOrderBrandCoupon.BrandID = maxBrandCouponReceiverMid.BrandID
				preOrderBrandCoupon.PersonalCouponID = maxBrandCouponReceiverMid.ID
				preOrderBrandCoupon.Scope = maxBrandCouponReceiverMid.Scope
				preOrderBrandCoupon.CouponID = maxBrandCouponReceiverMid.CouponID
				preOrderBrandCoupon.CouponName = maxBrandCouponReceiverMid.Name
				preOrderBrandCoupon.EndTime = maxBrandCouponReceiverMid.EndTime
				err = tx.Create(&preOrderBrandCoupon).Error
				if err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}
			}

			if maxUniversalCouponReceiverMid.ID > 0 {
				preOrderUniversalCoupon.OrderID = preOrderInfo.ID
				preOrderUniversalCoupon.DeductedAmount = universeCouponReducePrice
				preOrderUniversalCoupon.BrandID = maxUniversalCouponReceiverMid.BrandID
				preOrderUniversalCoupon.PersonalCouponID = maxUniversalCouponReceiverMid.ID
				preOrderUniversalCoupon.Scope = maxUniversalCouponReceiverMid.Scope
				preOrderUniversalCoupon.CouponID = maxUniversalCouponReceiverMid.CouponID
				preOrderUniversalCoupon.CouponName = maxUniversalCouponReceiverMid.Name
				preOrderUniversalCoupon.EndTime = maxUniversalCouponReceiverMid.EndTime
				err = tx.Create(&preOrderUniversalCoupon).Error
				if err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}
			}
		}

		{
			preOrderGoods.OrderID = preOrderInfo.ID
			preOrderGoods.VendorID = goodsInfo.VendorID
			preOrderGoods.VendorName = vendorName
			preOrderGoods.BrandID = brandInfo.ID
			preOrderGoods.BrandName = brandInfo.Name
			preOrderGoods.CategoryName = firCate.Name + "/" + secCate.Name
			preOrderGoods.GoodsID = goodsInfo.ID
			preOrderGoods.GoodsName = goodsInfo.GoodsName
			preOrderGoods.IsJoinTeamPerformance = goodsInfo.IsJoinTeamPerformance
			preOrderGoods.Hash = goodsInfo.Hash
			preOrderGoods.SkuID = sku.ID
			preOrderGoods.SkuName = sku.Name
			preOrderGoods.SkuCode = sku.Code
			preOrderGoods.MainPhotoURL = mainPhotoURL
			preOrderGoods.Quantity = p.Quantity
			preOrderGoods.FreightID = goodsInfo.FreightID
			preOrderGoods.Weight = goodsInfo.Weight
			preOrderGoods.PromotionSkuId = promotionSku.ID
			preOrderGoods.PromotionGoodsId = promotionGoods.ID
			preOrderGoods.PromotionName = promotionGoods.PromotionName
			preOrderGoods.PromotionStartTime = promotionGoods.StartTime
			preOrderGoods.PromotionEndTime = promotionGoods.EndTime
			preOrderGoods.UnitPrice = unitPrice
			preOrderGoods.PurchasePrice = sku.PurchasePrice
			// preOrderGoods.TotalCommission = commission.Mul(decimal.NewFromInt(int64(p.Quantity)))
			// 收益 / 单价 * （单价-(优惠券）/数量）
			preOrderGoods.TotalCommission = preOrderInfo.GoodsTotalCommission
			preOrderGoods.BrandCouponAmount = brandCouponReducePrice
			preOrderGoods.UniverseCouponAmount = universeCouponReducePrice
			preOrderGoods.CoinAmount = coinReducePrice
			preOrderGoods.GoodsAmount = unitPrice.Mul(decimal.NewFromInt(int64(p.Quantity)))
			preOrderGoods.ExpressFee = expressFee
			preOrderGoods.ActualAmount = actualAmount
			preOrderGoods.IsImport = goodsInfo.IsImport
			preOrderGoods.Storehouse = goodsInfo.Storehouse
			preOrderGoods.IsFerme = goodsInfo.IsFerme

			if stock.Id > 0 {
				preOrderGoods.UnitPrice = stock.SecKillDiscountPrice
				preOrderGoods.PurchasePrice = stock.SecKillPurchase
				preOrderGoods.TotalCommission = preOrderInfo.GoodsTotalCommission
				preOrderGoods.GoodsAmount = stock.SecKillDiscountPrice.Mul(decimal.NewFromInt(int64(p.Quantity)))
			}

			err = tx.Create(&preOrderGoods).Error
			if err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
		}
	}
	tx.Commit()
	//新增邮件提醒
	go sendJTEmail(preOrderInfo.ID)

	back.Suc(c, "操作成功", queryPreviewOrderGroup(preOrderInfo.ID))
}

func computeExpressFeeWithGoods(quantity uint, goodsInfo *goods.Information, province, city string) (bool, decimal.Decimal, error) {
	var freightTemplateInfo freight.Information
	// 只有用户有默认地址才去计算运费价格
	err := dbc.DB.First(&freightTemplateInfo, "id = ?", goodsInfo.FreightID).Error
	if err != nil {
		return false, decimal.NewFromFloat(0.0), err
	}

	//  检测是否属于不发货地区
	// 不发货的省
	var nonDeliveryProvince freight.NoProvince
	err = dbc.DB.First(&nonDeliveryProvince, "freight_id = ? AND province_name = ?", goodsInfo.FreightID, province).Error
	if err != nil && false == gorm.IsRecordNotFoundError(err) {
		return false, decimal.Zero, err
	}
	if nonDeliveryProvince.ID > 0 {
		return false, decimal.NewFromFloat(0.0), nil
	}

	// 不发货的市
	var noCitys freight.NoCitys
	err = dbc.DB.First(&noCitys, "freight_id = ? AND province_name = ? and city_name = ?", goodsInfo.FreightID, province, city).Error
	if err != nil && gorm.IsRecordNotFoundError(err) == false {
		return false, decimal.Zero, err
	}
	if noCitys.ID > 0 {
		return false, decimal.NewFromFloat(0.0), nil
	}

	// 进入该分支代表该地址可以发货 需要查询运费信息
	// 先判断是不是所有地方包邮
	var freightInfo freight.Information
	err = dbc.DB.First(&freightInfo, "id = ?", goodsInfo.FreightID).Error
	if err != nil {
		return false, decimal.NewFromFloat(0.0), nil
	}
	if freightInfo.AllFree == 1 {
		return true, decimal.NewFromFloat(0.0), nil
	}
	// 先找到该收货省市的信息 然后找到对应的价格表

	var priceDetailID uint
	// 市价格表
	var deliveryCity freight.Citys
	err = dbc.DB.First(&deliveryCity, "freight_id = ? AND province_name = ? and city_name = ?", goodsInfo.FreightID, province, city).Error
	if deliveryCity.ID == 0 {
		// 省价格表
		var deliveryProvince freight.Province
		err = dbc.DB.First(&deliveryProvince, "freight_id = ? AND province_name = ?", goodsInfo.FreightID, province).Error
		if err != nil {
			return true, decimal.Zero, nil
		}
		priceDetailID = deliveryProvince.PriceDetailID
	} else {
		priceDetailID = deliveryCity.PriceDetailID
	}
	var freightPrice freight.Price
	dbc.DB.First(&freightPrice, "id = ?", priceDetailID)

	expressFee := decimal.NewFromFloat(0.0)
	if freightPrice.Type == 0 { // 按照件数计算
		if quantity <= freightPrice.FirstNumber {
			expressFee = freightPrice.FirstNumberFee
		} else {
			baseNumber := math.Ceil(float64((quantity - freightPrice.FirstNumber) / freightPrice.AdditionalNumber)) // 向上取整 意思是不满一斤算一斤
			expressFee = freightPrice.FirstNumberFee.Add(decimal.NewFromFloat(baseNumber).Mul(freightPrice.AdditionalNumberFee))
		}
	} else if freightPrice.Type == 3 { // 固定计费
		return true, freightPrice.Amount, nil
		//if goodsInfo.Weight.LessThanOrEqual(freightPrice.FirstWeight) { // 小于首重
		//	expressFee = freightPrice.FirstWeightFee
		//} else {
		//	baseWeight := (goodsInfo.Weight.Sub(freightPrice.FirstWeight)).Div(freightPrice.AdditionalWeight).Ceil() // 向上取整 意思是不满一斤算一斤
		//	expressFee = freightPrice.FirstWeightFee.Sub(baseWeight.Mul(freightPrice.AdditionalWeightFee))
		//}
	} else { // 按照重量计算
		if goodsInfo.Weight.LessThanOrEqual(freightPrice.FirstWeight) { // 小于首重
			expressFee = freightPrice.FirstWeightFee
		} else {
			baseWeight := (goodsInfo.Weight.Sub(freightPrice.FirstWeight)).Div(freightPrice.AdditionalWeight).Ceil() // 向上取整 意思是不满一斤算一斤
			expressFee = freightPrice.FirstWeightFee.Sub(baseWeight.Mul(freightPrice.AdditionalWeightFee))
		}
	}

	if quantity >= freightPrice.FreeNumberThreshold {
		expressFee = decimal.NewFromFloat(0.0)
	}
	return true, expressFee, nil
}

/*
	新增内容：
	在，遍历商品，如果含有景彤的商品则判断毛利率不在1%到6%之间，邮件提醒
*/
func sendJTEmail(oid uint) {

	var less []task.JtResponse
	var greater []task.JtResponse
	var cal rate.Calculation
	var jt task.Jingtong
	gys := enterprise.GysEnterpriseStateModel{}
	var goodsList []order_preview.GoodsDetail
	dbc.DB.Table("recook_order_preview_goods_detail").Where("order_id=?", oid).Find(&goodsList)
	fmt.Println("******测试开始")
	for _, v := range goodsList {
		var reInfo goods3.RecookGoodsInfoModel
		dbc.DB.Table("recook_goods_info").Where("id=?", v.GoodsID).First(&reInfo)
		if reInfo.ThirdPartyType == 2 { //景彤
			var rest []rate.NewGoodsSkuRest
			if reInfo.Storehouse > 1 {
				rest = cal.GrossProfitRateAbort(v.GoodsID, nil)
			} else {
				rest = cal.GrossProfitRate(v.GoodsID, nil)
			}

			for _, skuRest := range rest {
				fmt.Println("毛利率为", skuRest.EstimatedNetGrossMargin)
				if skuRest.EstimatedNetGrossMargin.LessThan(decimal.NewFromFloat(0.01)) {
					name := gys.FindByUserId(v.VendorID)
					less = append(less, task.JtResponse{
						GoodsName: v.GoodsName,
						GysName:   name.EnterpriseName,
						Coke:      skuRest.Code,
						Text:      "毛利率低于1%",
						Rate:      skuRest.EstimatedNetGrossMargin,
					})
				}
				if skuRest.EstimatedNetGrossMargin.GreaterThan(decimal.NewFromFloat(0.10)) {
					name := gys.FindByUserId(v.VendorID)
					greater = append(greater, task.JtResponse{
						GoodsName: v.GoodsName,
						GysName:   name.EnterpriseName,
						Coke:      skuRest.Code,
						Text:      "毛利率高于10%",
						Rate:      skuRest.EstimatedNetGrossMargin,
					})
				}
			}
		}
		if len(less)+len(greater) > 0 {
			err1 := jt.SendEmail(configs.ConfigJTEmail, less, greater)
			if err1 != nil {
				fmt.Println(err1.Error())
			}
		}

	}

	fmt.Println("*************8测试结束")
}
func IfSecKill(now time.Time, skuID uint) (flashsale.RecookSecKillGoodsModel, flashsale.RecookSecKillSortModel) {
	var seckill flashsale.RecookSecKillModel
	dbc.DB.Table(seckill.TableName()).Where("activity_start_time<?", now).Where("activity_end_time>?", now).Where("status=2").First(&seckill)
	//获取当前时间段的商品
	now2 := time.Date(0, 1, 1, now.Hour(), now.Minute(), now.Second(), 0, time.Local)
	var secgoods flashsale.RecookSecKillSortModel
	dbc.DB.Table((&flashsale.RecookSecKillSortModel{}).TableName()).Where("show_time_start<?", now2).Where("show_time_end>?", now2).Where("sec_kill_activity_id=?", seckill.Id).Where("sku_id=?", skuID).First(&secgoods)
	var gs flashsale.RecookSecKillGoodsModel
	dbc.DB.Table(gs.TableName()).Where("sec_kill_activity_id=?", seckill.Id).Where("goods_sku_id=?", secgoods.SkuId).First(&gs)
	return gs, secgoods
}