1121 lines
48 KiB
Go
1121 lines
48 KiB
Go
package tiktok_store
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
address_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_create/request"
|
||
address_list_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/request"
|
||
address_list_response "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/response"
|
||
freightTemplate_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/freightTemplate_create/request"
|
||
freightTemplate_update_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/freightTemplate_update/request"
|
||
shop_batchCreateStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_batchCreateStore/request"
|
||
shop_bindStoreFreight_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreFreight/request"
|
||
shop_bindStoreSaleLimit_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreSaleLimit/request"
|
||
shop_editStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_editStore/request"
|
||
shop_getStoreDetail_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_getStoreDetail/request"
|
||
shop_getStoreList_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_getStoreList/request"
|
||
shop_storeSuspend_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_storeSuspend/request"
|
||
shop_unsuspendStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_unsuspendStore/request"
|
||
trade_UpdateTradeLimitTemplate_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/trade_UpdateTradeLimitTemplate/request"
|
||
trade_createTradeLimitTemplate_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/trade_createTradeLimitTemplate/request"
|
||
"git.rosy.net.cn/baseapi/platformapi/tiktok_shop/tiktok_api"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"git.rosy.net.cn/baseapi/utils/errlist"
|
||
"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler"
|
||
"git.rosy.net.cn/jx-callback/business/jxstore/event"
|
||
"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"
|
||
"git.rosy.net.cn/jx-callback/globals/api"
|
||
"reflect"
|
||
)
|
||
|
||
func SplicingTimeToDoudian(openTime1, closeTime1, openTime2, closeTime2 int16, flag bool) (timeList string) {
|
||
//700 1200 -> 07:00-12:00
|
||
var (
|
||
s1 = ""
|
||
ts1 = ""
|
||
s2 = ""
|
||
ts2 = ""
|
||
//ts3 = ""//暂不支持多时间段
|
||
s4 = ""
|
||
ts4 = ""
|
||
timeStr = ""
|
||
)
|
||
if openTime1 != 0 && closeTime1 != 0 {
|
||
tOpenTime1 := utils.Int64ToStr(int64(openTime1))
|
||
len1 := len(tOpenTime1) - 2
|
||
if utils.Str2Int(tOpenTime1[:len1]) <= 9 {
|
||
ts1 = "0"
|
||
}
|
||
s1 = ts1 + tOpenTime1[:len1] + ":" + tOpenTime1[len1:]
|
||
tCloseTime1 := utils.Int64ToStr(int64(closeTime1))
|
||
len2 := len(tCloseTime1) - 2
|
||
if utils.Str2Int(tCloseTime1[:len2]) <= 9 {
|
||
ts2 = "0"
|
||
}
|
||
s2 = ts2 + tCloseTime1[:len2] + ":" + tCloseTime1[len2:]
|
||
if openTime2 != 0 && closeTime2 != 0 {
|
||
//tOpenTime2 := utils.Int64ToStr(int64(openTime2))
|
||
//len3 := len(tOpenTime2) - 2
|
||
//if utils.Str2Int(tOpenTime2[:len3]) <= 9 {
|
||
// ts3 = "0"
|
||
//}
|
||
//s3 = ts3 + tOpenTime2[:len3] + ":" + tOpenTime2[len3:]
|
||
tCloseTime2 := utils.Int64ToStr(int64(closeTime2))
|
||
len4 := len(tCloseTime2) - 2
|
||
if utils.Str2Int(tCloseTime2[:len4]) <= 9 {
|
||
ts4 = "0"
|
||
}
|
||
s4 = ts4 + tCloseTime2[:len4] + ":" + tCloseTime2[len4:]
|
||
}
|
||
}
|
||
if flag {
|
||
timeStr += s1 + "-" + s4
|
||
} else {
|
||
timeStr += s1 + "-" + s2
|
||
}
|
||
return timeStr
|
||
}
|
||
|
||
// shop/batchCreateStore 批量创建门店
|
||
func (P *PurchaseHandler) CreateStore2(db *dao.DaoDB, storeID int, userName string, params map[string]interface{}, storeDetail *dao.StoreDetail) (vendorStoreID string, err error) {
|
||
var (
|
||
vendorStoreIDs string
|
||
ShopBatchCreateStoreParam *shop_batchCreateStore_request.ShopBatchCreateStoreParam
|
||
errList = errlist.New()
|
||
timeStr = ""
|
||
m = make(map[int64]string)
|
||
a = getAPI(storeDetail.VendorOrgCode, storeID, storeDetail.VendorStoreID)
|
||
)
|
||
if storeDetail.OpenTime1 == 0 || storeDetail.CloseTime1 == 0 {
|
||
return "", fmt.Errorf("营业时间必填")
|
||
} else {
|
||
if storeDetail.OpenTime2 != 0 && storeDetail.CloseTime2 != 0 {
|
||
timeStr = SplicingTimeToDoudian(storeDetail.OpenTime1, storeDetail.CloseTime1, storeDetail.OpenTime2, storeDetail.CloseTime2, true)
|
||
} else {
|
||
timeStr = SplicingTimeToDoudian(storeDetail.OpenTime1, storeDetail.CloseTime1, 0, 0, false)
|
||
}
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
}
|
||
ShopBatchCreateStoreParam = &shop_batchCreateStore_request.ShopBatchCreateStoreParam{
|
||
StoreList: []shop_batchCreateStore_request.StoreListItem{
|
||
{
|
||
RowId: 1,
|
||
Name: "京西菜市(" + storeDetail.Name + ")",
|
||
StoreCode: utils.Int2Str(storeDetail.Store.ID),
|
||
Longitude: utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lng)),
|
||
Latitude: utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lat)),
|
||
Province: storeDetail.ProvinceName,
|
||
City: storeDetail.CityName,
|
||
District: storeDetail.DistrictName,
|
||
Address: storeDetail.Address,
|
||
Contact: storeDetail.Tel1,
|
||
OpenTime: &shop_batchCreateStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
},
|
||
},
|
||
}
|
||
if resp, err := a.BatchCreateStore(ShopBatchCreateStoreParam); err != nil {
|
||
return "", err
|
||
} else {
|
||
//必须先存进数据库
|
||
storeMap := &model.StoreMap{
|
||
VendorStoreID: vendorStoreID,
|
||
StoreID: storeID,
|
||
VendorID: model.VendorIDDD,
|
||
VendorOrgCode: storeDetail.VendorOrgCode,
|
||
Status: 0,
|
||
DeliveryType: model.StoreDeliveryTypeByStore,
|
||
PricePercentage: int16(utils.MustInterface2Int64(storeDetail.PricePercentage)),
|
||
AutoPickup: 1,
|
||
DeliveryCompetition: 1,
|
||
IsSync: 1,
|
||
PricePercentagePack: "",
|
||
}
|
||
dao.WrapAddIDCULDEntity(storeMap, userName)
|
||
if err := dao.CreateEntity(db, storeMap); err != nil {
|
||
errList.AddErr(dao.CreateEntity(db, storeMap))
|
||
}
|
||
vendorStoreIDs = utils.Int64ToStr(resp.ResultList[0].Store.StoreId)
|
||
if err := CreateOrUpdateAll(storeDetail.VendorOrgCode, int64(storeDetail.Store.ID), resp.ResultList[0].Store.StoreId, int64(storeDetail.DeliveryFeeDeductionFee), utils.Str2Int64(storeDetail.YbStorePrefix)); err != nil {
|
||
errList.AddErr(err)
|
||
}
|
||
}
|
||
endErr := errList.GetErrListAsOne()
|
||
return vendorStoreIDs, errors.New(fmt.Sprintf("创建抖店平台店铺相关错误信息：%v", endErr))
|
||
}
|
||
|
||
func CreateOrUpdateAll(vendorOrgCode string, storeID, vendorStoreID, deliveryFeeDeductionFee, minPrice int64) error {
|
||
var (
|
||
errList = errlist.New()
|
||
FreightTemplate = &model.FreightTemplate{}
|
||
db *dao.DaoDB
|
||
)
|
||
//1.平台获取门店运费模板
|
||
bindFreightIDs, err := GetStoreFreight(vendorOrgCode, vendorStoreID)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("获取门店(%d) 绑定运费模板出错:%v", vendorStoreID, err)
|
||
errList.AddErr(fmt.Errorf("获取门店(%d) 绑定运费模板出错:%v", vendorStoreID, err))
|
||
}
|
||
if bindFreightIDs == 0 { //（1）未查询到绑定信息，不算错误
|
||
//创建
|
||
if freightTemplateID, err := CreateFreightTemplate(int(storeID)); err != nil || freightTemplateID == 0 || utils.IsNil(freightTemplateID) {
|
||
globals.SugarLogger.Debugf("京西菜市门店:%d 平台门店:%d 创建运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err)
|
||
errList.AddErr(fmt.Errorf("京西菜市门店:%d 平台门店:%d 创建运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err))
|
||
} else { //绑定
|
||
if err = ShopBindStoreFreight(vendorOrgCode, vendorStoreID, freightTemplateID); err != nil {
|
||
globals.SugarLogger.Debug("京西菜市门店:%d 平台门店:%d 绑定运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err)
|
||
errList.AddErr(fmt.Errorf("京西菜市门店:%d 平台门店:%d 绑定运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err))
|
||
} else {
|
||
FreightTemplate.TemplateID = freightTemplateID
|
||
}
|
||
}
|
||
} else {
|
||
FreightTemplate.TemplateID = bindFreightIDs
|
||
}
|
||
|
||
//2.平台获取仓库信息以及电子围栏id
|
||
//bindWarehouseAndFence, err := GetWarehouseByStore(vendorOrgCode, vendorStoreID)
|
||
//if err != nil {
|
||
// globals.SugarLogger.Debugf("获取门店(%d) 绑定仓库信息以及电子围栏出错:%v", vendorStoreID, err)
|
||
// errList.AddErr(fmt.Errorf("获取门店(%d) 绑定仓库信息以及电子围栏出错:%v", vendorStoreID, err))
|
||
//}
|
||
//if len(bindWarehouseAndFence) == 0 || utils.IsNil(bindWarehouseAndFence) { //未绑定仓库以及电子围栏
|
||
//(1)创建仓库
|
||
warehouseID, err := CreateWarehouse(vendorOrgCode, storeID)
|
||
if err != nil || len(warehouseID) == 0 || utils.IsNil(warehouseID) {
|
||
globals.SugarLogger.Debugf("门店(%d) 创建仓库失败:%v", storeID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 创建仓库失败:%v", storeID, err))
|
||
} else { //绑定
|
||
if err = BindStoreWarehouse(vendorOrgCode, utils.Int64ToStr(storeID), vendorStoreID); err != nil { //仓库绑定通过自定义外部ID
|
||
globals.SugarLogger.Debugf("门店(%d) 绑定仓库:%s 失败:%v", storeID, warehouseID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 绑定仓库:%s 失败:%v", storeID, warehouseID, err))
|
||
} else {
|
||
FreightTemplate.WarehouseID = utils.Str2Int64(warehouseID)
|
||
}
|
||
}
|
||
//(2)创建电子围栏
|
||
if fenceID, err := CreateFenceByStore(vendorOrgCode, storeID); err != nil || utils.Str2Int(fenceID) == 0 || utils.IsNil(fenceID) { //不管存在与否 直接创建
|
||
globals.SugarLogger.Debugf("门店(%d) 创建电子围栏失败:%v", storeID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 创建电子围栏失败:%v", storeID, err))
|
||
} else { //绑定
|
||
if err := BindFenceByStore(vendorOrgCode, vendorStoreID, []string{utils.Int64ToStr(storeID)}); err != nil {
|
||
globals.SugarLogger.Debugf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err))
|
||
} else {
|
||
FreightTemplate.FenceID = utils.Int64ToStr(storeID)
|
||
}
|
||
//}
|
||
//} else {
|
||
// //电子围栏二次验证
|
||
// if len(bindWarehouseAndFence[vendorStoreID][0].OutFenceIds) == 0 || utils.IsNil(bindWarehouseAndFence[vendorStoreID][0].OutFenceIds) { //未绑定电子围栏
|
||
// globals.SugarLogger.Debugf("进入二次创建电子围栏=========")
|
||
// if fenceID, err := CreateFenceByStore(vendorOrgCode, storeID); err != nil || utils.Str2Int(fenceID) == 0 || utils.IsNil(fenceID) { //创建
|
||
// globals.SugarLogger.Debug("门店(%d) 创建电子围栏失败:%v", storeID, err)
|
||
// errList.AddErr(fmt.Errorf("门店(%d) 创建电子围栏失败:%v", storeID, err))
|
||
// } else { //绑定
|
||
// if err := BindFenceByStore(vendorOrgCode, vendorStoreID, []string{utils.Int64ToStr(storeID)}); err != nil {
|
||
// globals.SugarLogger.Debugf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err)
|
||
// errList.AddErr(fmt.Errorf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err))
|
||
// } else {
|
||
// FreightTemplate.FenceID = utils.Int64ToStr(storeID)
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
//3.平台获取限售模板
|
||
bindSaleLimitID, err := GetStoreSaleLimit(vendorOrgCode, vendorStoreID)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("获取门店(%d) 限售模板失败:%v", vendorStoreID, err)
|
||
errList.AddErr(fmt.Errorf("获取门店(%d) 限售模板失败:%v", vendorStoreID, err))
|
||
}
|
||
if bindSaleLimitID == 0 || utils.IsNil(bindSaleLimitID) { //未绑定限售模板,目前默认创建起送价限售模板
|
||
if createSaleLimitID, err := CreateAndBindMinPriceTemplate(vendorOrgCode, vendorStoreID, minPrice); err != nil {
|
||
errList.AddErr(fmt.Errorf("设置门店起送价限售模板失败:%v", err))
|
||
} else {
|
||
FreightTemplate.TradeLimitID = createSaleLimitID
|
||
}
|
||
} else {
|
||
if updateSaleLimitID, err := UpdateTradeLimitTemplate(vendorOrgCode, bindSaleLimitID, minPrice); err != nil {
|
||
errList.AddErr(fmt.Errorf("更新门店起送价限售模板失败：%v", err))
|
||
} else {
|
||
FreightTemplate.TradeLimitID = updateSaleLimitID
|
||
}
|
||
}
|
||
|
||
//4. 设置门店打包费 默认为0
|
||
if err := SetStorePackageFee(vendorOrgCode, vendorStoreID, deliveryFeeDeductionFee); err != nil {
|
||
errList.AddErr(fmt.Errorf("设置门店打包费失败:%v", err))
|
||
}
|
||
|
||
//5.同步进数据库
|
||
FreightTemplate = &model.FreightTemplate{
|
||
StoreID: int(storeID),
|
||
VendorStoreID: utils.Int64ToStr(vendorStoreID),
|
||
}
|
||
if err := dao.CreateEntity(db, FreightTemplate); err != nil {
|
||
if _, err1 := dao.UpdateEntity(db, FreightTemplate, "TemplateID", "WarehouseID", "FenceID", "TradeLimitID"); err1 != nil {
|
||
errList.AddErr(fmt.Errorf("更新操作，同步进数据库错误信息:%v", err1))
|
||
} else {
|
||
errList.AddErr(fmt.Errorf("创建操作，同步进数据库错误信息:%v", err))
|
||
}
|
||
}
|
||
endErr := errList.GetErrListAsOne()
|
||
if utils.IsNil(errList) {
|
||
globals.SugarLogger.Debug("绑定门店需进行的错误处理:%v", errors.New(fmt.Sprintf("%s", utils.Format4Output(errList, false))))
|
||
return endErr
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
func CreateAndBindAllV2(vendorOrgCode string, storeID, vendorStoreID, deliveryFeeDeductionFee, minPrice int64) error {
|
||
var (
|
||
db *dao.DaoDB
|
||
ctx *jxcontext.Context
|
||
errList = errlist.New()
|
||
FreightTemplate = &model.FreightTemplate{
|
||
VendorStoreID: utils.Int64ToStr(vendorStoreID),
|
||
StoreID: int(storeID),
|
||
}
|
||
)
|
||
task := tasksch.NewParallelTask("CreateAndBindAllV2", tasksch.NewParallelConfig().SetIsContinueWhenError(true).SetParallelCount(1), ctx,
|
||
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
||
step := batchItemList[0].(int)
|
||
switch step {
|
||
case 0: //1.门店运费模板
|
||
bindFreightIDs, err := GetStoreFreight(vendorOrgCode, vendorStoreID)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("获取门店(%d) 绑定运费模板出错:%v", vendorStoreID, err)
|
||
errList.AddErr(fmt.Errorf("获取门店(%d) 绑定运费模板出错:%v", vendorStoreID, err))
|
||
}
|
||
if bindFreightIDs == 0 {
|
||
if freightTemplateID, err := CreateFreightTemplate(int(storeID)); err != nil || freightTemplateID == 0 || utils.IsNil(freightTemplateID) {
|
||
globals.SugarLogger.Debugf("京西菜市门店:%d 平台门店:%d 创建运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err)
|
||
errList.AddErr(fmt.Errorf("京西菜市门店:%d 平台门店:%d 创建运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err))
|
||
} else {
|
||
if err = ShopBindStoreFreight(vendorOrgCode, vendorStoreID, freightTemplateID); err != nil {
|
||
globals.SugarLogger.Debugf("京西菜市门店:%d 平台门店:%d 绑定运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err)
|
||
errList.AddErr(fmt.Errorf("京西菜市门店:%d 平台门店:%d 绑定运费模板:%d 失败:%v", storeID, vendorStoreID, freightTemplateID, err))
|
||
} else {
|
||
FreightTemplate.TemplateID = freightTemplateID
|
||
}
|
||
}
|
||
} else {
|
||
FreightTemplate.TemplateID = bindFreightIDs
|
||
}
|
||
case 1: //2.仓库以及电子围栏
|
||
warehouseID, err := CreateWarehouse(vendorOrgCode, storeID)
|
||
if err != nil || len(warehouseID) == 0 || utils.IsNil(warehouseID) {
|
||
globals.SugarLogger.Debugf("门店(%d) 创建仓库失败:%v", storeID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 创建仓库失败:%v", storeID, err))
|
||
} else { //绑定
|
||
if err = BindStoreWarehouse(vendorOrgCode, utils.Int64ToStr(storeID), vendorStoreID); err != nil { //仓库绑定通过自定义外部ID
|
||
globals.SugarLogger.Debugf("门店(%d) 绑定仓库:%s 失败:%v", storeID, warehouseID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 绑定仓库:%s 失败:%v", storeID, warehouseID, err))
|
||
} else {
|
||
FreightTemplate.WarehouseID = utils.Str2Int64(warehouseID)
|
||
}
|
||
}
|
||
case 2: //3.电子围栏
|
||
fenceID, err := CreateFenceByStore(vendorOrgCode, storeID)
|
||
if err != nil || utils.Str2Int(fenceID) == 0 || utils.IsNil(fenceID) { //不管存在与否 直接创建
|
||
globals.SugarLogger.Debugf("门店(%d) 创建电子围栏失败:%v", storeID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 创建电子围栏失败:%v", storeID, err))
|
||
} else { //绑定
|
||
if err := BindFenceByStore(vendorOrgCode, vendorStoreID, []string{utils.Int64ToStr(storeID)}); err != nil {
|
||
globals.SugarLogger.Debugf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err))
|
||
} else {
|
||
FreightTemplate.FenceID = utils.Int64ToStr(storeID)
|
||
}
|
||
}
|
||
case 3: //4.限售模板
|
||
bindSaleLimitID, err := GetStoreSaleLimit(vendorOrgCode, vendorStoreID)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("获取门店(%d) 限售模板失败:%v", vendorStoreID, err)
|
||
errList.AddErr(fmt.Errorf("获取门店(%d) 限售模板失败:%v", vendorStoreID, err))
|
||
}
|
||
if bindSaleLimitID == 0 || utils.IsNil(bindSaleLimitID) { //未绑定限售模板,目前默认创建起送价限售模板
|
||
if createSaleLimitID, err := CreateAndBindMinPriceTemplate(vendorOrgCode, vendorStoreID, minPrice); err != nil {
|
||
errList.AddErr(fmt.Errorf("设置门店起送价限售模板失败:%v", err))
|
||
} else {
|
||
FreightTemplate.TradeLimitID = createSaleLimitID
|
||
}
|
||
} else {
|
||
if updateSaleLimitID, err := UpdateTradeLimitTemplate(vendorOrgCode, bindSaleLimitID, minPrice); err != nil {
|
||
errList.AddErr(fmt.Errorf("更新门店起送价限售模板失败：%v", err))
|
||
} else {
|
||
FreightTemplate.TradeLimitID = updateSaleLimitID
|
||
}
|
||
}
|
||
case 4: //5.门店打包费 默认为 0
|
||
if err := SetStorePackageFee(vendorOrgCode, vendorStoreID, deliveryFeeDeductionFee); err != nil {
|
||
errList.AddErr(fmt.Errorf("设置门店打包费失败：%v", err))
|
||
}
|
||
}
|
||
return nil, err
|
||
}, []int{0, 1, 2, 3, 4})
|
||
tasksch.ManageTask(task).Run()
|
||
//6.同步进数据库
|
||
globals.SugarLogger.Debugf("preTest TradeLimitID==%d,TemplateID==%d, WarehouseID==%d,FenceID==%s", FreightTemplate.TradeLimitID, FreightTemplate.TemplateID, FreightTemplate.WarehouseID, FreightTemplate.FenceID)
|
||
if err := dao.CreateEntity(db, FreightTemplate); err != nil {
|
||
_, err1 := dao.UpdateEntity(db, FreightTemplate, "TemplateID", "WarehouseID", "FenceID", "TradeLimitID")
|
||
if err1 == nil {
|
||
errList.AddErr(fmt.Errorf("同步Step1进数据库错误信息:%v", err))
|
||
} else {
|
||
errList.AddErr(fmt.Errorf("同步Step2进数据库错误信息:%v", err1))
|
||
}
|
||
}
|
||
endErr := errList.GetErrListAsOne()
|
||
if utils.IsNil(errList) {
|
||
globals.SugarLogger.Debug("绑定门店需进行的错误处理:%v", endErr)
|
||
return endErr
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
// shop/editStore 编辑门店信息 正向推送平台
|
||
func (P *PurchaseHandler) UpdateStore(db *dao.DaoDB, storeID int, userName string) (err error) {
|
||
var (
|
||
m = make(map[int64]string)
|
||
name string
|
||
storeInfo *dao.StoreDetail
|
||
errList = errlist.New()
|
||
timeStr = ""
|
||
FreightTemplate = &model.FreightTemplate{}
|
||
)
|
||
if db == nil {
|
||
db = dao.GetDB()
|
||
}
|
||
storeInfo, err = dao.GetStoreDetail(db, storeID, model.VendorIDDD, "")
|
||
if storeInfo.OpenTime1 != 0 && storeInfo.CloseTime1 != 0 {
|
||
if storeInfo.OpenTime2 != 0 && storeInfo.CloseTime2 != 0 {
|
||
timeStr = SplicingTimeToDoudian(storeInfo.OpenTime1, storeInfo.CloseTime1, storeInfo.OpenTime2, storeInfo.CloseTime2, true)
|
||
} else {
|
||
timeStr = SplicingTimeToDoudian(storeInfo.OpenTime1, storeInfo.CloseTime1, 0, 0, false)
|
||
}
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
} else {
|
||
return fmt.Errorf("营业时间必填")
|
||
}
|
||
vendorStoreID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(storeInfo.VendorStoreID),
|
||
}
|
||
apiObj := getAPI(storeInfo.VendorOrgCode, storeID, utils.Int64ToStr(vendorStoreID.StoreId))
|
||
if globals.EnableDdStoreWrite {
|
||
remoteStoreInfo, err2 := apiObj.GetStoreDetail(vendorStoreID)
|
||
if err2 != nil {
|
||
return err2
|
||
}
|
||
if remoteStoreInfo.StoreDetail.Store.StoreId == 0 {
|
||
return fmt.Errorf("ID(%d) 的门店不存在,请先创建", utils.Str2Int64(storeInfo.VendorStoreID))
|
||
}
|
||
mergedStoreStatus := jxutils.MergeStoreStatus(storeInfo.Status, storeInfo.VendorStatus)
|
||
name = remoteStoreInfo.StoreDetail.Store.Name
|
||
if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreName) != 0 {
|
||
if storeInfo.VendorStoreName != "" {
|
||
name = storeInfo.VendorStoreName
|
||
}
|
||
}
|
||
store := fmt.Sprintf("门店id:%d,门店名称:%s,第三方门店状态:%d,本地修改前门店状态%d,本地门店修改后状态:%d,第三方平台Id(抖店):%s", storeID, remoteStoreInfo.StoreDetail.Store.Name, remoteStoreInfo.StoreDetail.Store.State, storeInfo.Status, mergedStoreStatus, storeInfo.VendorOrgCode)
|
||
event.AddOperateEvent(jxcontext.AdminCtx, jxcontext.AdminCtx.GetTrackInfo(), store, "", "", 10, "UpdateStore")
|
||
params := &shop_editStore_request.ShopEditStoreParam{
|
||
StoreId: remoteStoreInfo.StoreDetail.Store.StoreId, //平台id不可修改
|
||
Name: name,
|
||
StoreCode: utils.Int2Str(storeInfo.ID), //自用编码即本地storeID
|
||
Latitude: utils.Int2Str(storeInfo.Lat),
|
||
Longitude: utils.Int2Str(storeInfo.Lng),
|
||
Province: storeInfo.ProvinceName,
|
||
City: storeInfo.CityName,
|
||
District: storeInfo.DistrictName,
|
||
Address: storeInfo.Address,
|
||
Contact: storeInfo.Tel1,
|
||
OpenTime: &shop_editStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
}
|
||
//修改店铺状态
|
||
if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreStatus) != 0 {
|
||
errList.AddErr(UpdateStoreStatus(jxcontext.AdminCtx, storeInfo.VendorOrgCode, storeID, storeInfo.VendorStoreID, mergedStoreStatus))
|
||
}
|
||
err3 := apiObj.EditStore(params)
|
||
if err3 != nil {
|
||
errList.AddErr(fmt.Errorf("修改门店(%d) 信息失败:%v", utils.Str2Int64(storeInfo.VendorStoreID), err3))
|
||
}
|
||
//电子围栏
|
||
bindWarehouseAndFence, err := GetWarehouseByStore(storeInfo.VendorOrgCode, utils.Str2Int64(storeInfo.VendorStoreID)) //todo 此接口暂时有问题
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("获取门店(%d) 电子围栏失败:%v", utils.Str2Int64(storeInfo.VendorStoreID), err))
|
||
}
|
||
if len(bindWarehouseAndFence) == 0 || (len(bindWarehouseAndFence) != 0 && len(bindWarehouseAndFence[utils.Str2Int64(storeInfo.VendorStoreID)][0].OutFenceIds) == 0) {
|
||
if fenceID, err := CreateFenceByStore(storeInfo.VendorOrgCode, int64(storeID)); err != nil || utils.Str2Int(fenceID) == 0 || utils.IsNil(fenceID) { //创建
|
||
globals.SugarLogger.Debug("门店(%d) 创建电子围栏失败:%v", storeID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 创建电子围栏失败:%v", storeID, err))
|
||
} else { //绑定
|
||
if err := BindFenceByStore(storeInfo.VendorOrgCode, utils.Str2Int64(storeInfo.VendorStoreID), []string{utils.Int2Str(storeID)}); err != nil {
|
||
globals.SugarLogger.Debug("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 绑定电子围栏:%s失败:%v", storeID, fenceID, err))
|
||
} else {
|
||
FreightTemplate.FenceID = utils.Int2Str(storeID)
|
||
}
|
||
}
|
||
} else {
|
||
//更新电子围栏
|
||
outFenceID := bindWarehouseAndFence[utils.Str2Int64(storeInfo.VendorStoreID)][0].OutFenceIds[0]
|
||
//容错绑定
|
||
if err := BindFenceByStore(storeInfo.VendorOrgCode, utils.Str2Int64(storeInfo.VendorStoreID), []string{outFenceID}); err != nil {
|
||
globals.SugarLogger.Debugf("门店(%d) 容错绑定电子围栏:%s失败:%v", storeID, outFenceID, err)
|
||
errList.AddErr(fmt.Errorf("门店(%d) 容错绑定电子围栏:%s失败:%v", storeID, outFenceID, err))
|
||
}
|
||
if err = UpdateFenceByStore(storeInfo.VendorOrgCode, outFenceID, storeID); err != nil {
|
||
return errors.New(fmt.Sprintf("更新电子围栏失败，原因:%v", err))
|
||
}
|
||
FreightTemplate.FenceID = outFenceID
|
||
}
|
||
//同步进数据库
|
||
FreightTemplate = &model.FreightTemplate{
|
||
StoreID: storeID,
|
||
VendorStoreID: storeInfo.VendorStoreID,
|
||
}
|
||
if err = dao.CreateEntity(db, FreightTemplate); err != nil {
|
||
if _, err1 := dao.UpdateEntity(db, FreightTemplate, "FenceID"); err1 != nil {
|
||
globals.SugarLogger.Debugf("db update storeID,vendorStoreID defeat on :%v", err1)
|
||
errList.AddErr(fmt.Errorf("更新操作，同步进数据库错误信息:%v", err1))
|
||
} else {
|
||
errList.AddErr(fmt.Errorf("创建操作，同步进数据库错误信息:%v", err))
|
||
}
|
||
}
|
||
}
|
||
endErr := errList.GetErrListAsOne()
|
||
globals.SugarLogger.Debugf("DouDian UpdateStore wrong information:%v", endErr)
|
||
return errors.New(fmt.Sprintf("更新抖店平台店铺信息，相关处理错误：%v", endErr))
|
||
}
|
||
|
||
// UpdateStoreStatus shop/unsuspendStore 门店恢复营业
|
||
func UpdateStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, status int) (err error) {
|
||
isOnline := bizStatusJX2DouDian(status)
|
||
a := getAPI(vendorOrgCode, storeID, vendorStoreID)
|
||
if globals.EnableDdStoreWrite {
|
||
if isOnline != tiktok_api.StoreStatusOnline { //暂停营业状态
|
||
if _, err = a.StoreSuspend(&shop_storeSuspend_request.ShopStoreSuspendParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
} else { //恢复营业
|
||
//与平台上店铺状态对比
|
||
remoteStoreInfo, err2 := a.GetStoreDetail(&shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
})
|
||
if err2 != nil {
|
||
return err2
|
||
}
|
||
if remoteStoreInfo.StoreDetail.Store.SuspendType == tiktok_api.SuspendTypePlatformPenalty {
|
||
err = errors.New("门店因平台处罚暂停营业，不可主动修改营业状态")
|
||
} else {
|
||
if _, err = a.UnsuspendStore(&shop_unsuspendStore_request.ShopUnsuspendStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
//默认 运费模板只创建 固定运费模板
|
||
func CreateFreightTemplate(storeCode int) (int64, error) {
|
||
storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeCode, model.VendorIDDD, "")
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
param := &freightTemplate_create_request.FreightTemplateCreateParam{
|
||
Template: &freightTemplate_create_request.Template{
|
||
TemplateName: storeDetail.VendorStoreName + "(" + utils.Int2Str(storeCode) + ")_",
|
||
ProductProvince: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
CalculateType: 2, //计价方式-1.按重量 2.按数量
|
||
TransferType: 1,
|
||
RuleType: 1, //固定运费&卖家包邮
|
||
FixedAmount: 500, //固定运费 单位：分
|
||
},
|
||
}
|
||
//直辖市特殊处理
|
||
flag := false
|
||
if storeDetail.CityName == tiktok_api.MunicipalityBeiJin || storeDetail.CityName == tiktok_api.MunicipalityShangHai || storeDetail.CityName == tiktok_api.MunicipalityTianJin || storeDetail.CityName == tiktok_api.MunicipalityChongQing {
|
||
flag = true
|
||
param.Template.ProductCity = int64(storeDetail.ProvinceCode)
|
||
} else {
|
||
param.Template.ProductCity = int64(storeDetail.CityCode)
|
||
}
|
||
if int64(storeDetail.DeliveryFeeDeductionSill) != 0 {
|
||
param.Template.TemplateName += "满减包邮模板"
|
||
columns := []freightTemplate_create_request.ColumnsItem{
|
||
{
|
||
IsOverFree: true, //是否包邮
|
||
IsLimited: false,
|
||
OverAmount: int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储满x包邮金额
|
||
}}
|
||
param.Columns = columns
|
||
if flag {
|
||
param.Columns[0].ProvinceInfos = []freightTemplate_create_request.ProvinceInfosItem{
|
||
{
|
||
Id: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
Children: []freightTemplate_create_request.ChildrenItem_4{
|
||
{
|
||
Id: int64(storeDetail.ProvinceCode),
|
||
Children: []freightTemplate_create_request.ChildrenItem_5{
|
||
{
|
||
Id: int64(storeDetail.DistrictCode),
|
||
Children: []freightTemplate_create_request.ChildrenItem{
|
||
{Id: 0},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}},
|
||
}
|
||
} else {
|
||
param.Columns[0].ProvinceInfos = []freightTemplate_create_request.ProvinceInfosItem{
|
||
{
|
||
Id: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
Children: []freightTemplate_create_request.ChildrenItem_4{
|
||
{
|
||
Id: int64(storeDetail.CityCode),
|
||
Children: []freightTemplate_create_request.ChildrenItem_5{
|
||
{
|
||
Id: int64(storeDetail.DistrictCode),
|
||
Children: []freightTemplate_create_request.ChildrenItem{
|
||
{Id: 0},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}},
|
||
}
|
||
}
|
||
} else {
|
||
param.Columns = nil
|
||
param.Template.TemplateName += "固定运费模板"
|
||
}
|
||
globals.SugarLogger.Debugf(" param.Template.ProductCity==%d,param.Template.ProductProvince==%d", param.Template.ProductCity, param.Template.ProductProvince)
|
||
resp, err := getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateCreate(param)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return resp.TemplateId, nil
|
||
}
|
||
|
||
// /freightTemplate/update 修改运费模板
|
||
func UpdateFreightTemplate(storeCode int) error {
|
||
globals.SugarLogger.Debugf("进入UpdateFreightTemplate")
|
||
//获取本地门店信息
|
||
storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeCode, model.VendorIDDD, "")
|
||
if err != nil {
|
||
return errors.New(fmt.Sprintf("获取本地门店信息失败:%v", err))
|
||
}
|
||
//获取绑定的运费模板信息
|
||
bindTemplate, err := GetStoreFreight(storeDetail.VendorOrgCode, utils.Str2Int64(storeDetail.VendorStoreID))
|
||
if err != nil || bindTemplate == 0 {
|
||
return errors.New(fmt.Sprintf("获取门店绑定运费模板失败:%v，请先创建运费模板", err))
|
||
} else {
|
||
param := &freightTemplate_update_request.FreightTemplateUpdateParam{
|
||
Template: &freightTemplate_update_request.Template{
|
||
Id: bindTemplate,
|
||
TemplateName: storeDetail.VendorStoreName + "(" + utils.Int2Str(storeCode) + ")_",
|
||
ProductProvince: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
CalculateType: 2, //计价方式-1.按重量 2.按数量
|
||
TransferType: 1,
|
||
RuleType: 1, //固定运费
|
||
FixedAmount: 500, //固定运费 单位：分
|
||
},
|
||
}
|
||
if storeDetail.CityName == tiktok_api.MunicipalityBeiJin || storeDetail.CityName == tiktok_api.MunicipalityShangHai || storeDetail.CityName == tiktok_api.MunicipalityTianJin || storeDetail.CityName == tiktok_api.MunicipalityChongQing {
|
||
param.Template.ProductCity = int64(storeDetail.ProvinceCode)
|
||
} else {
|
||
param.Template.ProductCity = int64(storeDetail.CityCode)
|
||
}
|
||
if int64(storeDetail.DeliveryFeeDeductionSill) != 0 {
|
||
param.Template.TemplateName += "满减包邮模板"
|
||
columns := []freightTemplate_update_request.ColumnsItem{
|
||
{
|
||
IsOverFree: true, //是否包邮
|
||
IsDefault: 0,
|
||
IsLimited: false,
|
||
OverAmount: int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储满x包邮金额
|
||
}}
|
||
param.Columns = columns
|
||
} else {
|
||
param.Columns = nil
|
||
param.Template.TemplateName += "固定运费模板"
|
||
}
|
||
_, err = getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateUpdate(param)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// /freightTemplate/create 批量创建 满x包邮 运费模板
|
||
//func (P *PurchaseHandler) BatchCreateFreightTemplate(relInfo map[string]map[string]string, shipFee int64) error {
|
||
// var (
|
||
// errList = errlist.New()
|
||
// flag = make(map[string]bool)
|
||
// )
|
||
// for i, j := range relInfo {
|
||
// for k, v := range j {
|
||
// if bindFreightID, err := getAPI(i, utils.Str2Int(k), v).GetStoreFreight(utils.Str2Int64(v)); err != nil || len(bindFreightID) == 0 {
|
||
// flag[v] = false
|
||
// }
|
||
// flag[v] = true
|
||
// }
|
||
// }
|
||
// storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeID, model.VendorIDDD, "")
|
||
// if err != nil {
|
||
// return errors.New("获取门店信息失败,请重试")
|
||
// }
|
||
// //预处理(1)更新 (2)创建
|
||
// param := &freightTemplate_create_request.FreightTemplateCreateParam{
|
||
// Template: &freightTemplate_create_request.Template{
|
||
// TemplateName: storeDetail.VendorStoreName + "(" + utils.Int2Str(storeID) + ")_",
|
||
// ProductProvince: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
// CalculateType: 2, //计价方式-1.按重量 2.按数量
|
||
// TransferType: 1,
|
||
// RuleType: 1, //固定运费&卖家包邮
|
||
// FixedAmount: 500, //固定运费 单位：分
|
||
// },
|
||
// }
|
||
// //直辖市特殊处理
|
||
// flag := false
|
||
// if storeDetail.CityName == tiktok_api.MunicipalityBeiJin || storeDetail.CityName == tiktok_api.MunicipalityShangHai || storeDetail.CityName == tiktok_api.MunicipalityTianJin || storeDetail.CityName == tiktok_api.MunicipalityChongQing {
|
||
// flag = true
|
||
// param.Template.ProductCity = int64(storeDetail.ProvinceCode)
|
||
// } else {
|
||
// param.Template.ProductCity = int64(storeDetail.CityCode)
|
||
// }
|
||
// if int64(storeDetail.DeliveryFeeDeductionSill) != 0 {
|
||
// param.Template.TemplateName += "满减包邮模板"
|
||
// columns := []freightTemplate_create_request.ColumnsItem{
|
||
// {
|
||
// IsOverFree: true, //是否包邮
|
||
// IsLimited: false,
|
||
// OverAmount: int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储满x包邮金额
|
||
// }}
|
||
// param.Columns = columns
|
||
// if flag {
|
||
// param.Columns[0].ProvinceInfos = []freightTemplate_create_request.ProvinceInfosItem{
|
||
// {
|
||
// Id: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
// Children: []freightTemplate_create_request.ChildrenItem_4{
|
||
// {
|
||
// Id: int64(storeDetail.ProvinceCode),
|
||
// Children: []freightTemplate_create_request.ChildrenItem_5{
|
||
// {
|
||
// Id: int64(storeDetail.DistrictCode),
|
||
// Children: []freightTemplate_create_request.ChildrenItem{
|
||
// {Id: 0},
|
||
// },
|
||
// },
|
||
// },
|
||
// },
|
||
// }},
|
||
// }
|
||
// } else {
|
||
// param.Columns[0].ProvinceInfos = []freightTemplate_create_request.ProvinceInfosItem{
|
||
// {
|
||
// Id: utils.Str2Int64(utils.Int2Str(storeDetail.ProvinceCode)[:2]),
|
||
// Children: []freightTemplate_create_request.ChildrenItem_4{
|
||
// {
|
||
// Id: int64(storeDetail.CityCode),
|
||
// Children: []freightTemplate_create_request.ChildrenItem_5{
|
||
// {
|
||
// Id: int64(storeDetail.DistrictCode),
|
||
// Children: []freightTemplate_create_request.ChildrenItem{
|
||
// {Id: 0},
|
||
// },
|
||
// },
|
||
// },
|
||
// },
|
||
// }},
|
||
// }
|
||
// }
|
||
// } else {
|
||
// param.Columns = nil
|
||
// param.Template.TemplateName += "固定运费模板"
|
||
// }
|
||
// globals.SugarLogger.Debugf(" param.Template.ProductCity==%d,param.Template.ProductProvince==%d", param.Template.ProductCity, param.Template.ProductProvince)
|
||
// resp, err := getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateCreate(param)
|
||
// if err != nil {
|
||
// return 0, err
|
||
// }
|
||
// return resp.TemplateId, nil
|
||
//
|
||
// bindInfo := &shop_bindStoreFreight_request.ShopBindStoreFreightParam{
|
||
// StoreId: vendorStoreID,
|
||
// FreightId: resp.TemplateId,
|
||
// }
|
||
// err = api.BindFreightTemplate(bindInfo)
|
||
// if err != nil {
|
||
// return err
|
||
// }
|
||
// //并写入数据库
|
||
// freightInfo := model.FreightTemplate{
|
||
// StoreID: int(storeID),
|
||
// VendorStoreID: utils.Int64ToStr(vendorStoreID),
|
||
// TemplateID: resp.TemplateId,
|
||
// }
|
||
// if err = dao.CreateEntity(db, freightInfo); err != nil {
|
||
// return err
|
||
// }
|
||
// return nil
|
||
//}
|
||
|
||
// /shop/bindStoreFreight 门店绑定运费模版
|
||
//门店绑定运费模版，运费模版必须属于门店关联的抖店，且门店与运费模版是一对一关系
|
||
func ShopBindStoreFreight(vendorOrgCode string, storeID, freightID int64) error {
|
||
if err := getAPI(vendorOrgCode, int(storeID), "").BindFreightTemplate(&shop_bindStoreFreight_request.ShopBindStoreFreightParam{
|
||
StoreId: storeID,
|
||
FreightId: freightID,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// /shop/getStoreFreight 获取门店绑定运费模板
|
||
func GetStoreFreight(vendorOrgCode string, storeID int64) (int64, error) {
|
||
if resp, err := getAPI(vendorOrgCode, int(storeID), "").GetStoreFreight(storeID); err != nil || len(resp) == 0 {
|
||
return 0, err
|
||
} else {
|
||
return resp[0], nil
|
||
}
|
||
}
|
||
|
||
// /address/create 创建店铺地址库（新建即绑定）
|
||
func (P *PurchaseHandler) CreateAddress(appOrgCode string, addressInfo address_create_request.AddressCreateParam) (addressID int64, err error) {
|
||
if resp, err := getAPI(appOrgCode, 0, utils.Int64ToStr(addressInfo.StoreId)).AddressCreate(&address_create_request.AddressCreateParam{
|
||
Address: addressInfo.Address,
|
||
StoreId: addressInfo.StoreId,
|
||
}); err != nil {
|
||
return 0, err
|
||
} else {
|
||
return resp.AddressId, nil
|
||
}
|
||
}
|
||
|
||
// /address/list 获取售后地址列表接口
|
||
//分页获取商家地址列表
|
||
func (P *PurchaseHandler) GetAddressList(appOrgCode string, param *address_list_request.AddressListParam) (*address_list_response.AddressListData, error) {
|
||
//不传入ID则是获取所有门店售后地址列表
|
||
info := &address_list_request.AddressListParam{
|
||
PageSize: 10,
|
||
PageNo: 1,
|
||
OrderBy: param.OrderBy,
|
||
OrderField: param.OrderField,
|
||
}
|
||
if param.StoreId != 0 {
|
||
info.StoreId = param.StoreId
|
||
}
|
||
if listInfo, err := getAPI(appOrgCode, 0, utils.Int64ToStr(info.StoreId)).GetAddressList(info); err != nil {
|
||
return nil, err
|
||
} else {
|
||
return listInfo, nil
|
||
}
|
||
}
|
||
|
||
// /trade/createTradeLimitTemplate 创建限售模板 默认模板 暂时不使用
|
||
func CreateTradeLimitTemplate(appOrgCode string, vendorStoreID int64) (tradeLimitID int64, err error) {
|
||
param := &trade_createTradeLimitTemplate_request.TradeCreateTradeLimitTemplateParam{
|
||
StoreId: vendorStoreID,
|
||
TradeLimitRuleRequestList: []trade_createTradeLimitTemplate_request.TradeLimitRuleRequestListItem{
|
||
{
|
||
TradeLimitModel: tiktok_api.TradeLimitModelQuantity,
|
||
TradeLimitResource: tiktok_api.TradeLimitResourceDouDian,
|
||
TradeLimitPattern: &trade_createTradeLimitTemplate_request.TradeLimitPattern{
|
||
Minimum: 1,
|
||
Maximum: 1000,
|
||
CumulativeMax: 10000,
|
||
},
|
||
TradeLimitSubjectList: []int32{tiktok_api.TradeLimitSubjectBuyMobile},
|
||
},
|
||
},
|
||
}
|
||
resp, err := getAPI(appOrgCode, 0, utils.Int64ToStr(vendorStoreID)).CreateTradeLimitTemplate(param)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return resp.TradeLimitId, nil
|
||
}
|
||
|
||
//创建起送价的 运费模板以及绑定
|
||
func CreateAndBindMinPriceTemplate(vendorOrgCode string, vendorStoreID, minimum int64) (int64, error) {
|
||
resp, err := getAPI(vendorOrgCode, 0, "").CreateTradeLimitTemplate(&trade_createTradeLimitTemplate_request.TradeCreateTradeLimitTemplateParam{
|
||
StoreId: vendorStoreID,
|
||
TradeLimitRuleRequestList: []trade_createTradeLimitTemplate_request.TradeLimitRuleRequestListItem{
|
||
{
|
||
TradeLimitModel: tiktok_api.TradeLimitModelMoney,
|
||
TradeLimitPattern: &trade_createTradeLimitTemplate_request.TradeLimitPattern{
|
||
Minimum: minimum,
|
||
},
|
||
TradeLimitSubjectList: []int32{
|
||
tiktok_api.TradeLimitSubjectEndUser,
|
||
tiktok_api.TradeLimitSubjectUserGroup,
|
||
tiktok_api.TradeLimitSubjectDevice,
|
||
tiktok_api.TradeLimitSubjectBuyMobile,
|
||
tiktok_api.TradeLimitSubjectReceivingMobile,
|
||
tiktok_api.TradeLimitSubjectIDCard,
|
||
tiktok_api.TradeLimitSubjectPayAccount,
|
||
},
|
||
},
|
||
},
|
||
})
|
||
if err != nil || resp.TradeLimitId == 0 {
|
||
return 0, errors.New(fmt.Sprintf("创建门店(%d)的起送价失败：%v", vendorStoreID, err))
|
||
} else { //绑定
|
||
if err := BindStoreSaleLimit(vendorOrgCode, vendorStoreID, resp.TradeLimitId); err != nil {
|
||
return 0, errors.New(fmt.Sprintf("门店(%d)绑定 起送价限售模板失败：%v", vendorStoreID, err))
|
||
}
|
||
}
|
||
return resp.TradeLimitId, nil
|
||
}
|
||
|
||
// /trade/UpdateTradeLimitTemplate 更新限售模板 目前只做起送价
|
||
func UpdateTradeLimitTemplate(vendorOrgCode string, tradeLimitID, minPrice int64) (int64, error) {
|
||
if updateTradeLimit, err := getAPI(vendorOrgCode, 0, "").UpdateTradeLimitTemplate(&trade_UpdateTradeLimitTemplate_request.TradeUpdateTradeLimitTemplateParam{
|
||
TradeLimitTemplateId: tradeLimitID,
|
||
TradeLimitRuleRequestList: []trade_UpdateTradeLimitTemplate_request.TradeLimitRuleRequestListItem{
|
||
{
|
||
TradeLimitModel: tiktok_api.TradeLimitModelMoney,
|
||
TradeLimitPattern: &trade_UpdateTradeLimitTemplate_request.TradeLimitPattern{
|
||
Minimum: minPrice,
|
||
},
|
||
},
|
||
},
|
||
}); err != nil {
|
||
return 0, err
|
||
} else if updateTradeLimit.TradeLimitTemplateId == 0 {
|
||
return 0, errors.New(fmt.Sprintf("更新操作返回的TradeLimitTemplateId=0"))
|
||
} else {
|
||
return updateTradeLimit.TradeLimitTemplateId, nil
|
||
}
|
||
}
|
||
|
||
// /shop/bindStoreSaleLimit 门店绑定限售模板
|
||
func BindStoreSaleLimit(appOrgCode string, storeID, saleLimitTemplateID int64) error {
|
||
if err := getAPI(appOrgCode, 0, utils.Int64ToStr(storeID)).BindStoreSaleLimit(&shop_bindStoreSaleLimit_request.ShopBindStoreSaleLimitParam{
|
||
StoreId: storeID,
|
||
SaleLimitId: saleLimitTemplateID,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 获取门店绑定限售模板
|
||
func GetStoreSaleLimit(appOrgCode string, storeID int64) (int64, error) {
|
||
saleLimitTemplateID, err := getAPI(appOrgCode, 0, "").StoreQuerySaleLimitTemp(storeID)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return saleLimitTemplateID, nil
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreOpTime(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, opTimeList []int16) (err error) {
|
||
var (
|
||
timeStr = ""
|
||
t1 = opTimeList[0]
|
||
t2 = opTimeList[1]
|
||
t3 = opTimeList[2]
|
||
t4 = opTimeList[4]
|
||
m = make(map[int64]string)
|
||
)
|
||
if t1 != 0 && t2 != 0 {
|
||
if t3 != 0 && t4 != 0 {
|
||
timeStr = SplicingTimeToDoudian(t1, t2, t3, t4, true)
|
||
} else {
|
||
timeStr = SplicingTimeToDoudian(t1, t2, t3, t4, false)
|
||
}
|
||
} else {
|
||
return fmt.Errorf("营业时间必填")
|
||
}
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
if globals.EnableDdStoreWrite {
|
||
err = getAPI(vendorOrgCode, storeID, vendorStoreID).EditStore(&shop_editStore_request.ShopEditStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
OpenTime: &shop_editStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
})
|
||
}
|
||
return err
|
||
}
|
||
|
||
//获取门店状态
|
||
func (P *PurchaseHandler) GetStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string) (storeStatus int, err error) {
|
||
if result, err := getAPI(vendorOrgCode, storeID, vendorStoreID).GetStoreDetail(&shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
IsNeedChargeInfo: false,
|
||
IsNeedPoiAuditInfo: false,
|
||
IsNeedRelShopUser: false,
|
||
}); err != nil {
|
||
return 0, err
|
||
} else {
|
||
poiStatus := int(result.StoreDetail.Store.PoiAuditState)
|
||
return poiStatus, nil
|
||
}
|
||
}
|
||
|
||
func (P *PurchaseHandler) EnableAutoAcceptOrder(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, isSetEnable bool) (err error) {
|
||
return err
|
||
}
|
||
|
||
// 获取店铺所有平台ID
|
||
func (P *PurchaseHandler) GetAllStoresVendorID(ctx *jxcontext.Context, vendorOrgCode string) (vendorStoreIDs []string, err error) {
|
||
//param := &shop_getStoreList_request.ShopGetStoreListParam{
|
||
// Page: "0",
|
||
// PageSize: "20",
|
||
//}
|
||
//if stores, err := getAPI(vendorOrgCode, 0, "").GetStoreList(param); err != nil || stores.Total == 0 {
|
||
// return nil, errors.New(fmt.Sprintf("暂时无门店数据返回，请重试:%v", err))
|
||
//}
|
||
//else if len(stores.StoreDetailList) > 0 {
|
||
// vendorStoreIDs = make([]string, len(stores.StoreDetailList))
|
||
// for k, v := range stores.StoreDetailList {
|
||
// vendorStoreIDs[k] = utils.Int64ToStr(v.Store.StoreId)
|
||
// }
|
||
//}
|
||
//return vendorStoreIDs, err
|
||
return nil, err
|
||
}
|
||
|
||
//获取京西 抖店门店映射关系
|
||
func GetAllVendorStoreMap(ctx *jxcontext.Context, vendorOrgCode string) (map[int64]string, error) {
|
||
param := &shop_getStoreList_request.ShopGetStoreListParam{
|
||
Page: "0",
|
||
PageSize: "20",
|
||
}
|
||
if stores, err := getAPI(vendorOrgCode, 0, "").GetStoreList(param); err != nil || len(stores) == 0 {
|
||
return nil, errors.New(fmt.Sprintf("暂时无门店数据返回，请重试:%v", err))
|
||
} else {
|
||
return stores, err
|
||
}
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreLineStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, lineStatus int) (err error) {
|
||
a := getAPI(vendorOrgCode, storeID, vendorStoreID)
|
||
if lineStatus == model.StoreStatusOpened {
|
||
_, err = a.UnsuspendStore(&shop_unsuspendStore_request.ShopUnsuspendStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
})
|
||
} else {
|
||
_, err = a.StoreSuspend(&shop_storeSuspend_request.ShopStoreSuspendParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
})
|
||
}
|
||
return err
|
||
}
|
||
func (P *PurchaseHandler) ReadStore(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID, vendorStoreName string) (store *dao.StoreDetail, err error) {
|
||
vendorStore, err := getAPI(vendorOrgCode, 0, "").GetStoreDetail(&shop_getStoreDetail_request.ShopGetStoreDetailParam{StoreId: utils.Str2Int64(vendorStoreID)})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
retVal := &dao.StoreDetail{
|
||
Store: model.Store{
|
||
Address: vendorStore.StoreDetail.Store.Address,
|
||
Tel1: vendorStore.StoreDetail.Store.Contact,
|
||
},
|
||
}
|
||
retVal.OriginalName = vendorStore.StoreDetail.Store.Name
|
||
_, retVal.Name = jxutils.SplitStoreName(retVal.OriginalName, partner.StoreNameSeparator, globals.StoreNameTiktok)
|
||
retVal.SetTiktokOpenTime(vendorStore.StoreDetail.Store.OpenTime.DayMap[1])
|
||
retVal.Status = bizStatusTiktok2JX(vendorStore.StoreDetail.Store.State)
|
||
retVal.Lng = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Longitude) * 1000000)
|
||
retVal.Lat = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Latitude) * 1000000)
|
||
lng := jxutils.IntCoordinate2Standard(retVal.Lng)
|
||
lat := jxutils.IntCoordinate2Standard(retVal.Lat)
|
||
db := dao.GetDB()
|
||
retVal.DistrictCode = api.AutonaviAPI.GetCoordinateDistrictCode(lng, lat)
|
||
city, err := dao.GetPlaceByCode(db, utils.Str2Int(vendorStore.StoreDetail.Store.CityCode))
|
||
retVal.CityName = city.Name
|
||
retVal.CityCode = utils.Str2Int(vendorStore.StoreDetail.Store.CityCode)
|
||
poiCode := vendorStore.StoreDetail.Store.StoreCode
|
||
retVal.VendorStoreID = vendorStoreID
|
||
retVal.ID = utils.Str2Int(poiCode)
|
||
retVal.DeliveryRangeType = model.DeliveryRangeTypeRadius
|
||
retVal.DeliveryRange = "3000"
|
||
retVal.DeliveryType = scheduler.StoreDeliveryTypeByStore
|
||
return retVal, nil
|
||
}
|
||
|
||
//设置门店打包费
|
||
func SetStorePackageFee(vendorOrgCode string, vendorStoreID, packageFee int64) error {
|
||
if err := getAPI(vendorOrgCode, 0, "").SetStorePackageFee(vendorStoreID, packageFee); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (P *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
|
||
return "", errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
func bizStatusJX2DouDian(status int) (onLine int) {
|
||
if status == model.StoreStatusDisabled || status == model.StoreStatusClosed || status == model.StoreStatusHaveRest {
|
||
return tiktok_api.StoreStatusOffline
|
||
}
|
||
return tiktok_api.StoreStatusOnline
|
||
}
|
||
|
||
func (P *PurchaseHandler) DeleteStore(db *dao.DaoDB, storeID int, userName string) (err error) {
|
||
return errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreCustomID(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID string, storeID int64) (err error) {
|
||
return err
|
||
}
|
||
|
||
func (P *PurchaseHandler) GetOrderStatus(vendorOrgCode, vendorOrderID string) (status int, err error) {
|
||
return 0, errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
func (p *PurchaseHandler) GetSkus(ctx *jxcontext.Context, vendorOrgCode string, skuID int, vendorSkuID string) (skuNameList []*partner.SkuNameInfo, err error) {
|
||
return nil, err
|
||
}
|
||
|
||
//以下为辅助函数
|
||
type RelInfo struct {
|
||
StoreID string
|
||
VendorStoreID string
|
||
}
|
||
|
||
func ToMap(actual interface{}) (map[string]string, error) {
|
||
var res []string
|
||
value := reflect.ValueOf(actual)
|
||
globals.SugarLogger.Debugf("value.Kind()=========%s", value.Kind())
|
||
if value.Kind() != reflect.Map {
|
||
return nil, errors.New("parse error")
|
||
}
|
||
temp := actual.(map[string]string)
|
||
globals.SugarLogger.Debugf("toMap temp===============%v", temp)
|
||
for i := 0; i < value.Len(); i++ {
|
||
res = append(res, value.Index(i).Interface().(string))
|
||
}
|
||
return temp, nil
|
||
}
|