liulei/jx-callback
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

结账第二期

Browse Source
This commit is contained in:
renyutian
2019-04-03 17:49:30 +08:00
parent 7b43e7d6e9
commit 632aa6aa3d
17 changed files with 1028 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
business/jxcallback/orderman/financial.go
View File

@@ -1,64 +1,293 @@
package orderman
import (
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/model/dao"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
)
const (
PublicWelfareDonation = 1 // 美团公益捐款金额现阶段是每单一分钱
TotalRate = 200 // 总费率（千分之200）= 第三方平台费+京西品牌费+京西服务费，现阶段都是合计200‰
TotalRate = 200 // 总费率（千分之200）= 第三方平台费+京西品牌费+京西服务费，现阶段都是合计200‰
MaxFreightMoneyFromJxByShop = 7 // 商家自送实际转美团/达达后由商家承担的运费金额上限
)
// 处理正向订单结账信息
func SaveOrderFinancialInfo(order *model.OrderFinancial) (err error) {
if order.VendorID == model.VendorIDJD { //京东订单单独处理部分
}
if order.VendorID == model.VendorIDEBAI { //饿百订单单独处理部分
order.FreightDiscountMoney = order.TotalDiscountMoney - order.DiscountMoney
}
if order.VendorID == model.VendorIDMTWM { //美团订单单独处理部分
order.DonationMoney = PublicWelfareDonation
}
order.ShopMoneyByCal = order.SalePriceMoney - order.TotalDiscountMoney + order.VendorFreightDiscountMoney - order.DistanceFreightMoney - order.FreightTipsMoney - order.DonationMoney + order.SelfDeliveryDiscountMoney + order.PmSubsidyMoney + order.BoxMoney - order.PmMoney
order.PmMoneyFormJx = (order.ShopMoney+order.PmMoney)*TotalRate/1000 - order.PmMoney // 京西平台费 = 总金额*20%-第三方平台费
if order.PmMoneyFormJx < 0 { // 如果算出京西平台费为负数，则置0
order.PmMoneyFormJx = 0
}
order.ShopMoneyFromJx = order.ShopMoney - order.PmMoneyFormJx + order.SubsidyMoneyFromJx - order.FreightMoneyFromJxByShop
err = dao.CreateEntity(dao.GetDB(), order)
return err
}
// 处理售后订单结账信息
func SaveAfsOrderFinancialInfo(afsOrder *model.AfterSalesOrder) (err error) {
func (c *OrderManager) SaveOrderFinancialInfo(order *model.OrderFinancial, operation string) (err error) {
db := dao.GetDB()
dao.Begin(db)
defer dao.Rollback(db)
if afsOrder.VendorID == model.VendorIDJD { //京东订单单独处理部分
}
if afsOrder.VendorID == model.VendorIDEBAI { //饿百订单单独处理部分
}
if afsOrder.VendorID == model.VendorIDMTWM { //美团订单单独处理部分
}
globals.SugarLogger.Debug(afsOrder.Skus)
for _, orderSku := range afsOrder.Skus {
orderSku.SkuRefundMoneyByCal = orderSku.SkuUserMoney + orderSku.SkuVendorMoney + afsOrder.FreightUserMoney + afsOrder.AfsFreightMoney + afsOrder.BoxMoney + afsOrder.TongchengFreightMoney + afsOrder.MealBoxMoney
// orderSku.SkuTotalMoney+=orderSku.SkuJxMoney // 退款单京西补贴部分先不作计算
afsOrder.SkuUserMoney += orderSku.SkuUserMoney
afsOrder.PmSubsidyMoney += orderSku.SkuVendorMoney
// order.SkuJxMoney += orderSku.SkuJxMoney // 退款单京西补贴部分先不作计算
if err = dao.CreateEntity(db, orderSku); err != nil {
defer func() {
if r := recover(); r != nil || err != nil {
dao.Rollback(db)
if r != nil {
panic(r)
}
}
}()
if operation == partner.UpdatedPeration {
// db := orm.NewOrm()
err = utils.CallFuncLogError(func() error {
_, err = dao.ExecuteSQL(db, "DELETE FROM order_Financial WHERE vendor_order_id = ? AND vendor_id = ?", order.VendorOrderID, order.VendorID)
return err
}, "SaveOrderFinancialInfo delete order_Financial, orderID:%s", order.VendorOrderID)
if err != nil {
return err
}
err = utils.CallFuncLogError(func() error {
_, err = dao.ExecuteSQL(db, "DELETE FROM order_sku_financial WHERE vendor_order_id = ? AND vendor_id = ?", order.VendorOrderID, order.VendorID)
return err
}, "SaveOrderFinancialInfo delete order_sku_financial, orderID:%s", order.VendorOrderID)
if err != nil {
return err
}
err = utils.CallFuncLogError(func() error {
_, err = dao.ExecuteSQL(db, "DELETE FROM order_discount_financial WHERE vendor_order_id = ? AND vendor_id = ?", order.VendorOrderID, order.VendorID)
return err
}, "SaveOrderFinancialInfo delete order_sku, orderID:%s", order.VendorOrderID)
if err != nil {
return err
}
}
afsOrder.RefundMoneyByCal = afsOrder.SkuUserMoney + afsOrder.PmSubsidyMoney + afsOrder.FreightUserMoney + afsOrder.AfsFreightMoney + afsOrder.BoxMoney + afsOrder.TongchengFreightMoney + afsOrder.MealBoxMoney
// order.TotalMoney += order.SkuJxMoney // 退款单京西补贴部分先不作计算
if err = dao.CreateEntity(db, afsOrder); err != nil {
globals.SugarLogger.Warnf("On SaveAfsOrderFinancialInfo err: SaveAfsOrder is err")
for _, activity := range order.Discounts {
if err = dao.CreateEntity(db, activity); err != nil {
return err
}
}
order.ShopMoneyByCal = order.SalePriceMoney - order.TotalDiscountMoney - order.PointsDeductionMoney + order.PmFreightDiscountMoney - order.DistanceFreightMoney - order.FreightTipsMoney - order.DonationMoney + order.SelfDeliveryDiscountMoney + order.PmSubsidyMoney + order.SkuBoxMoney + order.BoxMoney - order.PmMoney
order.JxPmMoney = (order.ShopMoney+order.PmMoney)*TotalRate/1000 - order.PmMoney // 京西平台费 = 总金额*20%-第三方平台费
if order.JxPmMoney < 0 { // 如果算出京西平台费为负数，则置0
order.JxPmMoney = 0
}
order.JxShopMoney = order.ShopMoney - order.JxPmMoney + order.JxSubsidyMoney - order.JxFreightMoneyByShop
// 订单结算金额拆分计算，拆分到单条sku
// 先获取订单主体优惠金额
platOrderGoodsDiscountMoney := order.PmSubsidyMoney - order.PmSkuSubsidyMoney + order.SelfDeliveryDiscountMoney
// 结算平台扣除项汇总---平台佣金，商家设置运费减免，远距离费，小费，公益捐款、、、、
deductionsByPm := order.FreightDiscountMoney + order.DistanceFreightMoney + order.FreightTipsMoney + order.DonationMoney + order.PmMoney
// 结算京西扣除项汇总---京西佣金，京西配送运费
deductionsByJx := order.JxPmMoney + order.JxFreightMoneyByShop
for _, sku := range order.Skus[1:] {
// 用户支付菜品金额，用户为这一条sku支付的菜品金额
sku.UserMoney = utils.Float64TwoInt64(float64(order.SalePriceMoney-order.DiscountMoney-order.PointsDeductionMoney+order.BoxMoney+order.SkuBoxMoney) * float64(sku.SalePrice*int64(sku.Count)+sku.SkuBoxMoney) / float64(order.SalePriceMoney+order.SkuBoxMoney)) // 林峰确认，比如49-2满减，算餐盒费满49元，不算餐盒费不足49元，是可以参加满减活动的，那么餐盒费也应该和商品金额一起进行折算
order.Skus[0].UserMoney += sku.UserMoney
// 计算平台订单主体补贴拆分到单条sku的金额 + sku.PmSubsidyMoneyForSku
sku.PmSubsidyMoney = sku.PmSkuSubsidyMoney + utils.Float64TwoInt64(float64(platOrderGoodsDiscountMoney*sku.SalePrice*int64(sku.Count)+sku.SkuBoxMoney)/float64(order.SalePriceMoney+order.SkuBoxMoney))
order.Skus[0].PmSubsidyMoney += sku.PmSubsidyMoney
// 计算京西满减补贴拆分到单条sku的金额 + sku.JxSubsidyMoneyForSku
sku.JxSubsidyMoney = sku.JxSkuSubsidyMoney + utils.Float64TwoInt64(float64(order.JxSubsidyMoney-order.PmSkuSubsidyMoney)*float64(sku.SalePrice*int64(sku.Count)+sku.SkuBoxMoney)/float64(order.SalePriceMoney+order.SkuBoxMoney))
order.Skus[0].JxSubsidyMoney += sku.JxSubsidyMoney
// 计算单条sku需要承担的平台扣费金额
sku.PmDeductionsMoney = utils.Float64TwoInt64(float64(deductionsByPm) * (float64(sku.UserMoney + sku.PmSubsidyMoney)) / (float64(order.SalePriceMoney + order.BoxMoney + order.SkuBoxMoney - order.DiscountMoney - order.PointsDeductionMoney + order.PmSubsidyMoney)))
order.Skus[0].PmDeductionsMoney += sku.PmDeductionsMoney
// 计算单条sku平台应该结算给京西的金额
sku.ShopMoneyByCal = sku.UserMoney + sku.PmSubsidyMoney - sku.PmDeductionsMoney
order.Skus[0].ShopMoneyByCal += sku.ShopMoneyByCal
// j计算单条sku需要承担的京西扣费金额
sku.JxDeductionsMoney = utils.Float64TwoInt64(float64(deductionsByJx*sku.ShopMoneyByCal) / float64(order.ShopMoney))
order.Skus[0].JxDeductionsMoney += sku.JxDeductionsMoney
// 计算单条sku京西应该结算给商家的金额
sku.JxShopMoney = sku.ShopMoneyByCal + sku.JxSubsidyMoney - sku.JxDeductionsMoney
order.Skus[0].JxShopMoney += sku.JxShopMoney
if err = dao.CreateEntity(db, sku); err != nil {
return err
}
}
if len(order.Skus) > 0 {
sku := order.Skus[0]
sku.UserMoney = order.SalePriceMoney - order.DiscountMoney - sku.UserMoney
sku.PmSubsidyMoney = platOrderGoodsDiscountMoney + order.SelfDeliveryDiscountMoney - sku.PmSubsidyMoney
sku.JxSubsidyMoney = order.JxSubsidyMoney - sku.JxSubsidyMoney
sku.PmDeductionsMoney = deductionsByPm - sku.PmDeductionsMoney
sku.ShopMoneyByCal = order.ShopMoney - sku.ShopMoneyByCal
sku.JxDeductionsMoney = deductionsByJx - sku.JxDeductionsMoney
sku.JxShopMoney = order.JxShopMoney - sku.JxShopMoney
if err = dao.CreateEntity(db, sku); err != nil {
return err
}
} else {
}
// 加上京西对单条sku的补贴，再存数据库
order.JxSubsidyMoney += order.JxSkuSubsidyMoney
if err = dao.CreateEntity(db, order); err != nil {
globals.SugarLogger.Warnf("On SaveOrderFinancialInfo err: order is err")
return err
}
dao.Commit(db)
return err
}
// 处理售后订单结账信息
func (c *OrderManager) SaveAfsOrderFinancialInfo(afsOrder *model.AfsOrder) (err error) {
db := dao.GetDB()
dao.Begin(db)
defer func() {
if r := recover(); r != nil || err != nil {
dao.Rollback(db)
if r != nil {
panic(r)
}
}
}()
globals.SugarLogger.Debug(afsOrder.Skus)
// 平台结算扣除汇总--平台补贴，售后产生运费，平台收包装费，同城运费、、、
deductionsByPm := afsOrder.PmSubsidyMoney + afsOrder.AfsFreightMoney + afsOrder.BoxMoney + afsOrder.TongchengFreightMoney
afsOrder.RefundMoneyByCal = afsOrder.SkuUserMoney + afsOrder.FreightUserMoney + deductionsByPm
// order.TotalMoney += order.SkuJxMoney // 退款单京西补贴部分先不作计算
if err = dao.CreateEntity(db, afsOrder); err != nil {
globals.SugarLogger.Warnf("On SaveAfsOrderFinancialInfo err: SaveAfsOrder is err")
return err
}
// 京西结算扣除汇总，先不作计算,计算单条sku最终扣款金额（+该条sku承担的平台结算扣除金额）
for _, orderSku := range afsOrder.Skus[1:] {
orderSku.RefundMoneyByCal = orderSku.PmSkuSubsidyMoney +
utils.Float64TwoInt64(float64(afsOrder.RefundMoneyByCal-afsOrder.PmSkuSubsidyMoney)*float64(orderSku.UserMoney+orderSku.PmSubsidyMoney-orderSku.PmSkuSubsidyMoney)/float64(afsOrder.SkuUserMoney+afsOrder.PmSubsidyMoney-afsOrder.PmSkuSubsidyMoney))
afsOrder.Skus[0].RefundMoneyByCal += orderSku.RefundMoneyByCal
if err = dao.CreateEntity(db, orderSku); err != nil {
return err
}
}
if len(afsOrder.Skus) > 0 {
orderSku := afsOrder.Skus[0]
orderSku.RefundMoneyByCal = afsOrder.RefundMoneyByCal - orderSku.RefundMoneyByCal
if err = dao.CreateEntity(db, orderSku); err != nil {
return err
}
}
dao.Commit(db)
return err
}
// 转自送实际使用美团/达达配送，调用此方法
func (c *OrderManager) UpdataOrderFinancialInfo(orderFinancial *model.OrderFinancial, wayBill *model.Waybill) (err error) {
// 通过本地数据库去取是否转美团/达达，并计算运费，写在上级调用函数里面传递过来
// wayBill, err2 := partner.CurOrderManager.LoadWaybill(orderFinancial.VendorOrderID, orderFinancial.VendorID)
// if err = err2; err == nil {
// orderFinancial.JxFreightMoney = wayBill.DesiredFee
// }
db := dao.GetDB()
dao.Begin(db)
defer func() {
if r := recover(); r != nil || err != nil {
dao.Rollback(db)
if r != nil {
panic(r)
}
}
}()
orderFinancial.JxFreightMoney = wayBill.DesiredFee
if (orderFinancial.JxFreightMoney - orderFinancial.SelfDeliveryDiscountMoney) > MaxFreightMoneyFromJxByShop {
orderFinancial.JxFreightMoneyByShop = orderFinancial.SelfDeliveryDiscountMoney + MaxFreightMoneyFromJxByShop
} else if (orderFinancial.JxFreightMoney - orderFinancial.SelfDeliveryDiscountMoney) < 0 {
orderFinancial.JxFreightMoneyByShop = orderFinancial.SelfDeliveryDiscountMoney
} else {
orderFinancial.JxFreightMoneyByShop = orderFinancial.JxFreightMoney
}
orderFinancial.JxShopMoney -= orderFinancial.JxFreightMoneyByShop
// orderFinancial.JxFreightMoneyByShop 的改变直接影响到单条sku的京西结算金额的改变
jxDecMoney := orderFinancial.JxFreightMoneyByShop
for _, sku := range orderFinancial.Skus[1:] {
// 重新计算单条sku京西应该结算的金额
skuJxDecMoney := utils.Float64TwoInt64(float64(jxDecMoney*sku.SalePrice*int64(sku.Count)+sku.SkuBoxMoney) / float64(orderFinancial.SalePriceMoney+orderFinancial.SkuBoxMoney))
sku.JxDeductionsMoney += skuJxDecMoney
sku.JxShopMoney -= skuJxDecMoney
jxDecMoney -= skuJxDecMoney
if _, err = dao.UpdateEntity(db, sku); err != nil {
return err
}
}
if len(orderFinancial.Skus) > 0 {
sku := orderFinancial.Skus[0]
sku.JxDeductionsMoney += jxDecMoney
sku.JxShopMoney -= jxDecMoney
if _, err = dao.UpdateEntity(db, sku); err != nil {
return err
}
}
if err = dao.CreateEntity(db, orderFinancial); err != nil {
globals.SugarLogger.Warnf("On SaveOrderFinancialInfo err: order is err")
return err
}
dao.Commit(db)
// orderFinancial 和 OrderSkuFinancial 数据计算完毕，准备进行更新
return err
}
// 正向订单设置小费后更新信息，需要再去订单查询列表接口查询小费金额，然后传递过来，感觉这样一个个写非常麻烦（以下demo是以京东为例）
// 为什么不直接用OrderDetail2Financial再处理一遍，通过传递一个type=新建/更新，在SaveOrderFinancialInfo进行相应的数据库操作
// func UpdataOrderFinancialInfoByTips(orderFinancial *model.OrderFinancial, orderData map[string]interface{}) (err error) {
// db := dao.GetDB()
// dao.Begin(db)
// defer dao.Rollback(db)
// order1, err2 := api.JdAPI.OrderShoudSettlementService(orderFinancial.VendorOrderID) // 考虑放到上层实现然后传递过来
// orderFinancial.FreightTipsMoney = utils.MustInterface2Int64(orderData["tips"])
// pmMoney := orderFinancial.PmMoney
// JxPmMoney := orderFinancial.JxPmMoney
// orderFinancial.PmMoney = 0
// // 京东/京西平台费可能会变化
// if err = err2; err == nil {
// orderFinancial.ShopMoney = utils.Interface2Int64WithDefault(order1["settlementAmount"], 0)
// orderFinancial.PmMoney += utils.Interface2Int64WithDefault(order1["goodsCommission"], 0)
// orderFinancial.PmMoney += utils.Interface2Int64WithDefault(order1["freightCommission"], 0)
// orderFinancial.PmMoney += utils.Interface2Int64WithDefault(order1["packageCommission"], 0)
// orderFinancial.PmMoney += utils.Interface2Int64WithDefault(order1["guaranteedCommission"], 0)
// orderFinancial.JxPmMoney = (orderFinancial.ShopMoney+orderFinancial.PmMoney)*TotalRate/1000 - orderFinancial.PmMoney // 京西平台费 = 总金额*20%-第三方平台费
// if orderFinancial.JxPmMoney < 0 { // 如果算出京西平台费为负数，则置0
// orderFinancial.JxPmMoney = 0
// }
// // 计算在此次变动中，第三方平台结算费用的变化值
// decMoney := orderFinancial.FreightTipsMoney + orderFinancial.PmMoney - pmMoney
// orderFinancial.ShopMoneyByCal -= decMoney
// decMoney2 := decMoney
// // 计算在此次变动中，京西结算费用的变化值
// jxDecMoney := decMoney + orderFinancial.JxPmMoney - JxPmMoney
// orderFinancial.JxShopMoney -= jxDecMoney
// jxDecMoney2 := jxDecMoney
// for _, sku := range orderFinancial.Skus[1:] {
// // 重新计算单条sku平台应该结算的金额
// skuDecMoney := utils.Float64TwoInt64(float64(decMoney*sku.SalePrice*int64(sku.Count)+sku.MealBoxMoney) / float64(orderFinancial.SalePriceMoney+orderFinancial.MealBoxMoney))
// sku.PmDeductionsMoney += skuDecMoney
// sku.ShopMoneyByCal -= skuDecMoney
// decMoney2 -= skuDecMoney
// // 重新计算单条sku京西应该结算的金额
// skuJxDecMoney := utils.Float64TwoInt64(float64(jxDecMoney*sku.SalePrice*int64(sku.Count)+sku.MealBoxMoney) / float64(orderFinancial.SalePriceMoney+orderFinancial.MealBoxMoney))
// sku.JxDeductionsMoney += skuJxDecMoney
// sku.JxShopMoney -= skuJxDecMoney
// jxDecMoney2 -= skuJxDecMoney
// if err = dao.UpdateEntity(db, sku); err != nil {
// return err
// }
// }
// if len(orderFinancial.Skus) > 0 {
// sku := orderFinancial.Skus[0]
// sku.PmDeductionsMoney += decMoney2
// sku.ShopMoneyByCal -= decMoney2
// sku.JxDeductionsMoney += jxDecMoney2
// sku.JxShopMoney -= jxDecMoney2
// if err = dao.UpdateEntity(db, sku); err != nil {
// return err
// }
// }
// // orderFinancial 和 OrderSkuFinancial 数据计算完毕，准备进行更新
// // 更新
// // 更新
// } else {
// globals.SugarLogger.Warnf("jd OrderDetail2Financial, orderID:%s is not found from api.JdAPI.OrderShoudSettlementService", orderFinancial.VendorOrderID)
// }
// return err
// }
// 正向订单转自配送后更新信息
// func SaveOrderFinancialInfoBySelf(orderFinancial *model.OrderFinancial) (err error) {
// // 此时考虑之前有没有设置小费，如果设置了小费，要扣掉
// return err
// }

42
business/jxcallback/orderman/order.go
View File

@@ -402,6 +402,48 @@ func (c *OrderManager) LoadOrder2(vendorOrderID2 string, vendorID int) (order *m
return c.loadOrder("", vendorOrderID2, vendorID)
}
func (c *OrderManager) LoadOrderFinancial(vendorOrderID string, vendorID int) (order *model.OrderFinancial, err error) {
return c.loadOrderFinancial(vendorOrderID, "", vendorID)
}
func (c *OrderManager) LoadOrderFinancial2(vendorOrderID2 string, vendorID int) (order *model.OrderFinancial, err error) {
return c.loadOrderFinancial("", vendorOrderID2, vendorID)
}
func (c *OrderManager) loadOrderFinancial(vendorOrderID, vendorOrderID2 string, vendorID int) (order *model.OrderFinancial, err error) {
db := orm.NewOrm()
order = &model.OrderFinancial{
VendorOrderID: vendorOrderID,
VendorOrderID2: vendorOrderID2,
VendorID: vendorID,
}
keyFields := []string{
model.FieldVendorID,
}
if vendorOrderID != "" {
keyFields = append(keyFields, model.FieldVendorOrderID)
}
if vendorOrderID2 != "" {
keyFields = append(keyFields, model.FieldVendorOrderID2)
}
// 这块不知道怎么写了、、、标注一下
if err = db.Read(order, keyFields...); err == nil {
vendorOrderID = order.VendorOrderID
err = utils.CallFuncLogError(func() error {
_, err = db.QueryTable("order_sku_financial").Filter("vendor_order_id", vendorOrderID).Filter("vendor_id", vendorID).All(&order.Skus)
return err
}, "LoadOrder orderID:%s", vendorOrderID)
}
if err != nil {
if err == orm.ErrNoRows {
err = ErrCanNotFindOrder
}
globals.SugarLogger.Infof("LoadOrderFinancial orderID:%s failed with error:%v", vendorOrderID, err)
}
return order, err
}
func (c *OrderManager) UpdateOrderStatusAndFlag(order *model.GoodsOrder) (err error) {
db := orm.NewOrm()
utils.CallFuncLogError(func() error {

112
business/jxcallback/orderman/orderman_ext.go
View File

@@ -490,3 +490,115 @@ func (c *OrderManager) GetOrderStatusList(ctx *jxcontext.Context, vendorOrderID
}
return statusList, nil
}
func (c *OrderManager) GetOrdersFinancial(ctx *jxcontext.Context, fromDateStr, toDateStr string, params map[string]interface{}, offset, pageSize int) (pagedInfo *model.PagedInfo, err error) {
globals.SugarLogger.Debugf("GetOrdersFinancial from:%s to:%s", fromDateStr, toDateStr)
pageSize = jxutils.FormalizePageSize(pageSize)
if offset < 0 {
offset = 0
}
sql := `
SELECT SQL_CALC_FOUND_ROWS t1.*,
t2.store_name,t2.vendor_store_id,t2.store_id,t2.jx_store_id,t2.status,t2.order_finished_at
FROM order_financial t1
LEFT JOIN goods_order t2 ON t1.vendor_order_id = t2.vendor_order_id
`
var (
sqlWhere string
sqlParams []interface{}
)
if params["orderID"] != nil {
sqlWhere = " WHERE (t1.vendor_order_id = ? OR t1.vendor_order_id2 = ?)"
sqlParams = []interface{}{
params["orderID"],
params["orderID"],
}
} else {
fromDate, err2 := utils.TryStr2Time(fromDateStr)
if err = err2; err != nil {
return nil, err
}
if toDateStr == "" {
toDateStr = fromDateStr
}
toDate, err2 := utils.TryStr2Time(toDateStr)
if err = err2; err != nil {
return nil, err
}
toDate = toDate.Add(24 * time.Hour)
sqlWhere = `
WHERE t2.order_finished_at >= ? AND t2.order_finished_at < ?
`
sqlParams = []interface{}{
fromDate,
toDate,
}
if params["vendorIDs"] != nil {
var vendorIDs []int
if err = utils.UnmarshalUseNumber([]byte(params["vendorIDs"].(string)), &vendorIDs); err != nil {
return nil, err
}
if len(vendorIDs) > 0 {
sqlWhere += " AND t1.vendor_id IN (" + dao.GenQuestionMarks(len(vendorIDs)) + ")"
sqlParams = append(sqlParams, vendorIDs)
}
}
if params["storeIDs"] != nil {
var storeIDs []int
if err = utils.UnmarshalUseNumber([]byte(params["storeIDs"].(string)), &storeIDs); err != nil {
return nil, err
}
if len(storeIDs) > 0 {
sqlWhere += " AND IF(t1.vendor_id = ?, t2.store_id, IF(t2.jx_store_id != 0, t2.jx_store_id, t2.store_id)) IN (" + dao.GenQuestionMarks(len(storeIDs)) + ")"
sqlParams = append(sqlParams, model.VendorIDWSC, storeIDs)
}
}
if params["statuss"] != nil {
var statuss []int
if err = utils.UnmarshalUseNumber([]byte(params["statuss"].(string)), &statuss); err != nil {
return nil, err
}
if len(statuss) > 0 {
sqlWhere += " AND t2.status IN (" + dao.GenQuestionMarks(len(statuss)) + ")"
sqlParams = append(sqlParams, statuss)
}
}
if params["cities"] != nil {
var cities []int
if err = utils.UnmarshalUseNumber([]byte(params["cities"].(string)), &cities); err != nil {
return nil, err
}
if len(cities) > 0 {
sql += "JOIN store st ON t2.store_id = st.id"
sqlWhere += " AND st.city_code IN (" + dao.GenQuestionMarks(len(cities)) + ")"
sqlParams = append(sqlParams, cities)
}
}
}
sql += sqlWhere
sql += `
ORDER BY t1.delivery_confirm_time DESC
LIMIT ? OFFSET ?
`
sqlParams = append(sqlParams, pageSize, offset)
var orders []*model.OrderFinancialExt
db := dao.GetDB()
dao.Begin(db)
defer func() {
if r := recover(); r != nil {
dao.Rollback(db)
panic(r)
}
}()
if err = dao.GetRows(db, &orders, sql, sqlParams...); err == nil {
pagedInfo = &model.PagedInfo{
TotalCount: dao.GetLastTotalRowCount(db),
Data: orders,
}
}
dao.Commit(db)
return pagedInfo, err
}