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

- 去除无用代码，主要是promotion相关的

Browse Source
This commit is contained in:
gazebo
2019-08-14 11:12:33 +08:00
parent 667e27d62e
commit 4c484a6280
17 changed files with 179 additions and 1878 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
business/jxstore/cms/cms.go
View File

@@ -73,8 +73,6 @@ func InitServiceInfo(version string, buildTime time.Time, gitCommit string) {
"vendorName": model.VendorChineseNames,
"orderStatus": model.OrderStatusName,
"waybillStatus": model.WaybillStatusName,
// "bankName": model.BankName,
"promotionStatusName": model.PromotionStatusName,
"orderTypeName": model.OrderTypeName,
"taskStatusName": tasksch.TaskStatusName,
"opRequestTypeName": model.RequestTypeName,

6
business/jxstore/cms/store_sku.go
View File

@@ -433,11 +433,7 @@ func GetStoresSkusNew(ctx *jxcontext.Context, storeIDs, skuIDs []int, isFocus bo
storeIDs, skuIDs = GetStoreAndSkuIDsFromInfo(skuNamesInfo)
}
beginTime := time.Now()
if globals.EnableNewAct {
err = updateActPrice4StoreSkuNameNew(db, storeIDs, skuIDs, skuNamesInfo)
} else {
// err = updateActPrice4StoreSkuName(db, storeIDs, skuIDs, skuNamesInfo)
}
err = updateActPrice4StoreSkuNameNew(db, storeIDs, skuIDs, skuNamesInfo)
globals.SugarLogger.Debugf("GetStoresSkusNew updateActPrice4StoreSkuName:%v", time.Now().Sub(beginTime))
if !isFocus {
err = updateUnitPrice4StoreSkuNameNew(db, skuNamesInfo)

1111
business/jxstore/promotion/jd_promotion.go
View File

File diff suppressed because it is too large Load Diff

15
business/jxstore/promotion/jd_promotion_test.go
View File

@@ -1,15 +0,0 @@
package promotion
import (
"testing"
"git.rosy.net.cn/jx-callback/globals/testinit"
)
func init() {
testinit.Init()
}
func TestCreateLocalPromotionFromRemote(t *testing.T) {
t.Log(createLocalPromotionFromRemote(14510904))
}

89
business/jxstore/promotion/promotion.go
View File

@@ -1,89 +0,0 @@
package promotion
import (
"strings"
"time"
"github.com/KenmyZhang/aliyun-communicate"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
"git.rosy.net.cn/jx-callback/business/model/dao"
"git.rosy.net.cn/jx-callback/globals"
)
const (
DefGoodsOrderDays = 60
MaxBatchSize = 500
)
type tMobileInfo struct {
Mobile string
}
func SendAdvertingByGoodsOrder(ctx *jxcontext.Context, advertising string, days int, isAsync bool, userName string) (hint string, err error) {
globals.SugarLogger.Debugf("SendAdvertingByGoodsOrder advertising:%s, days:%d, isAsync:%t, userName:%s", advertising, days, isAsync, userName)
if days == 0 {
days = DefGoodsOrderDays
}
sqlParams := []interface{}{}
sql1 := `
SELECT IF(t1.consignee_mobile2 <> '', t1.consignee_mobile2, t1.consignee_mobile) mobile
FROM goods_order t1
LEFT JOIN black_client t2 ON IF(t1.consignee_mobile2 <> '', t1.consignee_mobile2, t1.consignee_mobile) = t2.mobile
WHERE IF(t1.consignee_mobile2 <> '', t1.consignee_mobile2, t1.consignee_mobile) <> '' AND t2.id IS NULL AND LENGTH(IF(t1.consignee_mobile2 <> '', t1.consignee_mobile2, t1.consignee_mobile)) = 11 AND LEFT(IF(t1.consignee_mobile2 <> '', t1.consignee_mobile2, t1.consignee_mobile), 1) = '1'
`
sql2 := `
SELECT buyer_mobile mobile
FROM jxorder t1
LEFT JOIN black_client t2 ON t1.buyer_mobile = t2.mobile
WHERE buyer_mobile IS NOT NULL AND buyer_mobile <> '' AND t2.id IS NULL AND LENGTH(buyer_mobile) = 11 AND LEFT(buyer_mobile, 1) = '1'
`
if days > 0 {
sql1 += " AND order_created_at > ?"
sql2 += " AND order_start_time > ?"
daysTime := time.Now().Add(-time.Duration(days) * 24 * time.Hour)
sqlParams = append(sqlParams, daysTime, daysTime)
}
var mobiles []*tMobileInfo
db := dao.GetDB()
if err = dao.GetRows(db, &mobiles, sql1+" UNION DISTINCT "+sql2, sqlParams...); err != nil {
return "", err
}
index := 0
mobileNumbers := make([]string, len(mobiles))
for _, v := range mobiles {
if v.Mobile[:1] == "1" && strings.Index(v.Mobile, ",") == -1 {
mobileNumbers[index] = v.Mobile
index++
}
}
mobileNumbers = mobileNumbers[:index]
mobileNumbers = append(mobileNumbers, "18180948107")
smsClient := aliyunsmsclient.New("http://dysmsapi.aliyuncs.com/")
task := tasksch.NewParallelTask("SendAdvertingByGoodsOrder", tasksch.NewParallelConfig().SetBatchSize(MaxBatchSize), ctx,
func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
numbers := make([]string, len(batchItemList))
for k, v := range batchItemList {
numbers[k] = v.(string)
}
numberStr := strings.Join(numbers, ",")
_, err = smsClient.Execute(globals.AliKey, globals.AliSecret, numberStr, "京西菜市", "SMS_109345355", string(utils.MustMarshal(map[string]interface{}{
"code": "code",
})))
if err != nil {
globals.SugarLogger.Infof("SendAdvertingByGoodsOrder numbers:%s failed with error:%v", numberStr, err)
}
return nil, err
}, mobileNumbers)
tasksch.HandleTask(task, nil, true).Run()
if !isAsync {
_, err = task.GetResult(0)
}
return task.ID, err
}

292
business/jxstore/tempop/tempop.go
View File

@@ -2,9 +2,7 @@ package tempop
import (
"fmt"
"math"
"regexp"
"strings"
"sync"
"time"
@@ -13,7 +11,6 @@ import (
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/jxstore/cms"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
@@ -21,7 +18,6 @@ import (
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/model/dao"
"git.rosy.net.cn/jx-callback/business/model/legacymodel"
"git.rosy.net.cn/jx-callback/business/model/legacymodel2"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/business/partner/purchase/ebai"
"git.rosy.net.cn/jx-callback/globals"
@@ -284,79 +280,79 @@ func Change2JDSPU4Store(ctx *jxcontext.Context, storeIDs []int, step int, isAsyn
return hint, err
}
func TransferLegacyJdOrder(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
sqlBatchCount := 1000
rootTask := tasksch.NewSeqTask("TransferLegacyJdOrder", ctx,
func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
sql := `
SELECT t1.*
FROM jdorder t1
LEFT JOIN goods_order_original t2 ON t2.vendor_order_id = t1.vendor_order_id
WHERE t2.id IS NULL AND LENGTH(t1.data) > 10 AND t1.cityname = 'all'
ORDER BY t1.orderstatustime
LIMIT ?
`
db := dao.GetDB()
var jdOrderList []*legacymodel2.Jdorder
if err = dao.GetRows(db, &jdOrderList, sql, sqlBatchCount); err != nil {
return nil, err
}
if len(jdOrderList) > 0 {
task := tasksch.NewParallelTask("TransferLegacyJdOrder2", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetBatchSize(40), ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
var orderDetailList []*model.GoodsOrderOriginal
for _, v := range batchItemList {
jdOrder := v.(*legacymodel2.Jdorder)
var detail map[string]interface{}
if err = utils.UnmarshalUseNumber([]byte(strings.Replace(strings.Replace(jdOrder.Data, "\n", "", -1), "\r", "", -1)), &detail); err != nil {
return nil, err
}
resultList := detail["result"].(map[string]interface{})["resultList"].([]interface{})
if len(resultList) > 0 {
originalData := resultList[0].(map[string]interface{})
orgCode := originalData["orgCode"].(string)
if orgCode == "320406" {
orderPurchaseTime := utils.Interface2String(originalData["orderPurchaseTime"])
if orderPurchaseTime == "" {
globals.SugarLogger.Debugf("TransferLegacyJdOrder abnormal order:%s", jdOrder.VendorOrderID)
orderPurchaseTime = utils.Interface2String(originalData["orderStartTime"])
}
if orderPurchaseTime != "" {
orderDetail := &model.GoodsOrderOriginal{
VendorOrderID: jdOrder.VendorOrderID,
VendorID: model.VendorIDJD,
AccountNo: orgCode,
OrderCreatedAt: utils.Str2Time(orderPurchaseTime),
OriginalData: string(utils.MustMarshal(originalData)),
}
orderDetailList = append(orderDetailList, orderDetail)
} else {
globals.SugarLogger.Debugf("TransferLegacyJdOrder abnormal2 order:%s", jdOrder.VendorOrderID)
}
}
}
}
if len(orderDetailList) > 0 {
err = dao.CreateMultiEntities(db, orderDetailList)
}
return nil, err
}, jdOrderList)
// rootTask.AddChild(task).Run()
task.Run()
_, err = task.GetResult(0)
} else {
rootTask.Cancel()
}
return nil, err
}, math.MaxInt32)
tasksch.ManageTask(rootTask).Run()
if !isAsync {
_, err = rootTask.GetResult(0)
} else {
hint = rootTask.ID
}
return hint, err
}
// func TransferLegacyJdOrder(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
// sqlBatchCount := 1000
// rootTask := tasksch.NewSeqTask("TransferLegacyJdOrder", ctx,
// func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
// sql := `
// SELECT t1.*
// FROM jdorder t1
// LEFT JOIN goods_order_original t2 ON t2.vendor_order_id = t1.vendor_order_id
// WHERE t2.id IS NULL AND LENGTH(t1.data) > 10 AND t1.cityname = 'all'
// ORDER BY t1.orderstatustime
// LIMIT ?
// `
// db := dao.GetDB()
// var jdOrderList []*legacymodel2.Jdorder
// if err = dao.GetRows(db, &jdOrderList, sql, sqlBatchCount); err != nil {
// return nil, err
// }
// if len(jdOrderList) > 0 {
// task := tasksch.NewParallelTask("TransferLegacyJdOrder2", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetBatchSize(40), ctx,
// func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
// var orderDetailList []*model.GoodsOrderOriginal
// for _, v := range batchItemList {
// jdOrder := v.(*legacymodel2.Jdorder)
// var detail map[string]interface{}
// if err = utils.UnmarshalUseNumber([]byte(strings.Replace(strings.Replace(jdOrder.Data, "\n", "", -1), "\r", "", -1)), &detail); err != nil {
// return nil, err
// }
// resultList := detail["result"].(map[string]interface{})["resultList"].([]interface{})
// if len(resultList) > 0 {
// originalData := resultList[0].(map[string]interface{})
// orgCode := originalData["orgCode"].(string)
// if orgCode == "320406" {
// orderPurchaseTime := utils.Interface2String(originalData["orderPurchaseTime"])
// if orderPurchaseTime == "" {
// globals.SugarLogger.Debugf("TransferLegacyJdOrder abnormal order:%s", jdOrder.VendorOrderID)
// orderPurchaseTime = utils.Interface2String(originalData["orderStartTime"])
// }
// if orderPurchaseTime != "" {
// orderDetail := &model.GoodsOrderOriginal{
// VendorOrderID: jdOrder.VendorOrderID,
// VendorID: model.VendorIDJD,
// AccountNo: orgCode,
// OrderCreatedAt: utils.Str2Time(orderPurchaseTime),
// OriginalData: string(utils.MustMarshal(originalData)),
// }
// orderDetailList = append(orderDetailList, orderDetail)
// } else {
// globals.SugarLogger.Debugf("TransferLegacyJdOrder abnormal2 order:%s", jdOrder.VendorOrderID)
// }
// }
// }
// }
// if len(orderDetailList) > 0 {
// err = dao.CreateMultiEntities(db, orderDetailList)
// }
// return nil, err
// }, jdOrderList)
// // rootTask.AddChild(task).Run()
// task.Run()
// _, err = task.GetResult(0)
// } else {
// rootTask.Cancel()
// }
// return nil, err
// }, math.MaxInt32)
// tasksch.ManageTask(rootTask).Run()
// if !isAsync {
// _, err = rootTask.GetResult(0)
// } else {
// hint = rootTask.ID
// }
// return hint, err
// }
func TransferLegacyElmOrder(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
// sqlBatchCount := 1000
@@ -595,77 +591,77 @@ type GoodsOrderOriginalEx struct {
OrderStatus int
}
func CreateOrderFromOriginal(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
sqlBatchCount := 5000
rootTask := tasksch.NewSeqTask("CreateOrderFromOriginal", ctx,
func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
sql := `
SELECT t1.*, t3.order_status
FROM goods_order_original t1
LEFT JOIN goods_order t2 ON t2.vendor_order_id = t1.vendor_order_id
LEFT JOIN jxorder t3 ON t3.order_id = t1.vendor_order_id
WHERE t2.id IS NULL
LIMIT ?;
`
db := dao.GetDB()
var orderList []*GoodsOrderOriginalEx
if err = dao.GetRows(db, &orderList, sql, sqlBatchCount); err != nil {
return nil, err
}
if len(orderList) > 0 {
task := tasksch.NewParallelTask("CreateOrderFromOriginal", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(1), ctx,
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
orderOriginal := batchItemList[0].(*GoodsOrderOriginalEx)
globals.SugarLogger.Debugf("CreateOrderFromOriginal processing orderID:%s", orderOriginal.VendorOrderID)
if handler := partner.GetPurchasePlatformFromVendorID(orderOriginal.VendorID); handler != nil {
var detail map[string]interface{}
if err = utils.UnmarshalUseNumber([]byte(strings.Replace(strings.Replace(orderOriginal.OriginalData, "\n", "", -1), "\r", "", -1)), &detail); err != nil {
globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
return nil, err
}
order := handler.Map2Order(detail)
if order.Status < model.OrderStatusEndBegin {
if orderOriginal.OrderStatus == 3 {
order.Status = model.OrderStatusFinished
} else if orderOriginal.OrderStatus == 7 {
order.Status = model.OrderStatusCanceled
} else {
order2, err2 := handler.GetOrder(order.VendorOrderID)
if err = err2; err == nil {
order.Status = order2.Status
} else {
err = nil // ignore get status error
}
}
}
if err == nil {
if _, err = orderman.FixedOrderManager.SaveOrder(order, false, dao.GetDB()); err != nil {
globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
}
} else {
globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
}
} else {
globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s", orderOriginal.VendorOrderID)
}
return nil, err
}, orderList)
// rootTask.AddChild(task).Run()
task.Run()
_, err = task.GetResult(0)
} else {
rootTask.Cancel()
}
return nil, err
}, math.MaxInt32)
tasksch.ManageTask(rootTask).Run()
if !isAsync {
_, err = rootTask.GetResult(0)
} else {
hint = rootTask.ID
}
return hint, err
}
// func CreateOrderFromOriginal(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
// sqlBatchCount := 5000
// rootTask := tasksch.NewSeqTask("CreateOrderFromOriginal", ctx,
// func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
// sql := `
// SELECT t1.*, t3.order_status
// FROM goods_order_original t1
// LEFT JOIN goods_order t2 ON t2.vendor_order_id = t1.vendor_order_id
// LEFT JOIN jxorder t3 ON t3.order_id = t1.vendor_order_id
// WHERE t2.id IS NULL
// LIMIT ?;
// `
// db := dao.GetDB()
// var orderList []*GoodsOrderOriginalEx
// if err = dao.GetRows(db, &orderList, sql, sqlBatchCount); err != nil {
// return nil, err
// }
// if len(orderList) > 0 {
// task := tasksch.NewParallelTask("CreateOrderFromOriginal", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(1), ctx,
// func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
// orderOriginal := batchItemList[0].(*GoodsOrderOriginalEx)
// globals.SugarLogger.Debugf("CreateOrderFromOriginal processing orderID:%s", orderOriginal.VendorOrderID)
// if handler := partner.GetPurchasePlatformFromVendorID(orderOriginal.VendorID); handler != nil {
// var detail map[string]interface{}
// if err = utils.UnmarshalUseNumber([]byte(strings.Replace(strings.Replace(orderOriginal.OriginalData, "\n", "", -1), "\r", "", -1)), &detail); err != nil {
// globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
// return nil, err
// }
// order := handler.Map2Order(detail)
// if order.Status < model.OrderStatusEndBegin {
// if orderOriginal.OrderStatus == 3 {
// order.Status = model.OrderStatusFinished
// } else if orderOriginal.OrderStatus == 7 {
// order.Status = model.OrderStatusCanceled
// } else {
// order2, err2 := handler.GetOrder(order.VendorOrderID)
// if err = err2; err == nil {
// order.Status = order2.Status
// } else {
// err = nil // ignore get status error
// }
// }
// }
// if err == nil {
// if _, err = orderman.FixedOrderManager.SaveOrder(order, false, dao.GetDB()); err != nil {
// globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
// }
// } else {
// globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s, error:%v", orderOriginal.VendorOrderID, err)
// }
// } else {
// globals.SugarLogger.Debugf("CreateOrderFromOriginal abnormal orderID:%s", orderOriginal.VendorOrderID)
// }
// return nil, err
// }, orderList)
// // rootTask.AddChild(task).Run()
// task.Run()
// _, err = task.GetResult(0)
// } else {
// rootTask.Cancel()
// }
// return nil, err
// }, math.MaxInt32)
// tasksch.ManageTask(rootTask).Run()
// if !isAsync {
// _, err = rootTask.GetResult(0)
// } else {
// hint = rootTask.ID
// }
// return hint, err
// }
func TransformJdSpu2Sku(ctx *jxcontext.Context, skuNameIDs []int, count int, isAsync, isContinueWhenError bool) (hint string, err error) {
sql := `