294 lines
10 KiB
Go
294 lines
10 KiB
Go
package cms
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"git.rosy.net.cn/baseapi/utils"
|
|
"git.rosy.net.cn/baseapi/utils/errlist"
|
|
"git.rosy.net.cn/jx-callback/business/jxutils"
|
|
"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"
|
|
"git.rosy.net.cn/jx-callback/business/model/dao"
|
|
"git.rosy.net.cn/jx-callback/business/partner"
|
|
"git.rosy.net.cn/jx-callback/globals"
|
|
)
|
|
|
|
type tMultiStoreVendorInfo struct {
|
|
VendorID int
|
|
OrgCode string
|
|
}
|
|
|
|
func CombineVendorIDAndOrgCode(vendorID int, orgCode string) string {
|
|
return fmt.Sprintf("%d-%s", vendorID, orgCode)
|
|
}
|
|
|
|
func getMultiStoreVendorInfoList() (list []*tMultiStoreVendorInfo) {
|
|
vendorIDs := partner.GetMultiStoreVendorIDs()
|
|
for _, vendorID := range vendorIDs {
|
|
orgCodeList := partner.CurAPIManager.GetAppOrgCodeList(vendorID)
|
|
for _, v := range orgCodeList {
|
|
list = append(list, &tMultiStoreVendorInfo{
|
|
VendorID: vendorID,
|
|
OrgCode: v,
|
|
})
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
func SyncCategories(ctx *jxcontext.Context, parentTask tasksch.ITask, vendorIDs []int, appOrgCodes []string, catIDs []int, isAsync bool) (hint string, err error) {
|
|
globals.SugarLogger.Debugf("SyncCategories catIDs:%v", catIDs)
|
|
db := dao.GetDB()
|
|
catList, err := dao.GetSkuCategoryWithVendor(db, nil, nil, -1, catIDs, true)
|
|
if err == nil && len(catList) > 0 {
|
|
// todo 按vendorID orgCode合并操作
|
|
task := tasksch.NewParallelTask(fmt.Sprintf("同步分类:%v", catIDs), nil, ctx,
|
|
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
|
catVendorInfo := batchItemList[0].(*dao.SkuStoreCatInfo)
|
|
if multiStoresHandler, ok := partner.GetPurchasePlatformFromVendorID(catVendorInfo.VendorID).(partner.IMultipleStoresHandler); ok {
|
|
if model.IsSyncStatusDelete(catVendorInfo.CatSyncStatus) { //删除
|
|
if !dao.IsVendorThingIDEmpty(catVendorInfo.VendorCatID) &&
|
|
model.IsSyncStatusNeedDelete(catVendorInfo.CatSyncStatus) {
|
|
err = multiStoresHandler.DeleteCategory2(ctx, catVendorInfo)
|
|
}
|
|
} else if model.IsSyncStatusNew(catVendorInfo.CatSyncStatus) { // 新增
|
|
err = multiStoresHandler.CreateCategory2(ctx, catVendorInfo)
|
|
} else if model.IsSyncStatusUpdate(catVendorInfo.CatSyncStatus) { // 修改
|
|
err = multiStoresHandler.UpdateCategory2(ctx, catVendorInfo)
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("平台:%d不合法", catVendorInfo.VendorID)
|
|
}
|
|
if err = OnThingSync(ctx, dao.GetDB(), SkuCategoryVendor2ThingMap(catVendorInfo), err); err == nil {
|
|
retVal = []int{1}
|
|
}
|
|
return retVal, err
|
|
}, catList)
|
|
tasksch.HandleTask(task, parentTask, len(catIDs) > 0).Run()
|
|
if isAsync {
|
|
hint = task.GetID()
|
|
} else {
|
|
resultList, err2 := task.GetResult(0)
|
|
if err = err2; err == nil {
|
|
hint = utils.Int2Str(len(resultList))
|
|
}
|
|
}
|
|
}
|
|
return hint, err
|
|
}
|
|
|
|
func SyncSkus(ctx *jxcontext.Context, parentTask tasksch.ITask, vendorIDs []int, appOrgCodes []string, nameIDs, skuIDs []int, isAsync bool) (hint string, err error) {
|
|
globals.SugarLogger.Debugf("SyncSkus nameIDs:%v, skuIDs:%v", nameIDs, skuIDs)
|
|
db := dao.GetDB()
|
|
skuList, err := dao.GetSkusWithVendor(db, nil, nil, nameIDs, skuIDs, true)
|
|
if err == nil && len(skuList) > 0 {
|
|
// todo 按vendorID orgCode合并操作
|
|
task := tasksch.NewParallelTask(fmt.Sprintf("同步商品:%v,%v", nameIDs, skuIDs), nil, ctx,
|
|
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
|
skuVendorInfo := batchItemList[0].(*dao.StoreSkuSyncInfo)
|
|
skuVendorInfo.SkuName = jxutils.ComposeSkuName(skuVendorInfo.Prefix, skuVendorInfo.Name, skuVendorInfo.Comment, skuVendorInfo.Unit, skuVendorInfo.SpecQuality, skuVendorInfo.SpecUnit, 0)
|
|
skuVendorInfo.MergedStatus = jxutils.MergeSkuStatus(skuVendorInfo.Status, skuVendorInfo.NameStatus)
|
|
if multiStoresHandler, ok := partner.GetPurchasePlatformFromVendorID(skuVendorInfo.VendorID).(partner.IMultipleStoresHandler); ok {
|
|
if model.IsSyncStatusDelete(skuVendorInfo.SkuSyncStatus) { //删除
|
|
if !dao.IsVendorThingIDEmpty(skuVendorInfo.VendorSkuID) &&
|
|
model.IsSyncStatusNeedDelete(skuVendorInfo.SkuSyncStatus) {
|
|
err = multiStoresHandler.DeleteSku2(ctx, skuVendorInfo)
|
|
}
|
|
} else if model.IsSyncStatusNew(skuVendorInfo.SkuSyncStatus) { // 新增
|
|
err = multiStoresHandler.CreateSku2(ctx, skuVendorInfo)
|
|
} else if model.IsSyncStatusUpdate(skuVendorInfo.SkuSyncStatus) { // 修改
|
|
err = multiStoresHandler.UpdateSku2(ctx, skuVendorInfo)
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("平台:%d不合法", skuVendorInfo.VendorID)
|
|
}
|
|
if err = OnThingSync(ctx, dao.GetDB(), SkuVendor2ThingMap(skuVendorInfo), err); err == nil {
|
|
retVal = []int{1}
|
|
}
|
|
return retVal, err
|
|
}, skuList)
|
|
tasksch.HandleTask(task, parentTask, len(skuList) > 0).Run()
|
|
if isAsync {
|
|
hint = task.GetID()
|
|
} else {
|
|
resultList, err2 := task.GetResult(0)
|
|
if err = err2; err == nil {
|
|
hint = utils.Int2Str(len(resultList))
|
|
}
|
|
}
|
|
}
|
|
return hint, err
|
|
}
|
|
|
|
func SyncReorderCategories(ctx *jxcontext.Context, parentCatID int, isAsync bool) (hint string, err error) {
|
|
globals.SugarLogger.Debugf("SyncReorderCategories parentCatID:%d", parentCatID)
|
|
db := dao.GetDB()
|
|
hint, err = CurVendorSync.LoopMultiStoresVendors(ctx, db, fmt.Sprintf("分类重排序:%d", parentCatID), isAsync, false,
|
|
func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
|
vendorInfo := batchItemList[0].(*tMultiStoreVendorInfo)
|
|
multiStoresHandler := CurVendorSync.GetMultiStoreHandler(vendorInfo.VendorID)
|
|
if multiStoresHandler != nil {
|
|
catList, err2 := dao.GetSkuCategoryWithVendor(db, []int{vendorInfo.VendorID}, []string{vendorInfo.OrgCode}, parentCatID, nil, false)
|
|
if err = err2; err == nil {
|
|
var vendorCatIDList []string
|
|
for _, v := range catList {
|
|
if v.VendorCatID != "" {
|
|
vendorCatIDList = append(vendorCatIDList, v.VendorCatID)
|
|
}
|
|
}
|
|
if len(vendorCatIDList) > 0 {
|
|
if err = multiStoresHandler.ReorderCategories2(ctx, vendorInfo.OrgCode, catList[0].ParentVendorCatID, vendorCatIDList); err == nil {
|
|
retVal = []int{len(vendorCatIDList)}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("非法平台:%d", vendorInfo.VendorID)
|
|
}
|
|
return retVal, err
|
|
})
|
|
return hint, err
|
|
}
|
|
|
|
func OnCreateThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
|
|
if thingType == model.ThingTypeSkuName {
|
|
return nil
|
|
}
|
|
errList := errlist.New()
|
|
for _, v := range getMultiStoreVendorInfoList() {
|
|
thingMap := &model.ThingMap{
|
|
ThingID: thingID,
|
|
ThingType: thingType,
|
|
VendorID: v.VendorID,
|
|
VendorOrgCode: v.OrgCode,
|
|
SyncStatus: model.SyncFlagNewMask,
|
|
}
|
|
dao.WrapAddIDCULDEntity(thingMap, ctx.GetUserName())
|
|
errList.AddErr(dao.CreateEntity(db, thingMap))
|
|
}
|
|
if globals.IsUseThingMap {
|
|
err = errList.GetErrListAsOne()
|
|
}
|
|
return err
|
|
}
|
|
|
|
func OnUpdateThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
|
|
if thingType == model.ThingTypeSkuName {
|
|
return nil
|
|
}
|
|
errList := errlist.New()
|
|
for _, v := range getMultiStoreVendorInfoList() {
|
|
thingMap := &model.ThingMap{
|
|
ThingID: thingID,
|
|
ThingType: thingType,
|
|
VendorID: v.VendorID,
|
|
VendorOrgCode: v.OrgCode,
|
|
}
|
|
thingMap.DeletedAt = utils.DefaultTimeValue
|
|
if err2 := dao.GetEntity(db, thingMap, "ThingID", "ThingType", "VendorID", "VendorOrgCode", model.FieldDeletedAt); err2 == nil {
|
|
thingMap.SyncStatus |= model.SyncFlagModifiedMask
|
|
thingMap.LastOperator = ctx.GetUserName()
|
|
_, err2 = dao.UpdateEntity(db, thingMap)
|
|
errList.AddErr(err2)
|
|
} else if !dao.IsNoRowsError(err2) {
|
|
errList.AddErr(err2)
|
|
}
|
|
}
|
|
if globals.IsUseThingMap {
|
|
err = errList.GetErrListAsOne()
|
|
}
|
|
return err
|
|
}
|
|
|
|
func OnDeleteThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
|
|
if thingType == model.ThingTypeSkuName {
|
|
return nil
|
|
}
|
|
errList := errlist.New()
|
|
for _, v := range getMultiStoreVendorInfoList() {
|
|
thingMap := &model.ThingMap{
|
|
ThingID: thingID,
|
|
ThingType: thingType,
|
|
VendorID: v.VendorID,
|
|
VendorOrgCode: v.OrgCode,
|
|
}
|
|
thingMap.DeletedAt = utils.DefaultTimeValue
|
|
if err2 := dao.GetEntity(db, thingMap, "ThingID", "ThingType", "VendorID", "VendorOrgCode", model.FieldDeletedAt); err2 == nil {
|
|
if model.IsSyncStatusNew(thingMap.SyncStatus) {
|
|
thingMap.SyncStatus = 0
|
|
thingMap.DeletedAt = time.Now()
|
|
} else {
|
|
thingMap.SyncStatus |= model.SyncFlagDeletedMask
|
|
}
|
|
thingMap.LastOperator = ctx.GetUserName()
|
|
_, err2 = dao.UpdateEntity(db, thingMap)
|
|
errList.AddErr(err2)
|
|
} else if !dao.IsNoRowsError(err2) {
|
|
errList.AddErr(err2)
|
|
}
|
|
}
|
|
if globals.IsUseThingMap {
|
|
err = errList.GetErrListAsOne()
|
|
}
|
|
return err
|
|
}
|
|
|
|
func SkuCategoryVendor2ThingMap(cat *dao.SkuStoreCatInfo) (thingMap *model.ThingMap) {
|
|
thingMap = &model.ThingMap{
|
|
ThingID: int64(cat.ID),
|
|
ThingType: model.ThingTypeCategory,
|
|
VendorID: cat.VendorID,
|
|
VendorOrgCode: cat.VendorOrgCode,
|
|
|
|
SyncStatus: cat.CatSyncStatus,
|
|
VendorThingID: cat.VendorCatID,
|
|
}
|
|
thingMap.ID = cat.MapID // 一定要赋值
|
|
return thingMap
|
|
}
|
|
|
|
func SkuVendor2ThingMap(sku *dao.StoreSkuSyncInfo) (thingMap *model.ThingMap) {
|
|
thingMap = &model.ThingMap{
|
|
ThingID: int64(sku.SkuID),
|
|
ThingType: model.ThingTypeSku,
|
|
VendorID: sku.VendorID,
|
|
VendorOrgCode: sku.VendorOrgCode,
|
|
|
|
SyncStatus: sku.SkuSyncStatus,
|
|
VendorThingID: sku.VendorSkuID,
|
|
}
|
|
thingMap.ID = sku.BindID // 一定要赋值
|
|
return thingMap
|
|
}
|
|
|
|
func OnThingSync(ctx *jxcontext.Context, db *dao.DaoDB, thingMap *model.ThingMap, syncErr error) (err error) {
|
|
globals.SugarLogger.Debugf("OnThingSync thingMap:%s", utils.Format4Output(thingMap, true))
|
|
if syncErr != nil {
|
|
err = syncErr
|
|
thingMap.Remark = utils.LimitUTF8StringLen(err.Error(), 255)
|
|
dao.UpdateEntity(db, thingMap, "Remark")
|
|
} else {
|
|
updateFields := []string{
|
|
model.FieldSyncStatus,
|
|
model.FieldUpdatedAt,
|
|
model.FieldLastOperator,
|
|
"Remark",
|
|
}
|
|
if model.IsSyncStatusDelete(thingMap.SyncStatus) { //删除
|
|
thingMap.DeletedAt = time.Now()
|
|
thingMap.VendorThingID = ""
|
|
updateFields = append(updateFields, "VendorThingID", model.FieldDeletedAt)
|
|
} else if model.IsSyncStatusNew(thingMap.SyncStatus) { // 新增
|
|
updateFields = append(updateFields, "VendorThingID")
|
|
}
|
|
thingMap.SyncStatus = 0
|
|
thingMap.LastOperator = ctx.GetUserName()
|
|
thingMap.UpdatedAt = time.Now()
|
|
thingMap.Remark = ""
|
|
_, err = dao.UpdateEntity(db, thingMap, updateFields...)
|
|
}
|
|
return err
|
|
}
|