- refactor jxcontent and tasksch (remove dependency from jxcontent to tasksch)

- send dingding msg to user when async task finished
2019-03-22 15:04:28 +08:00
parent 0f5445020a
commit 25ac631c5c
31 changed files with 1527 additions and 1488 deletions
--- a/business/auth2/auth2.go
+++ b/business/auth2/auth2.go
@@ -387,3 +387,7 @@ func DisableUser(userID, operatorUserName string) (err error) {
 	}
 	return err
 }
+
+func GetUserBindAuthInfo(userID string) (authList []*model.AuthBind, err error) {
+	return dao.GetUserBindAuthInfo(dao.GetDB(), userID)
+}
--- a/business/jxstore/cms/message.go
+++ b/business/jxstore/cms/message.go
@@ -41,7 +41,7 @@ func SendStoreMessage(ctx *jxcontext.Context, title, content string, storeIDs []
 	}
 	dao.Commit(db)

-	rootTask := tasksch.NewParallelTask("SendStoreMessage", nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("SendStoreMessage", nil, ctx, func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 		db := dao.GetDB()
 		msgStatus := batchItemList[0].(*model.MessageStatus)
 		if err = weixinmsg.NotifyStoreMessage(msgStatus.StoreID, msgStatus.MessageID, msgStatus.ID, msg.Title, msg.Content); err == nil {
--- a/business/jxstore/cms/store.go
+++ b/business/jxstore/cms/store.go
@@ -750,7 +750,8 @@ func RefreshMissingDadaStores(ctx *jxcontext.Context, storeID int, isAsync, isCo
 	if err != nil {
 		return "", err
 	}
-	task := tasksch.NewParallelTask("RefreshMissingDadaStores", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("RefreshMissingDadaStores", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			storeDetail := batchItemList[0].(*dao.StoreDetail2)
 			_, err = api.DadaAPI.ShopDetail(utils.Int2Str(storeDetail.ID))
 			if err != nil {
@@ -782,8 +783,7 @@ func RefreshMissingDadaStores(ctx *jxcontext.Context, storeID int, isAsync, isCo
 			}
 			return nil, err
 		}, storeList)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	tasksch.HandleTask(task, nil, true).Run()
 	hint = task.ID
 	if !isAsync {
 		_, err = task.GetResult(0)
--- a/business/jxstore/cms/sync.go
+++ b/business/jxstore/cms/sync.go
@@ -130,7 +130,8 @@ func (v *VendorSync) GetSingleStoreHandler(vendorID int) partner.ISingleStoreHan

 func (v *VendorSync) syncCategories(ctx *jxcontext.Context, parentTask tasksch.ITask, multiStoresHandler partner.IMultipleStoresHandler, db *dao.DaoDB, cats []*model.SkuCategory, userName string) (err error) {
 	syncStatusFieldName := dao.GetSyncStatusStructField(model.VendorNames[multiStoresHandler.GetVendorID()])
-	task := tasksch.NewParallelTask("syncCategories", nil, userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
+	task := tasksch.NewParallelTask("syncCategories", nil, ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
 			cat := batchItemList[0].(*model.SkuCategory)
 			updateFields := []string{syncStatusFieldName}
 			syncStatus := jxutils.GetObjFieldByName(cat, syncStatusFieldName).(int8)
@@ -151,8 +152,7 @@ func (v *VendorSync) syncCategories(ctx *jxcontext.Context, parentTask tasksch.I
 			}
 			return nil, err
 		}, cats)
-	ctx.SetTaskOrAddChild(task, parentTask)
-	task.Run()
+	tasksch.HandleTask(task, parentTask, false).Run()
 	_, err = task.GetResult(0)
 	return err
 }
@@ -212,7 +212,8 @@ func (v *VendorSync) SyncStore(ctx *jxcontext.Context, db *dao.DaoDB, vendorID,
 		loopMapInfo := batchItemList[0].(*LoopStoreMapInfo)
 		handler := v.GetStoreHandler(loopMapInfo.VendorID)
 		if len(loopMapInfo.StoreMapList) > 1 {
-			loopStoreTask := tasksch.NewParallelTask(fmt.Sprintf("SyncStore loop store %s", model.VendorChineseNames[loopMapInfo.VendorID]), nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			loopStoreTask := tasksch.NewParallelTask(fmt.Sprintf("SyncStore loop store %s", model.VendorChineseNames[loopMapInfo.VendorID]), nil, ctx,
+				func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 					storeMap := batchItemList[0].(*model.StoreMap)
 					if err = handler.UpdateStore(db, storeMap.StoreID, userName); err == nil {
 						storeMap.SyncStatus = 0
@@ -262,7 +263,8 @@ func (v *VendorSync) SyncSku(ctx *jxcontext.Context, db *dao.DaoDB, nameID, skuI
 		err := dao.GetRows(db, &skuNameList, sql, sqlParams...)
 		if err == nil && len(skuNameList) > 0 {
 			// todo 同一skuName下的sku顺序处理的原因是京东SPU特殊类型必须要序列化同步才能正常处理, db可能会有多线程问题
-			task := tasksch.NewParallelTask("SyncSku loop sku", tasksch.NewParallelConfig().SetParallelCount(10).SetIsContinueWhenError(isContinueWhenError), userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
+			task := tasksch.NewParallelTask("SyncSku loop sku", tasksch.NewParallelConfig().SetParallelCount(10).SetIsContinueWhenError(isContinueWhenError), ctx,
+				func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
 					skuName := batchItemList[0].(*model.SkuName)
 					var skuList []*model.Sku
 					if err = dao.GetRows(db, &skuList, fmt.Sprintf(`
@@ -320,7 +322,8 @@ func (v *VendorSync) SyncStoresCategory(ctx *jxcontext.Context, db *dao.DaoDB, v
 		loopMapInfo := batchItemList[0].(*LoopStoreMapInfo)
 		if handler := v.GetSingleStoreHandler(loopMapInfo.VendorID); handler != nil {
 			if len(loopMapInfo.StoreMapList) > 1 {
-				loopStoreTask := tasksch.NewSeqTask("SyncStoresCategory loop stores", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+				loopStoreTask := tasksch.NewSeqTask("SyncStoresCategory loop stores", ctx,
+					func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 						storeID := loopMapInfo.StoreMapList[step].StoreID
 						_, err = handler.SyncStoreCategory(ctx, task, storeID, false)
 						return nil, err
@@ -342,7 +345,8 @@ func (v *VendorSync) SyncStoresSkus(ctx *jxcontext.Context, db *dao.DaoDB, vendo
 		loopMapInfo := batchItemList[0].(*LoopStoreMapInfo)
 		if handler := v.GetStoreHandler(loopMapInfo.VendorID); handler != nil {
 			if len(loopMapInfo.StoreMapList) > 1 {
-				loopStoreTask := tasksch.NewSeqTask("SyncStoresSkus相同平台循环门店", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+				loopStoreTask := tasksch.NewSeqTask("SyncStoresSkus相同平台循环门店", ctx,
+					func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 						storeID := loopMapInfo.StoreMapList[step].StoreID
 						if _, err = handler.SyncStoreSkus(ctx, task, storeID, skuIDs, false, isContinueWhenError); err != nil {
 							globals.SugarLogger.Debugf("SyncStoresSkus failed1 store:%d failed with error:%v", storeID, err)
@@ -368,7 +372,8 @@ func (v *VendorSync) FullSyncStoresSkus(ctx *jxcontext.Context, db *dao.DaoDB, v
 		loopMapInfo := batchItemList[0].(*LoopStoreMapInfo)
 		if handler := v.GetStoreHandler(loopMapInfo.VendorID); handler != nil {
 			if len(loopMapInfo.StoreMapList) > 1 {
-				loopStoreTask := tasksch.NewSeqTask("FullSyncStoresSkus相同平台循环门店", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+				loopStoreTask := tasksch.NewSeqTask("FullSyncStoresSkus相同平台循环门店", ctx,
+					func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 						storeID := loopMapInfo.StoreMapList[step].StoreID
 						_, err = handler.FullSyncStoreSkus(ctx, task, storeID, false, isContinueWhenError)
 						return nil, err
@@ -389,7 +394,8 @@ func (v *VendorSync) DeleteRemoteStoreSkus(ctx *jxcontext.Context, db *dao.DaoDB
 		loopMapInfo := batchItemList[0].(*LoopStoreMapInfo)
 		if handler := v.GetStoreHandler(loopMapInfo.VendorID); handler != nil {
 			if len(loopMapInfo.StoreMapList) > 1 {
-				loopStoreTask := tasksch.NewSeqTask("DeleteRemoteStoreSkus相同平台循环门店", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+				loopStoreTask := tasksch.NewSeqTask("DeleteRemoteStoreSkus相同平台循环门店", ctx,
+					func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 						storeID := loopMapInfo.StoreMapList[step].StoreID
 						_, err = handler.DeleteRemoteStoreSkus(ctx, task, storeID, false, isContinueWhenError)
 						return nil, err
@@ -443,9 +449,8 @@ func (v *VendorSync) LoopStoresMap(ctx *jxcontext.Context, db *dao.DaoDB, taskNa
 		}
 		index++
 	}
-	task := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx.GetUserName(), handler, loopInfoList)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	task := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx, handler, loopInfoList)
+	tasksch.HandleTask(task, nil, true).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
@@ -453,50 +458,17 @@ func (v *VendorSync) LoopStoresMap(ctx *jxcontext.Context, db *dao.DaoDB, taskNa
 }

 func (v *VendorSync) LoopMultiStoresVendors(ctx *jxcontext.Context, db *dao.DaoDB, taskName string, isAsync bool, userName string, handler tasksch.WorkFunc) (hint string, err error) {
-	task := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true), userName, handler, v.MultiStoreVendorIDs)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	task := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx, handler, v.MultiStoreVendorIDs)
+	tasksch.HandleTask(task, nil, true).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
 	return task.ID, makeSyncError(err)
 }

-// func (v *VendorSync) LoopStoreVendors(ctx *jxcontext.Context, db *dao.DaoDB, vendorIDs []int, taskName string, isAsync bool, userName string, handler tasksch.WorkFunc) (hint string, err error) {
-// 	if taskName == "" {
-// 		taskName = "LoopStoreVendors"
-// 	}
-// 	var vendorIDMap map[int]int
-// 	if len(vendorIDs) != 0 {
-// 		vendorIDMap = make(map[int]int)
-// 		for _, v := range vendorIDs {
-// 			vendorIDMap[v] = 1
-// 		}
-// 	}
-// 	allHandlers := make([]int, len(v.MultiStoreVendorIDs)+len(v.SingleStoreVendorIDs))
-// 	copy(allHandlers, v.MultiStoreVendorIDs)
-// 	copy(allHandlers[len(v.MultiStoreVendorIDs):], v.SingleStoreVendorIDs)
-// 	if vendorIDMap != nil {
-// 		count := 0
-// 		for _, v := range allHandlers {
-// 			if vendorIDMap[v] == 1 {
-// 				allHandlers[count] = v
-// 				count++
-// 			}
-// 		}
-// 		allHandlers = allHandlers[:count]
-// 	}
-// 	task := tasksch.NewParallelTask(taskName, nil, userName, handler, allHandlers)
-// 	ctx.SetTaskOrAddChild(task, nil)
-// 	tasksch.ManageTask(task).Run()
-// 	if !isAsync {
-// 		_, err = task.GetResult(0)
-// 	}
-// 	return task.ID, err
-// }
-
 func (v *VendorSync) RefreshAllSkusID(ctx *jxcontext.Context, isAsync bool, vendorIDs []int, storeIDs []int) (hint string, err error) {
-	task := tasksch.NewParallelTask("RefreshAllSkusID", nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("RefreshAllSkusID", nil, ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			vendorID := batchItemList[0].(int)
 			if handler := v.GetStoreHandler(vendorID); handler != nil {
 				if multiHandler, ok := handler.(partner.IMultipleStoresHandler); ok {
@@ -507,8 +479,7 @@ func (v *VendorSync) RefreshAllSkusID(ctx *jxcontext.Context, isAsync bool, vend
 			}
 			return nil, err
 		}, vendorIDs)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	tasksch.HandleTask(task, nil, true).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
@@ -516,15 +487,15 @@ func (v *VendorSync) RefreshAllSkusID(ctx *jxcontext.Context, isAsync bool, vend
 }

 func (v *VendorSync) RefreshAllStoresID(ctx *jxcontext.Context, isAsync bool, vendorIDs []int) (hint string, err error) {
-	task := tasksch.NewParallelTask("RefreshAllStoresID", nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("RefreshAllStoresID", nil, ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			vendorID := batchItemList[0].(int)
 			if handler := v.GetStoreHandler(vendorID); handler != nil {
 				_, err = handler.RefreshAllStoresID(ctx, task, false)
 			}
 			return nil, err
 		}, vendorIDs)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	tasksch.HandleTask(task, nil, true).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
--- a/business/jxstore/cms/user2.go
+++ b/business/jxstore/cms/user2.go
@@ -100,7 +100,7 @@ func RegisterUser(user *model.User, mobileVerifyCode string, inAuthInfo *auth2.A
 func GetUserBindAuthInfo(ctx *jxcontext.Context) (authList []*model.AuthBind, err error) {
 	authInfo, err := ctx.GetV2AuthInfo()
 	if err == nil {
-		return dao.GetUserBindAuthInfo(dao.GetDB(), authInfo.GetID())
+		return auth2.GetUserBindAuthInfo(authInfo.GetID())
 	}
 	return nil, err
 }
--- a/business/jxstore/financial/financial.go
+++ b/business/jxstore/financial/financial.go
@@ -52,7 +52,8 @@ func SendFilesToStores(ctx *jxcontext.Context, files []*multipart.FileHeader, ti
 	}
 	upToken := putPolicy.UploadToken(api.QiniuAPI)
 	cfg := &storage.Config{}
-	task := tasksch.NewParallelTask("SendFilesToStores", tasksch.NewParallelConfig().SetIsContinueWhenError(true), userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("SendFilesToStores", tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			fileInfo := batchItemList[0].(*tUploadFileInfo)
 			fileHeader := fileInfo.FileHeader
 			storeID := fileInfo.StoreID
@@ -95,8 +96,7 @@ func SendFilesToStores(ctx *jxcontext.Context, files []*multipart.FileHeader, ti
 			}
 			return retVal, err
 		}, fileList)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	tasksch.HandleTask(task, nil, true).Run()
 	hint = task.ID
 	if !isAsync {
 		_, err = task.GetResult(0)
--- a/business/jxstore/initdata/initdata.go
+++ b/business/jxstore/initdata/initdata.go
@@ -147,7 +147,8 @@ func InitSkuName(ctx *jxcontext.Context, isForce, isAsync, isContinueWhenError b
 		return "", err
 	}

-	task := tasksch.NewParallelTask("InitSkuName calculate md5", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("InitSkuName calculate md5", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			skuName := batchItemList[0].(*model.SkuName)
 			if skuName.ImgHashCode == "" || isForce {
 				response, err := http.Get(skuName.Img)
@@ -207,7 +208,8 @@ func UploadWeimobImg4SkuName(ctx *jxcontext.Context, nameIDs []int, isAsync, isC
 	if err != nil {
 		return "", err
 	}
-	rootTask := tasksch.NewParallelTask("UploadWeimobImg4SkuName", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(5), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("UploadWeimobImg4SkuName", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(5), ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			skuName := batchItemList[0].(*model.SkuName)
 			if skuName.Img != "" && skuName.ImgWeimob == "" {
 				if globals.EnableWscStoreWrite {
@@ -350,7 +352,8 @@ func BuildSkuFromEbaiStore(ctx *jxcontext.Context, baiduShopID int64, isAsync, i
 	}
 	cfg := &storage.Config{}
 	upToken := putPolicy.UploadToken(api.QiniuAPI)
-	rootTask := tasksch.NewSeqTask("BuildSkuFromEbaiStore", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("BuildSkuFromEbaiStore", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			var catID string
 			cat := skuCatList[step]
 			skuNameExtList := allSkuInfo2[cat]
--- a/business/jxstore/promotion/jd_promotion.go
+++ b/business/jxstore/promotion/jd_promotion.go
@@ -424,9 +424,11 @@ func CreateJdPromotion(ctx *jxcontext.Context, isIDJd bool, isAsync, isContinueW
 		}
 		dao.Commit(db)

-		rootTask := tasksch.NewSeqTask("CreateJdPromotion", userName, func(task *tasksch.SeqTask, step int, params2 ...interface{}) (result interface{}, err error) {
+		rootTask := tasksch.NewSeqTask("CreateJdPromotion", ctx,
+			func(task *tasksch.SeqTask, step int, params2 ...interface{}) (result interface{}, err error) {
 				if step == 0 {
-				task1 := tasksch.NewParallelTask("CreateJdPromotion update sku price", nil, userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
+					task1 := tasksch.NewParallelTask("CreateJdPromotion update sku price", nil, ctx,
+						func(t *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
 							storeID := batchItemList[0].(int)
 							modifyPricesList := jxutils.SplitSlice(modifyPricesList[storeID], jdapi.MaxStoreSkuBatchSize)
 							for _, modifyPrices := range modifyPricesList {
@@ -447,7 +449,8 @@ func CreateJdPromotion(ctx *jxcontext.Context, isIDJd bool, isAsync, isContinueW
 				} else if step == 1 {
 					err = promotionHandler.CreatePromotionRules(infoId, "", limitDevice, limitPin, limitCount, limitDaily)
 				} else if step == 2 {
-				task2 := tasksch.NewParallelTask("CreateJdPromotion CreatePromotionSku", tasksch.NewParallelConfig().SetBatchSize(MaxPromotionSkuCount).SetIsContinueWhenError(isContinueWhenError), userName, func(task *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
+					task2 := tasksch.NewParallelTask("CreateJdPromotion CreatePromotionSku", tasksch.NewParallelConfig().SetBatchSize(MaxPromotionSkuCount).SetIsContinueWhenError(isContinueWhenError), ctx,
+						func(task *tasksch.ParallelTask, batchItemList []interface{}, params2 ...interface{}) (retVal interface{}, err error) {
 							skus := make([]map[string]interface{}, len(batchItemList))
 							for k, v := range batchItemList {
 								skus[k] = v.(map[string]interface{})
@@ -480,8 +483,7 @@ func CreateJdPromotion(ctx *jxcontext.Context, isIDJd bool, isAsync, isContinueW
 				}
 				return nil, err
 			}, 4)
-		ctx.SetTaskOrAddChild(rootTask, nil)
-		tasksch.ManageTask(rootTask).Run()
+		tasksch.HandleTask(rootTask, nil, true).Run()
 		if !isAsync {
 			_, err = rootTask.GetResult(0)
 		}
@@ -745,7 +747,8 @@ func RefreshJdStoreSkuStock(promotionID int, skuIDs []int) (err error) {
 	}
 	globals.SugarLogger.Debugf("RefreshJdStoreSkuStock promotionID:%d, len(promotionItemList)=%d", promotionID, len(promotionItemList))
 	if len(promotionItemList) > 0 {
-		task := tasksch.NewParallelTask("RefreshJdStoreSkuStock", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(true), "schedule", func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+		task := tasksch.NewParallelTask("RefreshJdStoreSkuStock", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(true), jxcontext.AdminCtx,
+			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 				stockList := make([]*jdapi.SkuStock, 0)
 				stationNo := batchItemList[0].(*tPromotionItemInfo).JdStoreID
 				for _, v := range batchItemList {
--- a/business/jxstore/promotion/promotion.go
+++ b/business/jxstore/promotion/promotion.go
@@ -65,7 +65,8 @@ func SendAdvertingByGoodsOrder(ctx *jxcontext.Context, advertising string, days
 	mobileNumbers = append(mobileNumbers, "18180948107")

 	smsClient := aliyunsmsclient.New("http://dysmsapi.aliyuncs.com/")
-	task := tasksch.NewParallelTask("SendAdvertingByGoodsOrder", tasksch.NewParallelConfig().SetBatchSize(MaxBatchSize), userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	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)
@@ -79,8 +80,7 @@ func SendAdvertingByGoodsOrder(ctx *jxcontext.Context, advertising string, days
 			}
 			return nil, err
 		}, mobileNumbers)
-	ctx.SetTaskOrAddChild(task, nil)
-	tasksch.ManageTask(task).Run()
+	tasksch.HandleTask(task, nil, true).Run()

 	if !isAsync {
 		_, err = task.GetResult(0)
--- a/business/jxstore/tempop/tempop.go
+++ b/business/jxstore/tempop/tempop.go
@@ -138,7 +138,8 @@ func Convert2JDSPU(ctx *jxcontext.Context, count int, isAsync, isContinueWhenErr
 	if err = dao.GetRows(db, &skuNameList, sql, utils.DefaultTimeValue); err != nil {
 		return "", err
 	}
-	rootTask := tasksch.NewParallelTask("Convert2JDSPU", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("Convert2JDSPU", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			skuName := batchItemList[0].(*model.SkuName)
 			_, err = cms.CurVendorSync.SyncSku(ctx, db, skuName.ID, -1, false, isContinueWhenError, ctx.GetUserName())
 			return nil, err
@@ -283,7 +284,8 @@ func Change2JDSPU4Store(ctx *jxcontext.Context, storeIDs []int, step int, isAsyn

 func TransferLegacyJdOrder(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
 	sqlBatchCount := 1000
-	rootTask := tasksch.NewSeqTask("TransferLegacyJdOrder", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("TransferLegacyJdOrder", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			sql := `
 		SELECT t1.*
 		FROM jdorder t1
@@ -298,7 +300,8 @@ func TransferLegacyJdOrder(ctx *jxcontext.Context, isAsync, isContinueWhenError
 				return nil, err
 			}
 			if len(jdOrderList) > 0 {
-			task := tasksch.NewParallelTask("TransferLegacyJdOrder2", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetBatchSize(40), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				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)
@@ -484,7 +487,8 @@ func PullJdOrder(ctx *jxcontext.Context, fromTime, toTime time.Time, isAsync, is
 		gapList[k] = k

 	}
-	rootTask := tasksch.NewParallelTask("PullJdOrder", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(20), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("PullJdOrder", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(20), ctx,
+		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			gapIndex := batchItemList[0].(int)
 			hourIndex := gapIndex * hourGap
 			subFromTime := fromTime.Add(time.Duration(hourIndex) * time.Hour)
@@ -562,7 +566,8 @@ func DeleteWrongSpu(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (
 	if err = dao.GetRows(db, &skuNameList, sql, utils.DefaultTimeValue); err != nil {
 		return "", err
 	}
-	rootTask := tasksch.NewSeqTask("DeleteWrongSpu", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("DeleteWrongSpu", ctx,
+		func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			mapData := map[string]interface{}{
 				"name": skuNameList[step].Name,
 			}
@@ -590,7 +595,8 @@ type GoodsOrderOriginalEx struct {

 func CreateOrderFromOriginal(ctx *jxcontext.Context, isAsync, isContinueWhenError bool) (hint string, err error) {
 	sqlBatchCount := 5000
-	rootTask := tasksch.NewSeqTask("CreateOrderFromOriginal", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	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
@@ -606,7 +612,8 @@ func CreateOrderFromOriginal(ctx *jxcontext.Context, isAsync, isContinueWhenErro
 				return nil, err
 			}
 			if len(orderList) > 0 {
-			task := tasksch.NewParallelTask("CreateOrderFromOriginal", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError).SetParallelCount(1), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				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 {
@@ -688,7 +695,8 @@ func TransformJdSpu2Sku(ctx *jxcontext.Context, skuNameIDs []int, count int, isA
 		return "", fmt.Errorf("待转换的skuName为空")
 	}
 	batchSize := 40
-	rootTask := tasksch.NewSeqTask("TransformJdSpu2Sku", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("TransformJdSpu2Sku", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			var (
 				locker sync.Mutex
 				skuIDs []int
@@ -698,7 +706,8 @@ func TransformJdSpu2Sku(ctx *jxcontext.Context, skuNameIDs []int, count int, isA
 				lastIndex = len(skuNameList)
 			}
 			batchSkNameList := skuNameList[step*batchSize : lastIndex]
-		subTask := tasksch.NewParallelTask(fmt.Sprintf("TransformJdSpu2Sku:%d", step), tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(subTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			subTask := tasksch.NewParallelTask(fmt.Sprintf("TransformJdSpu2Sku:%d", step), tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+				func(subTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 					skuName := batchItemList[0].(*model.SkuName)
 					if !jxutils.IsFakeID(skuName.JdID) {
 						sql = `
@@ -795,7 +804,8 @@ func ReProcessJdBadComment(ctx *jxcontext.Context, isForce, isAsync, isContinueW
 	var commentList []*legacymodel.JxBadComments
 	if err = dao.GetRows(db, &commentList, sql); err == nil {
 		if len(commentList) > 0 {
-			rootTask := tasksch.NewParallelTask("ReProcessJdBadComment", nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			rootTask := tasksch.NewParallelTask("ReProcessJdBadComment", nil, ctx,
+				func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 					badComment := batchItemList[0].(*legacymodel.JxBadComments)
 					comment1, _ := unmarshalCommentText(badComment.Msg)
 					comment2, _ := unmarshalCommentText(badComment.UpdatedMsg)
@@ -856,7 +866,8 @@ func RefreshEbaiBadComment(ctx *jxcontext.Context, fromTime, toTime time.Time, i
 	}
 	days := int(toTime.Sub(fromTime)/(24*time.Hour) + 1)
 	globals.SugarLogger.Debugf("RefreshEbaiBadComment fromTime:%s, toTime:%s, days:%d", utils.Time2Str(fromTime), utils.Time2Str(toTime), days)
-	rootTask := tasksch.NewSeqTask("RefreshEbaiBadComment", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("RefreshEbaiBadComment", ctx,
+		func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			batchFromTime := fromTime.Add(time.Duration(step) * 24 * time.Hour)
 			batchToTime := batchFromTime.Add(24*time.Hour - time.Second)
 			if batchToTime.Sub(toTime) > 0 {
--- a/business/jxutils/jxcontext/jxcontext.go
+++ b/business/jxutils/jxcontext/jxcontext.go
@@ -3,12 +3,10 @@ package jxcontext
 import (
 	"errors"
 	"net/http"
-	"sync"

 	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/auth2"
 	"git.rosy.net.cn/jx-callback/business/jxcallback/auth"
-	"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
 	"git.rosy.net.cn/jx-callback/business/model"
 	"git.rosy.net.cn/jx-callback/globals"
 	"github.com/astaxie/beego"
@@ -21,14 +19,12 @@ type IAuther interface {
 }

 type Context struct {
-	rootTask   tasksch.ITask
 	token      string
 	accessUUID string
 	userInfo   IAuther //*auth.LoginInfo
 	w          http.ResponseWriter
 	r          *http.Request
 	mapData    map[interface{}]interface{}
-	locker     sync.RWMutex
 }

 const (
@@ -43,9 +39,8 @@ func init() {
 	AdminCtx = NewWithUserName(nil, model.AdminName, nil, nil)
 }

-func NewWithUserName(rootTask tasksch.ITask, userName string, w http.ResponseWriter, r *http.Request) (ctx *Context) {
+func NewWithUserName(notUsed interface{}, userName string, w http.ResponseWriter, r *http.Request) (ctx *Context) {
 	ctx = &Context{
-		rootTask:   rootTask,
 		token:      userName,
 		w:          w,
 		r:          r,
@@ -55,9 +50,8 @@ func NewWithUserName(rootTask tasksch.ITask, userName string, w http.ResponseWri
 	return ctx
 }

-func New(rootTask tasksch.ITask, token string, w http.ResponseWriter, r *http.Request) (ctx *Context, errCode string, err error) {
+func New(notUsed interface{}, token string, w http.ResponseWriter, r *http.Request) (ctx *Context, errCode string, err error) {
 	ctx = &Context{
-		rootTask:   rootTask,
 		token:      token,
 		w:          w,
 		r:          r,
@@ -141,34 +135,6 @@ func (ctx *Context) GetV2AuthInfo() (authInfo *auth2.AuthInfo, err error) {
 	return nil, auth2.ErrNeedV2Token
 }

-func (ctx *Context) GetRootTask() tasksch.ITask {
-	ctx.locker.RLock()
-	defer ctx.locker.RUnlock()
-
-	return ctx.rootTask
-}
-
-func (ctx *Context) SetTaskOrAddChild(task tasksch.ITask, parentTask tasksch.ITask) bool {
-	if parentTask != nil {
-		parentTask.AddChild(task)
-	} else {
-		parentTask = task
-	}
-	ctx.locker.RLock()
-	if ctx.rootTask == nil {
-		ctx.locker.RUnlock()
-
-		ctx.locker.Lock()
-		if ctx.rootTask == nil {
-			ctx.rootTask = parentTask
-		}
-		ctx.locker.Unlock()
-		return true
-	}
-	ctx.locker.RUnlock()
-	return false
-}
-
 func (ctx *Context) GetResponseWriter() http.ResponseWriter {
 	return ctx.w
 }
@@ -176,17 +142,3 @@ func (ctx *Context) GetResponseWriter() http.ResponseWriter {
 func (ctx *Context) GetRequest() *http.Request {
 	return ctx.r
 }
-
-func (ctx *Context) SetValue(key, value interface{}) {
-	ctx.locker.Lock()
-	defer ctx.locker.Unlock()
-
-	ctx.mapData[key] = value
-}
-
-func (ctx *Context) GetValue(key interface{}) interface{} {
-	ctx.locker.RLock()
-	defer ctx.locker.RUnlock()
-
-	return ctx.mapData[key]
-}
--- a/business/jxutils/msg/msg.go
+++ b/business/jxutils/msg/msg.go
@@ -0,0 +1,24 @@
+package msg
+
+import (
+	"git.rosy.net.cn/jx-callback/business/auth2"
+	"git.rosy.net.cn/jx-callback/business/auth2/authprovider/dingding"
+	"git.rosy.net.cn/jx-callback/globals"
+	"git.rosy.net.cn/jx-callback/globals/api"
+)
+
+func SendUserMessage(userID, title, content string) (err error) {
+	authList, err := auth2.GetUserBindAuthInfo(userID)
+	if err == nil {
+		for _, auth := range authList {
+			if auth.Type == dingding.AuthTypeStaff {
+				err = api.DingDingAPI.CorpAsyncSendSimple(auth.AuthID, content)
+				break
+			}
+		}
+	}
+	if err != nil {
+		globals.SugarLogger.Infof("SendUserMessage userID:%s, title:%s, content:%s failed with error:%v", userID, title, content, err)
+	}
+	return err
+}
--- a/business/jxutils/tasksch/parallel_task.go
+++ b/business/jxutils/tasksch/parallel_task.go
@@ -6,6 +6,7 @@ import (

 	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/jxutils"
+	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
 	"git.rosy.net.cn/jx-callback/globals"
 )

@@ -18,6 +19,8 @@ type WorkFunc func(task *ParallelTask, batchItemList []interface{}, params ...in
 type ResultHandlerFunc func(taskName string, result []interface{}, err error)

 type ParallelConfig struct {
+	// ParentTask          ITask
+	// IsAsync             bool
 	ParallelCount       int
 	BatchSize           int
 	IsContinueWhenError bool
@@ -41,9 +44,11 @@ var (

 func NewParallelConfig() *ParallelConfig {
 	return &ParallelConfig{
+		// ParentTask:          parentTask,
+		// IsAsync:             false,
+		IsContinueWhenError: false,
 		ParallelCount:       DefParallelCount,
 		BatchSize:           1,
-		IsContinueWhenError: false,
 		ResultHandler:       nil,
 	}
 }
@@ -63,12 +68,17 @@ func (c *ParallelConfig) SetIsContinueWhenError(isContinueWhenError bool) *Paral
 	return c
 }

+// func (c *ParallelConfig) SetIsAsync(isAsync bool) *ParallelConfig {
+// 	c.IsAsync = isAsync
+// 	return c
+// }
+
 func (c *ParallelConfig) SetResultHandler(resultHandler ResultHandlerFunc) *ParallelConfig {
 	c.ResultHandler = resultHandler
 	return c
 }

-func NewParallelTask(taskName string, config *ParallelConfig, userName string, worker WorkFunc, itemList interface{}, params ...interface{}) *ParallelTask {
+func NewParallelTask(taskName string, config *ParallelConfig, ctx *jxcontext.Context, worker WorkFunc, itemList interface{}, params ...interface{}) *ParallelTask {
 	if config == nil {
 		config = NewParallelConfig()
 	}
@@ -91,7 +101,7 @@ func NewParallelTask(taskName string, config *ParallelConfig, userName string, w
 		worker:        worker,
 		jobList:       jobList,
 	}
-	task.Init(config.ParallelCount, config.BatchSize, config.IsContinueWhenError, params, taskName, userName, len(realItemList), jobListLen)
+	task.Init(config.ParallelCount, config.BatchSize, config.IsContinueWhenError, params, taskName, ctx, len(realItemList), jobListLen)
 	return task
 }

--- a/business/jxutils/tasksch/parallel_task_test.go
+++ b/business/jxutils/tasksch/parallel_task_test.go
@@ -7,6 +7,7 @@ import (
 	"time"

 	"git.rosy.net.cn/baseapi/utils"
+	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
 )

 func TestRunParallelTask(t *testing.T) {
@@ -14,7 +15,8 @@ func TestRunParallelTask(t *testing.T) {
 	for k := range itemList {
 		itemList[k] = k
 	}
-	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7), "autotest", func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7), jxcontext.AdminCtx,
+		func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			sleepSecond := rand.Intn(5)
 			t.Logf("sleep %d seconds", sleepSecond)
 			time.Sleep(time.Duration(sleepSecond) * time.Second)
@@ -45,7 +47,8 @@ func TestCancelParallelTask(t *testing.T) {
 	for k := range itemList {
 		itemList[k] = k
 	}
-	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7), "autotest", func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7), jxcontext.AdminCtx,
+		func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			sleepSecond := rand.Intn(5)
 			fmt.Printf("sleep %d seconds\n", sleepSecond)
 			time.Sleep(time.Duration(sleepSecond) * time.Second)
@@ -71,7 +74,8 @@ func TestRunParallelTaskPartialSuccess(t *testing.T) {
 	for k := range itemList {
 		itemList[k] = k
 	}
-	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7).SetIsContinueWhenError(true), "autotest", func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := NewParallelTask("test", NewParallelConfig().SetParallelCount(100).SetBatchSize(7).SetIsContinueWhenError(true), jxcontext.AdminCtx,
+		func(task *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			sleepSecond := rand.Intn(5)
 			t.Logf("sleep %d seconds", sleepSecond)
 			time.Sleep(time.Duration(sleepSecond) * time.Second)
--- a/business/jxutils/tasksch/sequence_task.go
+++ b/business/jxutils/tasksch/sequence_task.go
@@ -4,6 +4,7 @@ import (
 	"time"

 	"git.rosy.net.cn/baseapi/utils"
+	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
 	"git.rosy.net.cn/jx-callback/globals"
 )

@@ -19,11 +20,11 @@ type SeqTask struct {
 	worker SeqWorkFunc
 }

-func NewSeqTask(taskName string, userName string, worker SeqWorkFunc, stepCount int, params ...interface{}) *SeqTask {
+func NewSeqTask(taskName string, ctx *jxcontext.Context, worker SeqWorkFunc, stepCount int, params ...interface{}) *SeqTask {
 	task := &SeqTask{
 		worker: worker,
 	}
-	task.Init(1, 1, false, params, taskName, userName, stepCount, stepCount)
+	task.Init(1, 1, false, params, taskName, ctx, stepCount, stepCount)
 	return task
 }

--- a/business/jxutils/tasksch/sequence_task_test.go
+++ b/business/jxutils/tasksch/sequence_task_test.go
@@ -7,15 +7,18 @@ import (
 	"time"

 	"git.rosy.net.cn/baseapi/utils"
+	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
 )

 func TestRunSeqTask(t *testing.T) {
 	var seqTask ITask
-	seqTask = NewSeqTask("TestSeqTask", "autotest", func(task *SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	seqTask = NewSeqTask("TestSeqTask", jxcontext.AdminCtx,
+		func(task *SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				fmt.Println("ONE")
-			task2 := NewParallelTask("hello", nil, "xjh", func(parallelTask *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task2 := NewParallelTask("hello", nil, jxcontext.AdminCtx,
+					func(parallelTask *ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						i := batchItemList[0].(int)
 						time.Sleep(2 * time.Second)
 						fmt.Println(i * 2)
--- a/business/jxutils/tasksch/task.go
+++ b/business/jxutils/tasksch/task.go
@@ -8,6 +8,8 @@ import (
 	"time"

 	"git.rosy.net.cn/baseapi/utils"
+	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
+	"git.rosy.net.cn/jx-callback/business/jxutils/msg"
 	"git.rosy.net.cn/jx-callback/globals"
 )

@@ -97,14 +99,17 @@ type BaseTask struct {
 	Children TaskList      `json:"children"`
 	Err      error         `json:"err"`

-	detailErrMsgList []string `json:"-"`
-	finishChan       chan int
-	C                <-chan int `json:"-"`
+	detailErrMsgList []string
+	finishChan       chan struct{}
+	C                <-chan struct{} `json:"-"`
 	params           []interface{}
 	quitChan         chan int

 	locker sync.RWMutex
 	parent ITask
+
+	ctx               *jxcontext.Context
+	isGetResultCalled bool
 }

 func (s TaskList) Len() int {
@@ -121,7 +126,7 @@ func (s TaskList) Swap(i, j int) {
 	s[j] = tmp
 }

-func (t *BaseTask) Init(parallelCount, batchSize int, isContinueWhenError bool, params []interface{}, name, userName string, totalItemCount, totalJobCount int) {
+func (t *BaseTask) Init(parallelCount, batchSize int, isContinueWhenError bool, params []interface{}, name string, ctx *jxcontext.Context, totalItemCount, totalJobCount int) {
 	t.ID = utils.GetUUID()
 	t.ParallelCount = parallelCount
 	t.BatchSize = batchSize
@@ -129,13 +134,14 @@ func (t *BaseTask) Init(parallelCount, batchSize int, isContinueWhenError bool,
 	t.params = params
 	t.Name = name
 	t.CreatedAt = time.Now()
-	t.CreatedBy = userName
+	t.ctx = ctx
+	t.CreatedBy = ctx.GetUserName()
 	t.UpdatedAt = t.CreatedAt
 	t.TerminatedAt = utils.DefaultTimeValue
 	t.TotalItemCount = totalItemCount
 	t.TotalJobCount = totalJobCount
 	t.quitChan = make(chan int)
-	t.finishChan = make(chan int)
+	t.finishChan = make(chan struct{})
 	t.Status = TaskStatusWorking

 	t.C = t.finishChan
@@ -155,6 +161,7 @@ func (t *BaseTask) GetResult(duration time.Duration) (retVal []interface{}, err
 	timer := time.NewTimer(duration)
 	select {
 	case <-t.finishChan:
+		t.isGetResultCalled = true
 		timer.Stop()
 		return t.Result, t.Err
 	case <-timer.C:
@@ -249,6 +256,14 @@ func AddChild(parentTask ITask, task ITask) ITask {
 	return task
 }

+func HandleTask(task, parentTask ITask, isMangeIt bool) ITask {
+	AddChild(task, parentTask)
+	if parentTask == nil && isMangeIt {
+		ManageTask(task)
+	}
+	return task
+}
+
 /////////

 func (t *BaseTask) MarshalJSON() ([]byte, error) {
@@ -280,6 +295,18 @@ func (t *BaseTask) run(taskHandler func()) {
 			}

 			close(t.finishChan)
+			time.Sleep(10 * time.Millisecond) // 等待GetResult中的isGetResultCalled赋值
+			if !t.isGetResultCalled && t.parent == nil && len(GetTasks(t.ID, TaskStatusBegin, TaskStatusEnd, 24, "")) == 0 {
+				if authInfo, err := t.ctx.GetV2AuthInfo(); err == nil { // 这里应该是不管登录类型，直接以可能的方式发消息
+					var content string
+					if t.Status == TaskStatusFinished {
+						content = fmt.Sprintf("你的异步任务[%s]执行成功完成", t.Name)
+					} else {
+						content = fmt.Sprintf("你的异步任务[%s]执行失败，%s", t.Name, t.Err.Error())
+					}
+					msg.SendUserMessage(authInfo.UserID, "异步任务完成", content)
+				}
+			}
 		})
 	}
 }
--- a/business/model/dao/dao_auth2.go
+++ b/business/model/dao/dao_auth2.go
@@ -52,3 +52,18 @@ func GetAuthBindsByAuthID2(db *DaoDB, authID2 string, typeList []string) (authBi
 	err = GetRows(db, &authBinds, sql, sqlParams...)
 	return authBinds, err
 }
+
+func GetUserBindAuthInfo(db *DaoDB, userID string) (authList []*model.AuthBind, err error) {
+	sql := `
+	SELECT *
+	FROM auth_bind t1
+	WHERE t1.deleted_at = ? AND t1.status = ? AND t1.user_id = ?
+	`
+	sqlParams := []interface{}{
+		utils.DefaultTimeValue,
+		model.UserStatusNormal,
+		userID,
+	}
+	err = GetRows(db, &authList, sql, sqlParams...)
+	return authList, err
+}
--- a/business/model/dao/dao_user2.go
+++ b/business/model/dao/dao_user2.go
@@ -23,18 +23,3 @@ func GetUserByID(db *DaoDB, fieldName, fieldValue string) (user *model.User, err
 	err = GetRow(db, &user, sql, sqlParams...)
 	return user, err
 }
-
-func GetUserBindAuthInfo(db *DaoDB, userID string) (authList []*model.AuthBind, err error) {
-	sql := `
-	SELECT *
-	FROM auth_bind t1
-	WHERE t1.deleted_at = ? AND t1.status = ? AND t1.user_id = ?
-	`
-	sqlParams := []interface{}{
-		utils.DefaultTimeValue,
-		model.UserStatusNormal,
-		userID,
-	}
-	err = GetRows(db, &authList, sql, sqlParams...)
-	return authList, err
-}
--- a/business/partner/purchase/ebai/common.go
+++ b/business/partner/purchase/ebai/common.go
@@ -3,6 +3,7 @@ package ebai
 import (
 	"git.rosy.net.cn/baseapi/platformapi/ebaiapi"
 	"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/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
@@ -11,7 +12,8 @@ import (
 func (p *PurchaseHandler) UpdatePlaces() (err error) {
 	provinces, err := api.EbaiAPI.CommonShopCities(0)
 	if err == nil {
-		task := tasksch.NewParallelTask("UpdatePlaces", nil, "test", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+		task := tasksch.NewParallelTask("UpdatePlaces", nil, jxcontext.AdminCtx,
+			func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 				province := batchItemList[0].(*ebaiapi.CityInfo)
 				retSlice := make([]*ebaiapi.CityInfo, 0)
 				if province.IsOpen != 0 {
--- a/business/partner/purchase/ebai/order.go
+++ b/business/partner/purchase/ebai/order.go
@@ -338,7 +338,8 @@ func (c *PurchaseHandler) RefreshRealMobile(ctx *jxcontext.Context, fromTime, to
 	var orderList []*model.GoodsOrder
 	db := dao.GetDB()
 	if err = dao.GetRows(db, &orderList, sql, sqlParams...); err == nil && len(orderList) > 0 {
-		task := tasksch.NewParallelTask("ebai RefreshRealMobile", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+		task := tasksch.NewParallelTask("ebai RefreshRealMobile", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 				order := batchItemList[0].(*model.GoodsOrder)
 				mobile, err2 := api.EbaiAPI.GetRealMobile4Order(order.VendorOrderID)
 				if err = err2; err == nil && !jxutils.IsMobileFake(mobile) && strings.Index(order.ConsigneeMobile, mobile) == -1 {
@@ -347,8 +348,7 @@ func (c *PurchaseHandler) RefreshRealMobile(ctx *jxcontext.Context, fromTime, to
 				}
 				return nil, err
 			}, orderList)
-		ctx.SetTaskOrAddChild(task, nil)
-		tasksch.ManageTask(task).Run()
+		tasksch.HandleTask(task, nil, true).Run()
 		hint = task.ID
 		if !isAsync {
 			_, err = task.GetResult(0)
--- a/business/partner/purchase/ebai/store.go
+++ b/business/partner/purchase/ebai/store.go
@@ -216,7 +216,8 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 	const stepCount = 3
 	var stores []*tEbaiStoreInfo
 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("ebai RefreshAllStoresID", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("ebai RefreshAllStoresID", ctx,
+		func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = dao.GetRows(db, &stores, `
@@ -230,7 +231,8 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 				if step != stepCount-1 {
 					taskName = "ebai RefreshAllStoresID update to uuid"
 				}
-			task1 := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetBatchSize(batchSize), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task1 := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetBatchSize(batchSize), ctx,
+					func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						baiduShopIDs := make([]string, len(batchItemList))
 						shopIDs := make([]string, len(batchItemList))
 						for k, v := range batchItemList {
@@ -252,8 +254,7 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 			return nil, err
 		}, stepCount)

-	ctx.SetTaskOrAddChild(rootTask, parentTask)
-	rootTask.Run()
+	tasksch.HandleTask(rootTask, parentTask, false).Run()
 	if !isAsync {
 		_, err = rootTask.GetResult(0)
 	}
--- a/business/partner/purchase/ebai/store_sku.go
+++ b/business/partner/purchase/ebai/store_sku.go
@@ -144,7 +144,8 @@ func (p *PurchaseHandler) FullSyncStoreSkus(ctx *jxcontext.Context, parentTask t
 	globals.SugarLogger.Debugf("FullSyncStoreSkus storeID:%d, isContinueWhenError:%t, userName:%s", storeID, isContinueWhenError, userName)

 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("FullSyncStoreSkus", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("FullSyncStoreSkus", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = p.DeleteRemoteSkus(ctx, rootTask, storeID, nil)
@@ -180,7 +181,8 @@ func (p *PurchaseHandler) DeleteRemoteStoreSkus(ctx *jxcontext.Context, parentTa

 	db := dao.GetDB()
 	var errDeleteSku error
-	rootTask := tasksch.NewSeqTask("DeleteRemoteStoreSkus", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("DeleteRemoteStoreSkus", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = p.DeleteRemoteSkus(ctx, rootTask, storeID, nil)
@@ -215,7 +217,8 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 	var storeSkuInfoList []*tStoreSkuFullInfo
 	var num int64
 	strStoreID := utils.Int2Str(storeID)
-	rootTask := tasksch.NewSeqTask("SyncStoreSkus饿百1", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("SyncStoreSkus饿百1", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			if step == 0 {
 				db := dao.GetDB()
 				for i := 0; i < 3; i++ {
@@ -234,7 +237,8 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 					return nil, errors.New("不能创建商品所需的类别")
 				}
 			} else if step == 1 {
-			task := tasksch.NewParallelTask("SyncStoreSkus饿百2", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task := tasksch.NewParallelTask("SyncStoreSkus饿百2", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+					func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						storeSku := batchItemList[0].(*tStoreSkuFullInfo)
 						updateFields := []string{model.FieldEbaiSyncStatus}
 						if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
@@ -274,7 +278,7 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 	return rootTask.ID, err
 }

-func (p *PurchaseHandler) GetAllRemoteSkus(storeID int) (skus []map[string]interface{}, err error) {
+func (p *PurchaseHandler) GetAllRemoteSkus(ctx *jxcontext.Context, storeID int, parentTask tasksch.ITask) (skus []map[string]interface{}, err error) {
 	page1, err := api.EbaiAPI.SkuList(utils.Int2Str(storeID), utils.Params2Map("pagesize", MaxPageSize))
 	if err == nil {
 		skus = append(skus, page1.List...)
@@ -283,7 +287,8 @@ func (p *PurchaseHandler) GetAllRemoteSkus(storeID int) (skus []map[string]inter
 			for i := 2; i <= page1.Pages; i++ {
 				pages[i-2] = i
 			}
-			task := tasksch.NewParallelTask("GetAllRemoteSkus", nil, "", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+			task := tasksch.NewParallelTask("GetAllRemoteSkus", nil, ctx,
+				func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 					callParams := map[string]interface{}{
 						"pagesize": MaxPageSize,
 						"page":     batchItemList[0],
@@ -295,7 +300,7 @@ func (p *PurchaseHandler) GetAllRemoteSkus(storeID int) (skus []map[string]inter
 					globals.SugarLogger.Debug(utils.Format4Output(callParams, false))
 					return nil, err2
 				}, pages)
-			task.Run()
+			tasksch.HandleTask(task, parentTask, false).Run()
 			result, err2 := task.GetResult(0)
 			if err = err2; err == nil {
 				for _, v := range result {
@@ -311,7 +316,7 @@ func (p *PurchaseHandler) DeleteRemoteSkus(ctx *jxcontext.Context, parentTask ta
 	globals.SugarLogger.Debugf("DeleteRemoteSkus饿百 storeID:%d", storeID)

 	if vendorSkuIDs == nil {
-		result, err2 := p.GetAllRemoteSkus(storeID)
+		result, err2 := p.GetAllRemoteSkus(ctx, storeID, parentTask)
 		if err = err2; err == nil {
 			vendorSkuIDs = make([]string, len(result))
 			for k, v := range result {
@@ -319,7 +324,8 @@ func (p *PurchaseHandler) DeleteRemoteSkus(ctx *jxcontext.Context, parentTask ta
 			}
 		}
 	}
-	task := tasksch.NewParallelTask("DeleteRemoteSkus", tasksch.NewParallelConfig().SetBatchSize(100).SetIsContinueWhenError(true), "", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("DeleteRemoteSkus", tasksch.NewParallelConfig().SetBatchSize(100).SetIsContinueWhenError(true), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			strList := make([]string, len(batchItemList))
 			for k, v := range batchItemList {
 				strList[k] = v.(string)
@@ -347,7 +353,8 @@ func (p *PurchaseHandler) DeleteRemoteCategories(ctx *jxcontext.Context, parentT
 			}
 		}
 	}
-	task := tasksch.NewParallelTask("DeleteRemoteCategories", tasksch.NewParallelConfig().SetIsContinueWhenError(true), "", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("DeleteRemoteCategories", tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
 				err = api.EbaiAPI.ShopCategoryDelete(strStoreID, batchItemList[0].(int64))
 			}
@@ -465,7 +472,8 @@ func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask t
 	globals.SugarLogger.Debugf("SyncOneStoreCategories storeID:%d, userName:%s", storeID, userName)

 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("ebai SyncStoreCategory", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("ebai SyncStoreCategory", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			level := step + 1
 			sql := `
 	SELECT t2.*, t1.name, t1.parent_id, t1.level, t1.type, t1.seq, t2p.ebai_id parent_ebai_id
@@ -485,7 +493,8 @@ func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask t
 			}
 			if err = dao.GetRows(db, &catList, sql, sqlParams...); err == nil {
 				strStoreID := utils.Int2Str(storeID)
-			task := tasksch.NewParallelTask("SyncStoreCategory", nil, userName, func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task := tasksch.NewParallelTask("SyncStoreCategory", nil, ctx,
+					func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						updateFields := []string{model.FieldEbaiSyncStatus}
 						catInfo := batchItemList[0].(*tStoreCatInfo)
 						// globals.SugarLogger.Debug(utils.Format4Output(catInfo, false))
--- a/business/partner/purchase/ebai/store_sku_test.go
+++ b/business/partner/purchase/ebai/store_sku_test.go
@@ -36,7 +36,7 @@ func TestSyncOneStoreCategoriesFromLocal2Remote(t *testing.T) {
 }

 func TestGetAllRemoteSkus(t *testing.T) {
-	result, err := new(PurchaseHandler).GetAllRemoteSkus(testShopID)
+	result, err := new(PurchaseHandler).GetAllRemoteSkus(jxcontext.AdminCtx, testShopID, nil)
 	if err != nil {
 		t.Fatal(err.Error())
 	} else {
--- a/business/partner/purchase/jd/sku.go
+++ b/business/partner/purchase/jd/sku.go
@@ -302,7 +302,8 @@ func (p *PurchaseHandler) RefreshAllSkusID(ctx *jxcontext.Context, parentTask ta
 	var skuPairs []*jdapi.SkuIDPair
 	const stepCount = 2

-	rootTask := tasksch.NewSeqTask("jd RefreshAllSkusID", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("jd RefreshAllSkusID", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = dao.GetRows(db, &skuPairs, `
@@ -315,7 +316,8 @@ func (p *PurchaseHandler) RefreshAllSkusID(ctx *jxcontext.Context, parentTask ta
 				if step != stepCount-1 {
 					taskName = "RefreshAllSkusID update uuid"
 				}
-			task1 := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true).SetBatchSize(jdapi.MaxBatchSize4BatchUpdateOutSkuId), ctx.GetUserName(), func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task1 := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true).SetBatchSize(jdapi.MaxBatchSize4BatchUpdateOutSkuId), ctx,
+					func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						skuPairs := make([]*jdapi.SkuIDPair, len(batchItemList))
 						for k, v := range batchItemList {
 							pair := v.(*jdapi.SkuIDPair)
@@ -338,8 +340,7 @@ func (p *PurchaseHandler) RefreshAllSkusID(ctx *jxcontext.Context, parentTask ta
 			}
 			return nil, err
 		}, stepCount)
-	ctx.SetTaskOrAddChild(rootTask, parentTask)
-	rootTask.Run()
+	tasksch.HandleTask(rootTask, parentTask, false).Run()
 	if !isAsync {
 		_, err = rootTask.GetResult(0)
 	}
--- a/business/partner/purchase/jd/store.go
+++ b/business/partner/purchase/jd/store.go
@@ -209,7 +209,8 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 	const stepCount = 3
 	var stores []*tJdStoreInfo
 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("jd RefreshAllStoresID", ctx.GetUserName(), func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("jd RefreshAllStoresID", ctx,
+		func(task *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = dao.GetRows(db, &stores, `
@@ -223,7 +224,8 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 				if step != stepCount-1 {
 					taskName = "jd RefreshAllStoresID update to uuid"
 				}
-			task1 := tasksch.NewParallelTask(taskName, nil, ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task1 := tasksch.NewParallelTask(taskName, nil, ctx,
+					func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						store := batchItemList[0].(*tJdStoreInfo)
 						storeParams := map[string]interface{}{
 							"outSystemId": utils.Int2Str(int(store.ID)),
@@ -242,8 +244,7 @@ func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask
 			return nil, err
 		}, stepCount)

-	ctx.SetTaskOrAddChild(rootTask, parentTask)
-	rootTask.Run()
+	tasksch.HandleTask(rootTask, parentTask, false).Run()
 	if !isAsync {
 		_, err = rootTask.GetResult(0)
 	}
--- a/business/partner/purchase/jd/store_sku.go
+++ b/business/partner/purchase/jd/store_sku.go
@@ -54,7 +54,8 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 	if err = dao.GetRows(db, &storeSkus, sql, append(sqlParams, sqlWhereParams...)...); err != nil {
 		return "", err
 	}
-	task := tasksch.NewParallelTask("SyncStoresSkus京东", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("SyncStoresSkus京东", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			var skuPriceInfoList []*jdapi.SkuPriceInfo
 			var skuVendibilityList []*jdapi.StockVendibility
 			var skuStockList []*jdapi.SkuStock
@@ -152,8 +153,7 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 			}
 			return nil, err
 		}, storeSkus)
-	ctx.SetTaskOrAddChild(task, parentTask)
-	task.Run()
+	tasksch.HandleTask(task, parentTask, false).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
@@ -185,7 +185,8 @@ func (p *PurchaseHandler) syncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 		return "", err
 	}
 	stationNo := storeDetail.VendorStoreID
-	task := tasksch.NewParallelTask("SyncStoresSkus京东", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
+	task := tasksch.NewParallelTask("SyncStoresSkus京东", tasksch.NewParallelConfig().SetBatchSize(jdapi.MaxStoreSkuBatchSize).SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (interface{}, error) {
 			var skuPriceInfoList []*jdapi.SkuPriceInfo
 			var skuVendibilityList []*jdapi.StockVendibility
 			var skuStockList []*jdapi.SkuStock
@@ -260,8 +261,7 @@ func (p *PurchaseHandler) syncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 			}
 			return nil, err
 		}, skus)
-	ctx.SetTaskOrAddChild(task, parentTask)
-	task.Run()
+	tasksch.HandleTask(task, parentTask, false).Run()
 	if !isAsync {
 		_, err = task.GetResult(0)
 	}
--- a/business/partner/purchase/mtwm/store_sku.go
+++ b/business/partner/purchase/mtwm/store_sku.go
@@ -17,7 +17,6 @@ import (

 // hint，如果是异步，返回的是任务ID，如果是同步，返回是本次需要同步的目录数
 func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, isAsync bool) (hint string, err error) {
-	userName := ctx.GetUserName()
 	num := 0
 	db := dao.GetDB()
 	storeDetail, err := dao.GetStoreDetail(db, storeID, model.VendorIDMTWM)
@@ -25,12 +24,14 @@ func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask t
 		return hint, err
 	}
 	vendorStoreID := storeDetail.VendorStoreID
-	rootTask := tasksch.NewSeqTask("美团外卖SyncStoreCategory step1", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("美团外卖SyncStoreCategory step1", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			level := step + 1
 			catList, err := dao.GetStoreCategories(db, model.VendorIDMTWM, storeID, level)
 			if len(catList) > 0 {
 				num += len(catList)
-			task := tasksch.NewParallelTask(fmt.Sprintf("美团外卖SyncStoreCategory step2, level=%d", level), nil, userName, func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task := tasksch.NewParallelTask(fmt.Sprintf("美团外卖SyncStoreCategory step2, level=%d", level), nil, ctx,
+					func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						updateFields := []string{dao.GetSyncStatusStructField(model.VendorNames[model.VendorIDMTWM])}
 						catInfo := batchItemList[0].(*dao.StoreCatSyncInfo)
 						if globals.EnableStoreWrite && globals.EnableMtwmStoreWrite {
@@ -235,7 +236,8 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 	}
 	// globals.SugarLogger.Debug(utils.Format4Output(skus, false))
 	vendorStoreID := storeDetail.VendorStoreID
-	rootTask := tasksch.NewParallelTask("美团外卖SyncStoreSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(rootTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("美团外卖SyncStoreSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(rootTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			foodDataList := make([]map[string]interface{}, len(batchItemList))
 			// for k, v := range batchItemList {
 			v := batchItemList[0]
@@ -307,7 +309,8 @@ func (p *PurchaseHandler) FullSyncStoreSkus(ctx *jxcontext.Context, parentTask t
 	globals.SugarLogger.Debugf("mtwm FullSyncStoreSkus storeID:%d, isContinueWhenError:%t, userName:%s", storeID, isContinueWhenError, userName)

 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("美团外卖FullSyncStoreSkus", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("美团外卖FullSyncStoreSkus", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = p.DeleteRemoteSkus(ctx, rootTask, storeID, nil)
@@ -351,7 +354,8 @@ func (p *PurchaseHandler) DeleteRemoteSkus(ctx *jxcontext.Context, parentTask ta
 		return err
 	}
 	vendorStoreID := storeDetail.VendorStoreID
-	task := tasksch.NewParallelTask("mtwm DeleteRemoteSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(true), "", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	task := tasksch.NewParallelTask("mtwm DeleteRemoteSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx,
+		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			if globals.EnableStoreWrite && globals.EnableMtwmStoreWrite {
 				// globals.SugarLogger.Debugf("mtwm RetailDelete vendorStoreID:%s, sku:%s", vendorStoreID, batchItemList[0].(string))
 				err = api.MtwmAPI.RetailDelete(vendorStoreID, batchItemList[0].(string))
@@ -402,7 +406,8 @@ func (p *PurchaseHandler) DeleteRemoteCategories(ctx *jxcontext.Context, parentT
 			}
 		}
 	}
-	rootTask := tasksch.NewSeqTask("mtwm DeleteRemoteCategories", "", func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("mtwm DeleteRemoteCategories", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			var catIDs []string
 			if step == 0 {
 				catIDs = vendorCatIDs2
@@ -410,7 +415,8 @@ func (p *PurchaseHandler) DeleteRemoteCategories(ctx *jxcontext.Context, parentT
 				catIDs = vendorCatIDs
 			}
 			if len(catIDs) > 0 {
-			task := tasksch.NewParallelTask("mtwm DeleteRemoteCategories paralle", tasksch.NewParallelConfig().SetIsContinueWhenError(true), "", func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task := tasksch.NewParallelTask("mtwm DeleteRemoteCategories paralle", tasksch.NewParallelConfig().SetIsContinueWhenError(true), ctx,
+					func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						if globals.EnableStoreWrite && globals.EnableMtwmStoreWrite {
 							err = api.MtwmAPI.RetailCatDelete(vendorStoreID, batchItemList[0].(string))
 						}
@@ -432,7 +438,8 @@ func (p *PurchaseHandler) DeleteRemoteStoreSkus(ctx *jxcontext.Context, parentTa

 	db := dao.GetDB()
 	var errDeleteSku error
-	rootTask := tasksch.NewSeqTask("mtwm DeleteRemoteStoreSkus", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("mtwm DeleteRemoteStoreSkus", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				err = p.DeleteRemoteSkus(ctx, rootTask, storeID, nil)
--- a/business/partner/purchase/weimob/wsc/store_sku.go
+++ b/business/partner/purchase/weimob/wsc/store_sku.go
@@ -24,17 +24,18 @@ const (
 )

 func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, isAsync bool) (hint string, err error) {
-	userName := ctx.GetUserName()
 	strStoreID := utils.Int2Str(storeID)
 	num := 0
 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("微盟微商城SyncStoreCategory step1", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("微盟微商城SyncStoreCategory step1", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			level := step + 1
 			catList, err := dao.GetStoreCategories(db, model.VendorIDWSC, storeID, level)
 			// globals.SugarLogger.Debug(utils.Format4Output(catList, false))
 			if len(catList) > 0 {
 				num += len(catList)
-			task := tasksch.NewParallelTask(fmt.Sprintf("微盟微商城SyncStoreCategory step2, level=%d", level), nil, userName, func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+				task := tasksch.NewParallelTask(fmt.Sprintf("微盟微商城SyncStoreCategory step2, level=%d", level), nil, ctx,
+					func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 						updateFields := []string{dao.GetSyncStatusStructField(model.VendorNames[model.VendorIDWSC])}
 						catInfo := batchItemList[0].(*dao.StoreCatSyncInfo)
 						if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
@@ -170,7 +171,8 @@ func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasks
 		return "", err
 	}
 	globals.SugarLogger.Debug(utils.Format4Output(skus, false))
-	rootTask := tasksch.NewParallelTask("微盟微商城SyncStoreSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(rootTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
+	rootTask := tasksch.NewParallelTask("微盟微商城SyncStoreSkus", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
+		func(rootTask *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
 			v := batchItemList[0]
 			skuItem := v.(*dao.StoreSkuSyncInfo)
 			updateFields := []string{model.FieldWscSyncStatus}
@@ -266,7 +268,8 @@ func (p *PurchaseHandler) FullSyncStoreSkus(ctx *jxcontext.Context, parentTask t
 	globals.SugarLogger.Debugf("wsc FullSyncStoreSkus storeID:%d, isContinueWhenError:%t, userName:%s", storeID, isContinueWhenError, userName)

 	db := dao.GetDB()
-	rootTask := tasksch.NewSeqTask("微盟微商城FullSyncStoreSkus", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
+	rootTask := tasksch.NewSeqTask("微盟微商城FullSyncStoreSkus", ctx,
+		func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
 			switch step {
 			case 0:
 				_, err = dao.SetStoreCategorySyncStatus(db, model.VendorIDWSC, storeID, nil, model.SyncFlagNewMask)
--- a/conf/app.conf
+++ b/conf/app.conf
@@ -54,6 +54,7 @@ weimobCallbackURL = "http://callback.test.jxc4.com/weimob"
 weixinPageAppID = "wx018dbe7daa3d5627"
 weixinPageSecret = "c7a84ed3ef3ae04ac78e02fb593ffbe5"

+dingdingAgentID = 241047291
 dingdingAppKey = "dingpx4hcf55zb4ubewg"
 dingdingSecret = "1zooB4bmEXPesdwb1ElWASVQ1vinOSZM-1XCUFrrSjHsNAId1UuVCT5tmHSmg5_V"

@@ -123,6 +124,7 @@ enableWscStoreWrite = true

 weimobCallbackURL = "http://callback.jxc4.com/weimob"

+dingdingAgentID = 239461075
 dingdingAppKey = "ding7iu9cptairtcls0c"
 dingdingSecret = "LWrZAFeqUfuVv7n_tc8vPpCAx6PT4CwManx2XCVhJOqGsx2L5XCDuX1sAN_JtvsI"

--- a/globals/api/api.go
+++ b/globals/api/api.go
@@ -90,7 +90,7 @@ func Init() {
 	weimobAPIConfig.ClientTimeout = 120 * time.Second
 	WeimobAPI = weimobapi.New(nil, beego.AppConfig.DefaultString("weimobAppID", ""), beego.AppConfig.DefaultString("weimobAppSecret", ""), &weimobAPIConfig)

-	DingDingAPI = dingdingapi.New(beego.AppConfig.DefaultString("dingdingCorpID", ""), beego.AppConfig.DefaultString("dingdingAppKey", ""), beego.AppConfig.DefaultString("dingdingSecret", ""))
+	DingDingAPI = dingdingapi.NewWithAgentID(beego.AppConfig.DefaultInt64("dingdingAgentID", 0), beego.AppConfig.DefaultString("dingdingCorpID", ""), beego.AppConfig.DefaultString("dingdingAppKey", ""), beego.AppConfig.DefaultString("dingdingSecret", ""))
 	DingDingQRCodeAPI = dingdingapi.New(beego.AppConfig.DefaultString("dingdingCorpID", ""), beego.AppConfig.DefaultString("dingdingQRCodeAppKey", ""), beego.AppConfig.DefaultString("dingdingQRCodeSecret", ""))
 }